[u/mrichter/AliRoot.git] / SHUTTLE / AliSimpleValue.h

#ifndef ALI_SIMPLE_VALUE_H
#define ALI_SIMPLE_VALUE_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

//
// This class is a simple wrapper of
// all primitive types used in PVSS SCADA system.
//

#include <TObject.h>
#include <TString.h>

class AliSimpleValue: public TObject {
public:
	enum Type {
		kInvalid = 0,
		kBool = 1,
		kByte = 2,
		kInt = 3,
		kUInt = 4,
		kFloat = 5,
		kDynBool = 11,
		kDynByte = 12,
		kDynInt = 13,
		kDynUInt = 14,
		kDynFloat = 15
	};	


	AliSimpleValue();

        AliSimpleValue(const AliSimpleValue& other);

        AliSimpleValue(Type type, Int_t size = 0);

        AliSimpleValue(Bool_t val);

        AliSimpleValue(Char_t val);

        AliSimpleValue(Int_t val);

        AliSimpleValue(UInt_t val);

        AliSimpleValue(Float_t val);

        AliSimpleValue(Int_t size, const Bool_t* vals);

        AliSimpleValue(Int_t size, const Char_t* vals);

        AliSimpleValue(Int_t size, const Int_t* vals);

        AliSimpleValue(Int_t size, const UInt_t* vals);

        AliSimpleValue(Int_t size, const Float_t* vals);

        ~AliSimpleValue();


        AliSimpleValue& operator=(const AliSimpleValue& other);

        Bool_t operator==(const AliSimpleValue& other) const;

        void SetBool(Bool_t val);

        void SetByte(Char_t val);

        void SetInt(Int_t val);

        void SetUInt(UInt_t val);

        void SetFloat(Float_t val);


        Bool_t GetBool() const;

        Char_t GetByte() const;

        Int_t GetInt() const;

        UInt_t GetUInt() const;

        Float_t GetFloat() const;


	void SetDynBool(Int_t n, Bool_t val);

        void SetDynByte(Int_t n, Char_t val);

        void SetDynInt(Int_t n, Int_t val);

        void SetDynUInt(Int_t n, UInt_t val);

        void SetDynFloat(Int_t n, Float_t val);


        Bool_t GetDynBool(Int_t n) const;

        Char_t GetDynByte(Int_t n) const;

        Int_t GetDynInt(Int_t n) const;

        UInt_t GetDynUInt(Int_t n) const;

        Float_t GetDynFloat(Int_t n) const;


        Type GetType() const {return fType;};

        Int_t GetSize() const;

        Int_t GetDynamicSize() const;

        TString ToString() const;


        static Bool_t IsDynamic(Type type);

        static Int_t GetPrimitiveSize(Type type);

        static const char* GetTypeString(Type type);

private:

	class BoolHolder: public TObject {
	public:
		Bool_t fValue;

		BoolHolder() {}

		BoolHolder(Bool_t val):fValue(val) {}
		
		virtual TObject* Clone(const char* name) const; 
	
		virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(BoolHolder, 1);
	};

	class ByteHolder: public TObject {
	public:
		Char_t fValue;

		ByteHolder() {};

		ByteHolder(Char_t val):fValue(val) {}
		
		virtual TObject* Clone(const char* name) const;

		virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(ByteHolder, 1);
	};

	class IntHolder: public TObject {
	public:
		Int_t fValue;

		IntHolder() {}

		IntHolder(Int_t val):fValue(val) {}
		
		virtual TObject* Clone(const char* name) const; 

		virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(IntHolder, 1);
	};

	class UIntHolder: public TObject {
	public:
		UInt_t fValue;

		UIntHolder() {}

		UIntHolder(UInt_t val):fValue(val) {}
		
		virtual TObject* Clone(const char* name) const;

		virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(UIntHolder, 1);
	};

	class FloatHolder: public TObject {
	public:
		Float_t fValue;

		FloatHolder() {}
	
		FloatHolder(Float_t val):fValue(val) {}
		
		virtual TObject* Clone(const char* name) const;

		virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(FloatHolder, 1);
	};

	class DynHolder: public TObject {
	public:
		Int_t fSize;

