This file is indexed.

/usr/include/CLAM/Enum.hxx is in libclam-dev 1.4.0-7.

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef _ENUM_H_
#define _ENUM_H_
#include <exception>
#include <iosfwd>
#include <string>
#include "Assert.hxx"
#include "Component.hxx"

namespace CLAM {

// TODO: Integrate this excepcion class with CLAM exception standards
class IllegalValue : public std::exception {
	public:
		IllegalValue(const IllegalValue & e): msg(e.msg) {};
		IllegalValue(const std::string & s) : msg(s) {};
		virtual ~IllegalValue() throw() {};
		std::string msg;
};


/**
 * Instances of this class represents objects that can adquire 
 * a symbolic value from a limited set of symbolic values.
 *
 * Enum provides more features that the C \c enum with a
 * very little overhead:
 *
 * - Run-time symbolic representation
 * - Assignment to both simbolic and numeric values
 * - Run-time checking of values on debug mode
 * - Formated input and output to an std::stream as symbol
 * - Implements the Component interface
 * 
 * The way to define an enumerated type is by subclassing 
 * Enum.
 *
 * The subclass MUST redefine its constructors by 
 * providing the Enum constructor an array of tEnumValue's,
 * which defines the mapping between numeric and symbolic 
 * values, and an initialization value, than can be both a 
 * symbol (char* or std::string) or an integer.
 * 
@code
// EMyEnum.hxx
class EMyEnum : public CLAM::Enum {
public:
	EMyEnum() : CLAM::Enum(ValueTable(), eTwo) {}
	EMyEnum(tValue v) : CLAM::Enum(ValueTable(), v) {};
	EMyEnum(const std::string & s) : CLAM::Enum(ValueTable(), s) {};

	virtual CLAM::Component * Species() const {return new EMyEnum();}

	typedef enum {
		eZero=0,
		eTwo=2,
		eHundred=100
	} tEnum;
	static tEnumValue * ValueTable()
	{
		static tEnumValue sValueTable[] = 
		{
			{eZero,"zero"},
			{eTwo,"two"},
			{eHundred,"hundred"},
			{0,NULL}
		};
		return sValueTable;
	}
};
@endcode
 */
class Enum : public Component {

// Internal Types
public:
	typedef int tValue;
	typedef struct {tValue value; const char*name;} tEnumValue;

// Attributes
private:
	const tEnumValue * mEnumValues;
	tValue mValue;

/** @name Construction/Destruction */
//@{

protected:
	/**
	 * Construction with a numeric value.
	 * @param values An array of tEnumValue structures in wich the last
	 * one has a NULL pointer as name.
	 * @param value An initialization numeric value.
	 * @throw A IllegalValue exception when the value is not valid.
	 */
	Enum (const tEnumValue * values, const tValue & value) /* throw IllegalValue */ {
		mEnumValues = values;
		SetValue(value);
	}
	/**
	 * Construction with a symbolic value.
	 * @param values An array of tEnumValue structures in wich the last
	 * one has a NULL pointer as name.
	 * @param value An initialization symbolic value.
	 * @throw A IllegalValue exception when the value is not valid.
	 */
	Enum (const tEnumValue * values, const std::string & value) /* throw IllegalValue */ {
		mEnumValues = values;
		SetValue(value);
	};
public:
	/** The required virtual destructor */
	virtual ~Enum ();
	const char * GetClassName() const {return NULL;}
//@}

// Operations
public:
	/**
	 * Returns the symbol map for the enum
	 */
	const tEnumValue * GetSymbolMap() const {
		return mEnumValues;
	}

