This file is indexed.

/usr/include/opencollada/COLLADAStreamWriter/COLLADASWInstanceMaterial.h is in opencollada-dev 0.1.0~20140703.ddf8f47+dfsg1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/*
    Copyright (c) 2008-2009 NetAllied Systems GmbH

	This file is part of COLLADAStreamWriter.
	
    Licensed under the MIT Open Source License, 
    for details please see LICENSE file or the website
    http://www.opensource.org/licenses/mit-license.php
*/

#ifndef __COLLADASTREAMWRITER_INSTANCE_MATERIAL_H__
#define __COLLADASTREAMWRITER_INSTANCE_MATERIAL_H__

#include "COLLADASWPrerequisites.h"
#include "COLLADASWElementWriter.h"
#include "COLLADASWConstants.h"

#include "COLLADABUURI.h"


namespace COLLADASW
{

    class BindVertexInput
	{
	private:
		/** Which effect parameter to bind. Required.*/
		String mSemantic;

		/** Which input semantic to bind. Required.*/
		String mInputSemantic;

		/** Which input set to bind. Optional. -1 if not set.*/
		int mInputSet;
	public:

		BindVertexInput(const COLLADASW::String& semantic, const COLLADASW::String& inputSemantic, int inputSet = -1)
			: mSemantic(semantic), mInputSemantic(inputSemantic), mInputSet(inputSet){}

		/** Which effect parameter to bind. Required.*/
		const COLLADASW::String& getSemantic() const { return mSemantic; }

		/** Which effect parameter to bind. Required.*/
		void setSemantic(const COLLADASW::String& semantic) { mSemantic = semantic; }

		/** Which input semantic to bind. Required.*/
		const COLLADASW::String& getInputSemantic() const { return mInputSemantic; }

		/** Which input semantic to bind. Required.*/
		void setInputSemantic(const COLLADASW::String& inputSemantic) { mInputSemantic = inputSemantic; }
		
		/** Which input set to bind. Optional. -1 if not set.*/
		int getInputSet() const { return mInputSet; }

		/** Which input set to bind. Optional. -1 if not set.*/
		void setInputSet(int inputSet) { mInputSet = inputSet; }

	private:
		/** Set this class a friend, so it can call the add() method.  */
		friend class InstanceMaterial;

		/** Add all the instance materials, added using push_back(), to the stream*/
		void add( StreamWriter* sw);

	};


    class InstanceMaterialList;

    /** A class that holds informations of an @a \<instance_material\> element*/
    class InstanceMaterial
    {
	private:
		/** List of all the BindVertexInput*/
		typedef std::list<BindVertexInput> BindVertexInputList;
    private:

		BindVertexInputList mBindVertexInputList;
        String mSymbol;
        URI mTarget;

    public:

        /** Constructor
        @param symbol The symbol name
        @param target The target
        */
        InstanceMaterial ( const String& symbol, const URI& target ) 
        : mSymbol ( symbol ), mTarget ( target ) {}

        /** Returns the symbol*/
        const String & getSymbol() const {return mSymbol; }

        /** Returns the target*/
        const URI & getTarget() const { return mTarget; }

		/** Adds @a input to list of inputs that should be added*/
		void push_back ( const BindVertexInput& input ) { mBindVertexInputList.push_back ( input ); }

	private:
		/** Set this class a friend, so it can call the add() method.  */
		friend class InstanceMaterialList;

		/** Add all the instance materials, added using push_back(), to the stream*/
		void add( StreamWriter* sw);


    };

    /** A class that hold a list of instances of InstanceMaterial and writes it to stream*/
    class InstanceMaterialList : public ElementWriter
    {

    public:
        /** Constructor
        @param streamWriter The stream writer the list should be written to
        */
        InstanceMaterialList ( StreamWriter * streamWriter ) : ElementWriter ( streamWriter ) {}

        /** Destructor*/
        virtual ~InstanceMaterialList() {}

        /** Adds @a input to list of inputs that should be added*/
        void push_back ( const InstanceMaterial& input ) { mList.push_back ( input ); }

		/** Returns a reference to the last InstanceMaterial in the list. The material list must not be empty.*/
		InstanceMaterial& back() { return mList.back(); }

        /** Return true, if the list of material bindings is empty, false otherwise*/
        bool empty() const { return mList.empty(); }

    private:

        /** Set this class a friend, so it can call the add() method.  */
        friend class BindMaterial;

        /** List of all the inputs*/
        typedef std::list<InstanceMaterial> List;
        List mList;

        /** Add all the instance materials, added using push_back(), to the stream*/
        void add();

    };

} //namespace COLLADASW


#endif //__COLLADASTREAMWRITER_INSTANCE_MATERIAL_H__