		DynHolder(): fSize(0) {}
		DynHolder(Int_t size): fSize(size){}

		ClassDef(DynHolder, 0);
	};

	class DynBoolHolder: public DynHolder {
	public:
		Bool_t* fValues; //[fSize]

		DynBoolHolder(): fValues(NULL) {}

		DynBoolHolder(Int_t size, const Bool_t* buf = NULL):
			DynHolder(size) {
			fValues = new Bool_t[size];
			if (buf) memcpy(fValues, buf, size * sizeof(Bool_t));
		}

		virtual ~DynBoolHolder() {if (fValues) delete[] fValues;}

		virtual TObject* Clone(const char* name) const;

                virtual Bool_t IsEqual(const TObject* object) const; 

		ClassDef(DynBoolHolder, 1);
	};

	class DynByteHolder: public DynHolder {
	public:
		Char_t* fValues; //[fSize]
	
		DynByteHolder(): fValues(NULL) {}

		DynByteHolder(Int_t size, const Char_t* buf = NULL):
			DynHolder(size) {
			fValues = new Char_t[size];
			if (buf) memcpy(fValues, buf, size * sizeof(Char_t));
		}

		virtual ~DynByteHolder() {if (fValues) delete[] fValues;}

		virtual TObject* Clone(const char* name) const;

                virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(DynByteHolder, 1);
	};

	class DynIntHolder: public DynHolder {
	public:
		Int_t* fValues; //[fSize]

		DynIntHolder(): fValues(NULL) {}

		DynIntHolder(Int_t size, const Int_t* buf = NULL):
			DynHolder(size) {
			fValues = new Int_t[size];
			if (buf) memcpy(fValues, buf, size * sizeof(Int_t));
		}

		virtual ~DynIntHolder() {if (fValues) delete[] fValues;}

		virtual TObject* Clone(const char* name) const;

                virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(DynIntHolder, 1);
	};

	class DynUIntHolder: public DynHolder {
	public:
		UInt_t* fValues; //[fSize]

		DynUIntHolder(): fValues(NULL) {}

		DynUIntHolder(Int_t size, const UInt_t* buf = NULL):
			DynHolder(size) {
			fValues = new UInt_t[size];
			if (buf) memcpy(fValues, buf, size * sizeof(UInt_t));	
		} 

		virtual ~DynUIntHolder() {if (fValues) delete[] fValues;}

		virtual TObject* Clone(const char* name) const;

                virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(DynUIntHolder, 1);
	};

	class DynFloatHolder: public DynHolder {
	public:
		Float_t* fValues; //[fSize]

		DynFloatHolder(): fValues(NULL) {}

		DynFloatHolder(Int_t size, const Float_t* buf = NULL):
			DynHolder(size) {
			fValues = new Float_t[size];
			if (buf) memcpy(fValues, buf, size * sizeof(Float_t));
		}

		virtual ~DynFloatHolder() {if (fValues) delete[] fValues;}

		virtual TObject* Clone(const char* name) const;

                virtual Bool_t IsEqual(const TObject* object) const;

		ClassDef(DynFloatHolder, 1);
	};


	TObject* fHolder;

	Type fType;


	Bool_t TypeOk(Type type) const;

	Bool_t BoundsOk(Int_t n) const;


	ClassDef(AliSimpleValue, 1);
};

