Separate library for CDB (Jan)
[u/mrichter/AliRoot.git] / STEER / AliSimpleValue.h
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