SHUTTLE/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