	/**
	 * Changes the value.
	 * @param v The new numeric value
	 */
	void SetValue(const tValue v) {
		CLAM_BEGIN_DEBUG_CHECK
			for (int i = 0; mEnumValues[i].name; i++) {
				if (v==mEnumValues[i].value) {
					mValue = v;
					return;
				}
			}
			CLAM_ASSERT(false, "Invalid value for an Enum");
		CLAM_END_DEBUG_CHECK
		mValue = v; 
	}
	/**
	 * Changes the value safely. 
	 * That is it checks the value is ok for the enum and throws a
	 * catchable exception if not.
	 * @param v The new numeric value
	 * @throw IllegalValue when the value is not valid for the enum
	 * @todo Fill IllegalValue with useful information to recover 
	 * instead a insightfull string.
	 */
	void SetValueSafely(const tValue v) throw (IllegalValue) {
		for (int i = 0; mEnumValues[i].name; i++) {
			if (v==mEnumValues[i].value) {
				mValue = v;
				return;
			}
		}
		throw IllegalValue("Invalid value for an Enum");
	}
	/**
	 * Changes the value.
	 * @param s The new symbolic value
	 */
	void SetValue(const std::string & s) 
	{
		for (int i = 0; mEnumValues[i].name; i++) {
			if (s.compare(mEnumValues[i].name)==0) {
				mValue = mEnumValues[i].value;
				return;
			}
		}
		CLAM_ASSERT(false, "Illegal literal for an Enum");
	}
	/*
	 * Changes the value safely. 
	 * That is it checks the value is ok for the enum and throws a
	 * catchable exception if not.
	 * @param s The new symbolic value
	 * @throw IllegalValue when the value is not valid for the enum
	 * @todo Fill IllegalValue with useful information to recover 
	 * instead a insightfull string.
	 */
	void SetValueSafely(const std::string & s) throw (IllegalValue) 
	{
		for (int i = 0; mEnumValues[i].name; i++) {
			if (s.compare(mEnumValues[i].name)==0) {
				mValue = mEnumValues[i].value;
				return;
			}
		}
		throw IllegalValue("Illegal literal for an Enum.");
	}

	/**
	 * Returns the numeric value.
	 * @returns The numeric value
	 */
	tValue GetValue() const {
		return mValue;
	}

	/**
	 * Returns the symbolic value.
	 * @returns The symbolic value
	 */
	std::string GetString() const throw (IllegalValue)
	{
		for (int i = 0; mEnumValues[i].name; i++) {
			if (mValue==mEnumValues[i].value) 
				return mEnumValues[i].name;
		}
		CLAM_ASSERT(false, "Illegal numeric value for an Enum");
		return "IllegalValue";
	}

	Enum & operator = (const tValue & v) throw (IllegalValue) {
		SetValue(v);
		return *this;
	}

	Enum & operator = (const std::string & v) throw (IllegalValue) {
		SetValue(v);
		return *this;
	}

	Enum & operator = (const Enum & v) throw (IllegalValue) {
		SetValue(tValue(v));
		return *this;
	}

	/**
	 * Conversion operiation as a number.
	 * @returns The numeric value
	 */
	operator tValue() const {
		return mValue;
	}

// Component Protocol
public:
	/**
	 * Returns a new object of the same class than the receiver
	 * object. To be reimplemented by subclasses.
	 * @returns a new allocated component. The pointer belongs
	 * to the caller.
	 */
	virtual Component * Species () const = 0;

	/**
	 * TODO: Copy documentation for this method from Component 
	 */
	virtual Component * DeepCopy () const {
		Enum * pe = (Enum*)Species();
		pe->SetValue(mValue);
		return pe;
	}

	/**
	 * TODO: Copy documentation for this method from Component 
	 */
	virtual Component * ShallowCopy () const {
		Enum * pe = (Enum*)Species();
		pe->SetValue(mValue);
		return pe;
	}

	/** 
	 * Stores component's subitems on the given Storage
	 * @param storage The given storage where the subitem will be stored
	 * @see Storage
	 * TODO: This method can throw and IllegalValue exception
	 */

	virtual void StoreOn (Storage & storage) const;

	/** 
	 * Loads component's subitems from the given Storage
	 * @param storage The given storage where the subitem will be stored
	 * @see Storage
	 * TODO: This method can throw and IllegalValue exception
	 */

	virtual void LoadFrom (Storage & storage);


};

/**
 * Stores the symbolic value of an Enum to the output stream.
 * @param os The output stream
 * @param e The Enum
 * @returns The output stream
 */
std::ostream & operator << (std::ostream & os, const Enum & e) throw (IllegalValue);

/**
 * Loads a symbolic value from the input stream onto an Enum.
 * @param os The input stream
 * @param e The Enum
 * @returns The input stream
 */
std::istream & operator >> (std::istream & os, Enum & e) throw (IllegalValue);

}
#endif // _ENUM_H_