[u/mrichter/AliRoot.git] / STEER / 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.
// bool, char, byte, int ,uint, float, and arrays of these values
//

#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 AliBoolHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:
		AliBoolHolder() {}
		virtual ~AliBoolHolder() {}

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

	private:
		Bool_t fValue;		// The value

		ClassDef(AliBoolHolder, 1);
	};

	class AliByteHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:

		AliByteHolder() {};
		virtual ~AliByteHolder() {}

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

		virtual Bool_t IsEqual(const TObject* object) const;

	private:
		Char_t fValue;		// The value

		ClassDef(AliByteHolder, 1);
	};

	class AliIntHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:

		AliIntHolder() {}
		virtual ~AliIntHolder() {}

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

		virtual Bool_t IsEqual(const TObject* object) const;


	private:
		Int_t fValue;		// The value

		ClassDef(AliIntHolder, 1);
	};

	class AliUIntHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:

		AliUIntHolder() {}
		virtual ~AliUIntHolder() {}

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

		virtual Bool_t IsEqual(const TObject* object) const;


	private:
		UInt_t fValue;		// The value

		ClassDef(AliUIntHolder, 1);
	};

	class AliFloatHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:

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

		virtual Bool_t IsEqual(const TObject* object) const;

	private:
		Float_t fValue;		// The value

		ClassDef(AliFloatHolder, 1);
	};

	class AliDynHolder: public TObject {
	
	friend class AliSimpleValue;
	
	public:

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

		Int_t fSize;		// The size
		ClassDef(AliDynHolder, 0);
	};

	class AliDynBoolHolder: public AliDynHolder {
	
	friend class AliSimpleValue;
	
	public:

		AliDynBoolHolder(): fValues(NULL) {}

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

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

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

                virtual Bool_t IsEqual(const TObject* object) const; 


	private:
		AliDynBoolHolder(const AliDynBoolHolder& /*other*/): AliDynHolder() { }
		AliDynBoolHolder& operator= (const AliDynBoolHolder& /*other*/) {return *this;}
		Bool_t* fValues; //[fSize] 	 The value

		ClassDef(AliDynBoolHolder, 1);
	};

	class AliDynByteHolder: public AliDynHolder {
	
	friend class AliSimpleValue;
	
	public:
	
		AliDynByteHolder(): fValues(NULL) {}

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

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

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

                virtual Bool_t IsEqual(const TObject* object) const;


	private:
		AliDynByteHolder(const AliDynByteHolder& /*other*/): AliDynHolder() { }
		AliDynByteHolder& operator= (const AliDynByteHolder& /*other*/) {return *this;}
		Char_t* fValues; //[fSize] 	 The value

		ClassDef(AliDynByteHolder, 1);
	};

	class AliDynIntHolder: public AliDynHolder {
	
	friend class AliSimpleValue;
	
	public:

		AliDynIntHolder(): fValues(NULL) {}

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

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

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

                virtual Bool_t IsEqual(const TObject* object) const;


	private:
		AliDynIntHolder(const AliDynIntHolder& /*other*/): AliDynHolder() { }
		AliDynIntHolder& operator= (const AliDynIntHolder& /*other*/) {return *this;}
		Int_t* fValues; //[fSize] 	 The value

		ClassDef(AliDynIntHolder, 1);
	};

	class AliDynUIntHolder: public AliDynHolder {
	
	friend class AliSimpleValue;
	
	public:

		AliDynUIntHolder(): fValues(NULL) {}

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

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

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

                virtual Bool_t IsEqual(const TObject* object) const;


	private:
		AliDynUIntHolder(const AliDynUIntHolder& /*other*/): AliDynHolder() { }
		AliDynUIntHolder& operator= (const AliDynUIntHolder& /*other*/) {return *this;}
		UInt_t* fValues; //[fSize] 	 The value

		ClassDef(AliDynUIntHolder, 1);
	};

	class AliDynFloatHolder: public AliDynHolder {
	
	friend class AliSimpleValue;
	
	public:

		AliDynFloatHolder(): fValues(NULL) {}

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

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

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

                virtual Bool_t IsEqual(const TObject* object) const;


	private:
		AliDynFloatHolder(const AliDynFloatHolder& /*other*/): AliDynHolder() { }
		AliDynFloatHolder& operator= (const AliDynFloatHolder& /*other*/) {return *this;}
		Float_t* fValues; //[fSize] 	 The value

		ClassDef(AliDynFloatHolder, 1);
	};


	TObject* fHolder;  	// Holder of the basic type value

	Type fType;  	// Type of the basic type value


	Bool_t TypeOk(Type type) const;

	Bool_t BoundsOk(Int_t n) const;


	ClassDef(AliSimpleValue, 1);
};