#endif
Commit	Line	Data
73abe331	1	#ifndef ALI_SIMPLE_VALUE_H
	2	#define ALI_SIMPLE_VALUE_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	/* $Id$ */
	8
	9	//
	10	// This class is a simple wrapper of
	11	// all primitive types used in PVSS SCADA system.
	12	//
	13
	14	#include <TObject.h>
	15	#include <TString.h>
	16
	17	class AliSimpleValue: public TObject {
	18	public:
	19	enum Type {
	20	kInvalid = 0,
	21	kBool = 1,
	22	kByte = 2,
	23	kInt = 3,
	24	kUInt = 4,
	25	kFloat = 5,
	26	kDynBool = 11,
	27	kDynByte = 12,
	28	kDynInt = 13,
	29	kDynUInt = 14,
	30	kDynFloat = 15
	31	};
	32
	33
	34	AliSimpleValue();
	35
	36	AliSimpleValue(const AliSimpleValue& other);
	37
	38	AliSimpleValue(Type type, Int_t size = 0);
	39
	40	AliSimpleValue(Bool_t val);
	41
	42	AliSimpleValue(Char_t val);
	43
	44	AliSimpleValue(Int_t val);
	45
	46	AliSimpleValue(UInt_t val);
	47
	48	AliSimpleValue(Float_t val);
	49
	50	AliSimpleValue(Int_t size, const Bool_t* vals);
	51
	52	AliSimpleValue(Int_t size, const Char_t* vals);
	53
	54	AliSimpleValue(Int_t size, const Int_t* vals);
	55
	56	AliSimpleValue(Int_t size, const UInt_t* vals);
	57
	58	AliSimpleValue(Int_t size, const Float_t* vals);
	59
	60	~AliSimpleValue();
	61
	62
	63	AliSimpleValue& operator=(const AliSimpleValue& other);
	64
65	Bool_t operator==(const AliSimpleValue& other) const;
66
67	void SetBool(Bool_t val);
68
69	void SetByte(Char_t val);
70
71	void SetInt(Int_t val);
72
73	void SetUInt(UInt_t val);
74
75	void SetFloat(Float_t val);
76
77
78	Bool_t GetBool() const;
79
80	Char_t GetByte() const;
81
82	Int_t GetInt() const;
83
84	UInt_t GetUInt() const;
85
86	Float_t GetFloat() const;
87
88
89	void SetDynBool(Int_t n, Bool_t val);
90
91	void SetDynByte(Int_t n, Char_t val);
92
93	void SetDynInt(Int_t n, Int_t val);
94
95	void SetDynUInt(Int_t n, UInt_t val);
96
97	void SetDynFloat(Int_t n, Float_t val);
98
99
100	Bool_t GetDynBool(Int_t n) const;
101
102	Char_t GetDynByte(Int_t n) const;
103
104	Int_t GetDynInt(Int_t n) const;
105
106	UInt_t GetDynUInt(Int_t n) const;
107
108	Float_t GetDynFloat(Int_t n) const;
109
110
111	Type GetType() const {return fType;};
112
113	Int_t GetSize() const;
114
115	Int_t GetDynamicSize() const;
116
117	TString ToString() const;
118
119
120	static Bool_t IsDynamic(Type type);
121
122	static Int_t GetPrimitiveSize(Type type);
123
124	static const char* GetTypeString(Type type);
125
126	private:
127
128	class BoolHolder: public TObject {
129	public:
130	Bool_t fValue;
131
132	BoolHolder() {}
133
134	BoolHolder(Bool_t val):fValue(val) {}
135
136	virtual TObject* Clone(const char* name) const;
137
138	virtual Bool_t IsEqual(const TObject* object) const;
139
140	ClassDef(BoolHolder, 1);
141	};
142
143	class ByteHolder: public TObject {
144	public:
145	Char_t fValue;
146
147	ByteHolder() {};
148
149	ByteHolder(Char_t val):fValue(val) {}
150
151	virtual TObject* Clone(const char* name) const;
152
153	virtual Bool_t IsEqual(const TObject* object) const;
154
155	ClassDef(ByteHolder, 1);
156	};
157
158	class IntHolder: public TObject {
159	public:
160	Int_t fValue;
161
162	IntHolder() {}
163
164	IntHolder(Int_t val):fValue(val) {}
165
166	virtual TObject* Clone(const char* name) const;
167
168	virtual Bool_t IsEqual(const TObject* object) const;
169
170	ClassDef(IntHolder, 1);
171	};
172
173	class UIntHolder: public TObject {
174	public:
175	UInt_t fValue;
176
177	UIntHolder() {}
178
179	UIntHolder(UInt_t val):fValue(val) {}
180
181	virtual TObject* Clone(const char* name) const;
182
183	virtual Bool_t IsEqual(const TObject* object) const;
184
185	ClassDef(UIntHolder, 1);
186	};
187
188	class FloatHolder: public TObject {
189	public:
190	Float_t fValue;
191
192	FloatHolder() {}
193
194	FloatHolder(Float_t val):fValue(val) {}
195
196	virtual TObject* Clone(const char* name) const;
197
198	virtual Bool_t IsEqual(const TObject* object) const;
199
200	ClassDef(FloatHolder, 1);
201	};
202
203	class DynHolder: public TObject {
204	public:
205	Int_t fSize;
206
207	DynHolder(): fSize(0) {}
208	DynHolder(Int_t size): fSize(size){}
209
210	ClassDef(DynHolder, 0);
211	};
212
213	class DynBoolHolder: public DynHolder {
214	public:
215	Bool_t* fValues; //[fSize]
216
217	DynBoolHolder(): fValues(NULL) {}
218
219	DynBoolHolder(Int_t size, const Bool_t* buf = NULL):
220	DynHolder(size) {
221	fValues = new Bool_t[size];
222	if (buf) memcpy(fValues, buf, size * sizeof(Bool_t));
223	}
224
225	virtual ~DynBoolHolder() {if (fValues) delete[] fValues;}
226
227	virtual TObject* Clone(const char* name) const;
228
229	virtual Bool_t IsEqual(const TObject* object) const;
230
231	ClassDef(DynBoolHolder, 1);
232	};
233
234	class DynByteHolder: public DynHolder {
235	public:
236	Char_t* fValues; //[fSize]
237
238	DynByteHolder(): fValues(NULL) {}
239
240	DynByteHolder(Int_t size, const Char_t* buf = NULL):
241	DynHolder(size) {
242	fValues = new Char_t[size];
243	if (buf) memcpy(fValues, buf, size * sizeof(Char_t));
244	}
245
246	virtual ~DynByteHolder() {if (fValues) delete[] fValues;}
247
248	virtual TObject* Clone(const char* name) const;
249
250	virtual Bool_t IsEqual(const TObject* object) const;
251
252	ClassDef(DynByteHolder, 1);
253	};
254
255	class DynIntHolder: public DynHolder {
256	public:
257	Int_t* fValues; //[fSize]
258
259	DynIntHolder(): fValues(NULL) {}
260
261	DynIntHolder(Int_t size, const Int_t* buf = NULL):
262	DynHolder(size) {
263	fValues = new Int_t[size];
264	if (buf) memcpy(fValues, buf, size * sizeof(Int_t));
265	}
266
267	virtual ~DynIntHolder() {if (fValues) delete[] fValues;}
268
269	virtual TObject* Clone(const char* name) const;
270
271	virtual Bool_t IsEqual(const TObject* object) const;
272
273	ClassDef(DynIntHolder, 1);
274	};
275
276	class DynUIntHolder: public DynHolder {
277	public:
278	UInt_t* fValues; //[fSize]
279
280	DynUIntHolder(): fValues(NULL) {}
281
282	DynUIntHolder(Int_t size, const UInt_t* buf = NULL):
283	DynHolder(size) {
284	fValues = new UInt_t[size];
285	if (buf) memcpy(fValues, buf, size * sizeof(UInt_t));
286	}
287
288	virtual ~DynUIntHolder() {if (fValues) delete[] fValues;}
289
290	virtual TObject* Clone(const char* name) const;
291
292	virtual Bool_t IsEqual(const TObject* object) const;
293
294	ClassDef(DynUIntHolder, 1);
295	};
296
297	class DynFloatHolder: public DynHolder {
298	public:
299	Float_t* fValues; //[fSize]
300
301	DynFloatHolder(): fValues(NULL) {}
302
303	DynFloatHolder(Int_t size, const Float_t* buf = NULL):
304	DynHolder(size) {
305	fValues = new Float_t[size];
306	if (buf) memcpy(fValues, buf, size * sizeof(Float_t));
307	}
308
309	virtual ~DynFloatHolder() {if (fValues) delete[] fValues;}
310
311	virtual TObject* Clone(const char* name) const;
312
313	virtual Bool_t IsEqual(const TObject* object) const;
314
315	ClassDef(DynFloatHolder, 1);
316	};
317
318
319	TObject* fHolder;
320
321	Type fType;
322
323
324	Bool_t TypeOk(Type type) const;
325
326	Bool_t BoundsOk(Int_t n) const;
327
328
329	ClassDef(AliSimpleValue, 1);
330	};
331
332	#endif