STEER/AliDCSValue.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.4  2006/09/04 17:42:34  hristov
  19 Changes required by Effective C++
  20
  21 Revision 1.3  2006/07/20 09:43:46  jgrosseo
  22 removing dynamic types
  23
  24 Revision 1.2  2006/07/04 14:58:11  jgrosseo
  25 revision of AliDCSValue: Removed wrapper classes, reduced storage size per value by factor 2
  26
  27 Revision 1.1  2006/06/02 14:14:36  hristov
  28 Separate library for CDB (Jan)
  29
  30 Revision 1.2  2006/03/07 07:52:34  hristov
  31 New version (B.Yordanov)
  32
  33 Revision 1.2  2005/11/17 14:43:23  byordano
  34 import to local CVS
  35
  36 Revision 1.1.1.1  2005/10/28 07:33:58  hristov
  37 Initial import as subdirectory in AliRoot
  38
  39 Revision 1.1.1.1  2005/09/12 22:11:40  byordano
  40 SHUTTLE package
  41
  42 Revision 1.2  2005/08/30 10:53:23  byordano
  43 some more descriptions added
  44
  45 */
  46
  47 //
  48 // This class represents the value(s) of
  49 // a DCS data point at a given timestamp.
  50 // It stores different data types, the current implementation has a member for all of them.
  51 // This is definitly not efficient, but the only way to use the automatic streamers generated by ROOT.
  52 //
  53 // Each element of this value series has two fields:
  54 // fValue - primitive value which represents the real measured value
  55 // fTimestamp - timestamp when the measurement was made
  56 //
  57
  58 #include "AliDCSValue.h"
  59
  60 #include "TTimeStamp.h"
  61 #include <TString.h>
  62
  63 ClassImp(AliDCSValue)
  64
  65 AliDCSValue::AliDCSValue() :
  66   TObject(),
  67   fType(kInvalid),
  68   fBool(kFALSE),
  69   fChar(0),
  70   fInt(0),
  71   fUInt(0),
  72   fFloat(0),
  73   fTimeStamp(0)
  74 {
  75   // default constructor
  76 }
  77
  78 AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) :
  79   TObject(),
  80   fType(kBool),
  81   fBool(value),
  82   fChar(0),
  83   fInt(0),
  84   fUInt(0),
  85   fFloat(0),
  86   fTimeStamp(timeStamp)
  87 {
  88   // constructor
  89 }
  90
  91 AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) :
  92   TObject(),
  93   fType(kChar),
  94   fBool(kFALSE),
  95   fChar(value),
  96   fInt(0),
  97   fUInt(0),
  98   fFloat(0),
  99   fTimeStamp(timeStamp)
 100 {
 101   // constructor
 102 }
 103
 104 AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) :
 105   TObject(),
 106   fType(kInt),
 107   fBool(kFALSE),
 108   fChar(0),
 109   fInt(value),
 110   fUInt(0),
 111   fFloat(0),
 112   fTimeStamp(timeStamp)
 113 {
 114   // constructor
 115 }
 116
 117 AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) :
 118   TObject(),
 119   fType(kUInt),
 120   fBool(kFALSE),
 121   fChar(0),
 122   fInt(0),
 123   fUInt(value),
 124   fFloat(0),
 125   fTimeStamp(timeStamp)
 126 {
 127   // constructor
 128 }
 129
 130 AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) :
 131   TObject(),
 132   fType(kFloat),
 133   fBool(kFALSE),
 134   fChar(0),
 135   fInt(0),
 136   fUInt(0),
 137   fFloat(value),
 138   fTimeStamp(timeStamp)
 139 {
 140   // constructor
 141
 142   Init();
 143
 144   fTimeStamp = timeStamp;
 145
 146   fType = kFloat;
 147   fFloat = value;
 148 }
 149
 150 AliDCSValue::AliDCSValue(const AliDCSValue& c) :
 151   TObject(c),
 152   fType(c.fType),
 153   fBool(c.fBool),
 154   fChar(c.fChar),
 155   fInt(c.fInt),
 156   fUInt(c.fUInt),
 157   fFloat(c.fFloat),
 158   fTimeStamp(c.fTimeStamp)
 159 {
 160   // copy constructor
 161 }
 162
 163 void AliDCSValue::Init()
 164 {
 165   // init helper, that initializes everything to 0
 166
 167   fType = kInvalid;
 168
 169   fBool = kFALSE;
 170   fChar = 0;
 171   fInt = 0;
 172   fUInt = 0;
 173   fFloat = 0;
 174
 175   fTimeStamp = 0;
 176 }
 177
 178 AliDCSValue::~AliDCSValue()
 179 {
 180   // destructor
 181 }
 182
 183 AliDCSValue &AliDCSValue::operator=(const AliDCSValue &c)
 184 {
 185   // assigment operator
 186
 187   if (this != &c)
 188     ((AliDCSValue &) c).Copy(*this);
 189
 190   return *this;
 191 }
 192
 193 void AliDCSValue::Copy(TObject& c) const
 194 {
 195   // copy function
 196
 197   AliDCSValue& target = (AliDCSValue &) c;
 198
 199   target.Init();
 200
 201   target.fType = fType;
 202
 203   target.fBool = fBool;
 204   target.fChar = fChar;
 205   target.fInt = fInt;
 206   target.fUInt = fUInt;
 207   target.fFloat = fFloat;
 208
 209   target.fTimeStamp = fTimeStamp;
 210 }
 211
 212 Int_t AliDCSValue::GetSize() const
 213 {
 214   // returns size in bytes of stored structure
 215
 216   Int_t size = sizeof(fTimeStamp);
 217
 218   switch (fType)
 219   {
 220     case kBool:  size += sizeof(Bool_t);  break;
 221     case kChar:  size += sizeof(Char_t);  break;
 222     case kInt:   size += sizeof(Int_t);   break;
 223     case kUInt:  size += sizeof(UInt_t);  break;
 224     case kFloat: size += sizeof(Float_t); break;
 225
 226     case kInvalid: break;
 227   }
 228
 229   return size;
 230 }
 231
 232 const Char_t* AliDCSValue::ToString() const
 233 {
 234   TString str;
 235
 236   switch (fType)
 237   {
 238     case kBool:  str = (fBool == kFALSE) ? "FALSE" : "TRUE"; break;
 239     case kChar:  str.Form("%d", fChar);  break;
 240     case kInt:   str.Form("%d", fInt);  break;
 241     case kUInt:  str.Form("%d", fUInt);  break;
 242     case kFloat: str.Form("%f", fFloat);  break;
 243
 244     case kInvalid: break;
 245   }
 246
 247   return Form("%s Timestamp: %s", str.Data(), TTimeStamp(fTimeStamp).AsString());
 248 }
 249
 250 void AliDCSValue::Print(Option_t* /*opt*/) const
 251 {
 252   printf("%s\n", ToString());
 253 }