#endif
Commit	Line	Data
57459306	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.
0bd5d12b	12	// bool, char, byte, int ,uint, float, and arrays of these values
57459306	13	//
	14
	15	#include <TObject.h>
	16	#include <TString.h>
	17
	18	class AliSimpleValue: public TObject {
	19	public:
	20	enum Type {
	21	kInvalid = 0,
	22	kBool = 1,
	23	kByte = 2,
	24	kInt = 3,
	25	kUInt = 4,
	26	kFloat = 5,
	27	kDynBool = 11,
	28	kDynByte = 12,
	29	kDynInt = 13,
	30	kDynUInt = 14,
	31	kDynFloat = 15
	32	};
	33
	34
	35	AliSimpleValue();
	36
	37	AliSimpleValue(const AliSimpleValue& other);
	38
	39	AliSimpleValue(Type type, Int_t size = 0);
	40
	41	AliSimpleValue(Bool_t val);
	42
	43	AliSimpleValue(Char_t val);
	44
	45	AliSimpleValue(Int_t val);
	46
	47	AliSimpleValue(UInt_t val);
	48
	49	AliSimpleValue(Float_t val);
	50
	51	AliSimpleValue(Int_t size, const Bool_t* vals);
	52
	53	AliSimpleValue(Int_t size, const Char_t* vals);
	54
	55	AliSimpleValue(Int_t size, const Int_t* vals);
	56
	57	AliSimpleValue(Int_t size, const UInt_t* vals);
	58
	59	AliSimpleValue(Int_t size, const Float_t* vals);
	60
	61	~AliSimpleValue();
	62
	63
	64	AliSimpleValue& operator=(const AliSimpleValue& other);
	65
	66	Bool_t operator==(const AliSimpleValue& other) const;
	67
	68	void SetBool(Bool_t val);
	69
	70	void SetByte(Char_t val);
	71
	72	void SetInt(Int_t val);
	73
	74	void SetUInt(UInt_t val);
	75
	76	void SetFloat(Float_t val);
77
78
79	Bool_t GetBool() const;
80
81	Char_t GetByte() const;
82
83	Int_t GetInt() const;
84
85	UInt_t GetUInt() const;
86
87	Float_t GetFloat() const;
88
89
90	void SetDynBool(Int_t n, Bool_t val);
91
92	void SetDynByte(Int_t n, Char_t val);
93
94	void SetDynInt(Int_t n, Int_t val);
95
96	void SetDynUInt(Int_t n, UInt_t val);
97
98	void SetDynFloat(Int_t n, Float_t val);
99
100
101	Bool_t GetDynBool(Int_t n) const;
102
103	Char_t GetDynByte(Int_t n) const;
104
105	Int_t GetDynInt(Int_t n) const;
106
107	UInt_t GetDynUInt(Int_t n) const;
108
109	Float_t GetDynFloat(Int_t n) const;
110
111
112	Type GetType() const {return fType;};
113
114	Int_t GetSize() const;
115
116	Int_t GetDynamicSize() const;
117
118	TString ToString() const;
119
120
121	static Bool_t IsDynamic(Type type);
122
123	static Int_t GetPrimitiveSize(Type type);
124
125	static const char* GetTypeString(Type type);
126
127	private:
128
0bd5d12b	129	class AliBoolHolder: public TObject {
	130
	131	friend class AliSimpleValue;
	132
57459306	133	public:
0bd5d12b	134	AliBoolHolder() {}
0bd5d12b	135	virtual ~AliBoolHolder() {}
57459306	136
0bd5d12b	137	AliBoolHolder(Bool_t val):fValue(val) {}
57459306	138
	139	virtual TObject* Clone(const char* name) const;
	140
	141	virtual Bool_t IsEqual(const TObject* object) const;
	142
0bd5d12b	143	private:
	144	Bool_t fValue; // The value
	145
	146	ClassDef(AliBoolHolder, 1);
57459306	147	};
57459306	148
0bd5d12b	149	class AliByteHolder: public TObject {
	150
	151	friend class AliSimpleValue;
	152
57459306	153	public:
57459306	154
0bd5d12b	155	AliByteHolder() {};
0bd5d12b	156	virtual ~AliByteHolder() {}
57459306	157
0bd5d12b	158	AliByteHolder(Char_t val):fValue(val) {}
57459306	159
	160	virtual TObject* Clone(const char* name) const;
	161
	162	virtual Bool_t IsEqual(const TObject* object) const;
	163
0bd5d12b	164	private:
	165	Char_t fValue; // The value
	166
	167	ClassDef(AliByteHolder, 1);
57459306	168	};
57459306	169
0bd5d12b	170	class AliIntHolder: public TObject {
	171
	172	friend class AliSimpleValue;
	173
57459306	174	public:
57459306	175
0bd5d12b	176	AliIntHolder() {}
0bd5d12b	177	virtual ~AliIntHolder() {}
57459306	178
0bd5d12b	179	AliIntHolder(Int_t val):fValue(val) {}
57459306	180
	181	virtual TObject* Clone(const char* name) const;
	182
	183	virtual Bool_t IsEqual(const TObject* object) const;
	184
0bd5d12b	185
	186	private:
	187	Int_t fValue; // The value
	188
	189	ClassDef(AliIntHolder, 1);
57459306	190	};
57459306	191
0bd5d12b	192	class AliUIntHolder: public TObject {
	193
	194	friend class AliSimpleValue;
	195
57459306	196	public:
57459306	197
0bd5d12b	198	AliUIntHolder() {}
0bd5d12b	199	virtual ~AliUIntHolder() {}
57459306	200
0bd5d12b	201	AliUIntHolder(UInt_t val):fValue(val) {}
57459306	202
	203	virtual TObject* Clone(const char* name) const;
	204
	205	virtual Bool_t IsEqual(const TObject* object) const;
	206
0bd5d12b	207
	208	private:
	209	UInt_t fValue; // The value
	210
	211	ClassDef(AliUIntHolder, 1);
57459306	212	};
57459306	213
0bd5d12b	214	class AliFloatHolder: public TObject {
	215
	216	friend class AliSimpleValue;
	217
57459306	218	public:
57459306	219
0bd5d12b	220	AliFloatHolder() {}
0bd5d12b	221	virtual ~AliFloatHolder() {}
57459306	222
0bd5d12b	223	AliFloatHolder(Float_t val):fValue(val) {}
57459306	224
	225	virtual TObject* Clone(const char* name) const;
	226
	227	virtual Bool_t IsEqual(const TObject* object) const;
	228
0bd5d12b	229	private:
	230	Float_t fValue; // The value
	231
	232	ClassDef(AliFloatHolder, 1);
57459306	233	};
57459306	234
0bd5d12b	235	class AliDynHolder: public TObject {
	236
	237	friend class AliSimpleValue;
	238
57459306	239	public:
57459306	240
0bd5d12b	241	AliDynHolder(): fSize(0) {}
0bd5d12b	242	AliDynHolder(Int_t size): fSize(size){}
57459306	243
0bd5d12b	244	Int_t fSize; // The size
0bd5d12b	245	ClassDef(AliDynHolder, 0);
57459306	246	};
57459306	247
0bd5d12b	248	class AliDynBoolHolder: public AliDynHolder {
	249
	250	friend class AliSimpleValue;
	251
57459306	252	public:
57459306	253
0bd5d12b	254	AliDynBoolHolder(): fValues(NULL) {}
57459306	255
0bd5d12b	256	AliDynBoolHolder(Int_t size, const Bool_t* buf = NULL):
0bd5d12b	257	AliDynHolder(size) {
57459306	258	fValues = new Bool_t[size];
	259	if (buf) memcpy(fValues, buf, size * sizeof(Bool_t));
	260	}
	261
0bd5d12b	262	virtual ~AliDynBoolHolder() {if (fValues) delete[] fValues;}
57459306	263
	264	virtual TObject* Clone(const char* name) const;
	265
	266	virtual Bool_t IsEqual(const TObject* object) const;
	267
0bd5d12b	268
	269	private:
	270	AliDynBoolHolder(const AliDynBoolHolder& /other/): AliDynHolder() { }
	271	AliDynBoolHolder& operator= (const AliDynBoolHolder& /other/) {return *this;}
	272	Bool_t* fValues; //[fSize] The value
	273
	274	ClassDef(AliDynBoolHolder, 1);
57459306	275	};
57459306	276
0bd5d12b	277	class AliDynByteHolder: public AliDynHolder {
	278
	279	friend class AliSimpleValue;
	280
57459306	281	public:
57459306	282
0bd5d12b	283	AliDynByteHolder(): fValues(NULL) {}
57459306	284
0bd5d12b	285	AliDynByteHolder(Int_t size, const Char_t* buf = NULL):
0bd5d12b	286	AliDynHolder(size) {
57459306	287	fValues = new Char_t[size];
	288	if (buf) memcpy(fValues, buf, size * sizeof(Char_t));
	289	}
	290
0bd5d12b	291	virtual ~AliDynByteHolder() {if (fValues) delete[] fValues;}
57459306	292
	293	virtual TObject* Clone(const char* name) const;
	294
	295	virtual Bool_t IsEqual(const TObject* object) const;
	296
0bd5d12b	297
	298	private:
	299	AliDynByteHolder(const AliDynByteHolder& /other/): AliDynHolder() { }
	300	AliDynByteHolder& operator= (const AliDynByteHolder& /other/) {return *this;}
	301	Char_t* fValues; //[fSize] The value
	302
	303	ClassDef(AliDynByteHolder, 1);
57459306	304	};
57459306	305
0bd5d12b	306	class AliDynIntHolder: public AliDynHolder {
	307
	308	friend class AliSimpleValue;
	309
57459306	310	public:
57459306	311
0bd5d12b	312	AliDynIntHolder(): fValues(NULL) {}
57459306	313
0bd5d12b	314	AliDynIntHolder(Int_t size, const Int_t* buf = NULL):
0bd5d12b	315	AliDynHolder(size) {
57459306	316	fValues = new Int_t[size];
	317	if (buf) memcpy(fValues, buf, size * sizeof(Int_t));
	318	}
	319
0bd5d12b	320	virtual ~AliDynIntHolder() {if (fValues) delete[] fValues;}
57459306	321
	322	virtual TObject* Clone(const char* name) const;
	323
	324	virtual Bool_t IsEqual(const TObject* object) const;
	325
0bd5d12b	326
	327	private:
	328	AliDynIntHolder(const AliDynIntHolder& /other/): AliDynHolder() { }
	329	AliDynIntHolder& operator= (const AliDynIntHolder& /other/) {return *this;}
	330	Int_t* fValues; //[fSize] The value
	331
	332	ClassDef(AliDynIntHolder, 1);
57459306	333	};
57459306	334
0bd5d12b	335	class AliDynUIntHolder: public AliDynHolder {
	336
	337	friend class AliSimpleValue;
	338
57459306	339	public:
57459306	340
0bd5d12b	341	AliDynUIntHolder(): fValues(NULL) {}
57459306	342
0bd5d12b	343	AliDynUIntHolder(Int_t size, const UInt_t* buf = NULL):
0bd5d12b	344	AliDynHolder(size) {
57459306	345	fValues = new UInt_t[size];
	346	if (buf) memcpy(fValues, buf, size * sizeof(UInt_t));
	347	}
	348
0bd5d12b	349	virtual ~AliDynUIntHolder() {if (fValues) delete[] fValues;}
57459306	350
	351	virtual TObject* Clone(const char* name) const;
	352
	353	virtual Bool_t IsEqual(const TObject* object) const;
	354
0bd5d12b	355
	356	private:
	357	AliDynUIntHolder(const AliDynUIntHolder& /other/): AliDynHolder() { }
	358	AliDynUIntHolder& operator= (const AliDynUIntHolder& /other/) {return *this;}
	359	UInt_t* fValues; //[fSize] The value
	360
	361	ClassDef(AliDynUIntHolder, 1);
57459306	362	};
57459306	363
0bd5d12b	364	class AliDynFloatHolder: public AliDynHolder {
	365
	366	friend class AliSimpleValue;
	367
57459306	368	public:
57459306	369
0bd5d12b	370	AliDynFloatHolder(): fValues(NULL) {}
57459306	371
0bd5d12b	372	AliDynFloatHolder(Int_t size, const Float_t* buf = NULL):
0bd5d12b	373	AliDynHolder(size) {
57459306	374	fValues = new Float_t[size];
	375	if (buf) memcpy(fValues, buf, size * sizeof(Float_t));
	376	}
	377
0bd5d12b	378	virtual ~AliDynFloatHolder() {if (fValues) delete[] fValues;}
57459306	379
	380	virtual TObject* Clone(const char* name) const;
	381
	382	virtual Bool_t IsEqual(const TObject* object) const;
	383
0bd5d12b	384
	385	private:
	386	AliDynFloatHolder(const AliDynFloatHolder& /other/): AliDynHolder() { }
	387	AliDynFloatHolder& operator= (const AliDynFloatHolder& /other/) {return *this;}
	388	Float_t* fValues; //[fSize] The value
	389
	390	ClassDef(AliDynFloatHolder, 1);
57459306	391	};
	392
	393
0bd5d12b	394	TObject* fHolder; // Holder of the basic type value
57459306	395
0bd5d12b	396	Type fType; // Type of the basic type value
57459306	397
	398
	399	Bool_t TypeOk(Type type) const;
	400
	401	Bool_t BoundsOk(Int_t n) const;
	402
	403
	404	ClassDef(AliSimpleValue, 1);
	405	};
	406
	407	#endif