STEER/AliDCSArray.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 //                                                                            //
  18 // This class represents the value(s) of a the LHC DPs at a given timestamp   //
  19 // The variuos measurement that occurred at the same timestamp are associated //
  20 // to the same timestamp.                                                     //
  21 //                                                                            //
  22 ////////////////////////////////////////////////////////////////////////////////
  23
  24
  25 #include "AliDCSArray.h"
  26
  27 #include "TTimeStamp.h"
  28 #include <TString.h>
  29
  30 ClassImp(AliDCSArray)
  31
  32 AliDCSArray::AliDCSArray() :
  33                 TObject(),
  34                 fType(kInvalid),
  35                 fnentries(0),
  36                 fBool(0x0),
  37                 fChar(0x0),
  38                 fInt(0x0),
  39                 fUInt(0x0),
  40                 fFloat(0x0),
  41                 fString(0x0),
  42                 fTimeStamp(0)
  43 {
  44         //
  45         // default constructor
  46         //
  47 }
  48
  49 //--------------------------------------------------------------------------
  50 AliDCSArray::AliDCSArray(Int_t nentries, Bool_t* value, TTimeStamp* timeStamp) :
  51         TObject(),
  52         fType(kBool),
  53         fnentries(nentries),
  54         fBool(new Bool_t[fnentries]),
  55         fChar(0x0),
  56         fInt(0x0),
  57         fUInt(0x0),
  58         fFloat(0x0),
  59         fString(0x0),
  60         fTimeStamp(timeStamp)
  61 {
  62         //
  63         // constructor for Bool
  64         //
  65
  66         for (Int_t i = 0; i<fnentries; i++){
  67                 fBool[i] = value[i];
  68         }
  69 }
  70
  71 //--------------------------------------------------------------------------
  72 AliDCSArray::AliDCSArray(Int_t nentries, Char_t* value, TTimeStamp* timeStamp) :
  73         TObject(),
  74         fType(kChar),
  75         fnentries(nentries),
  76         fBool(0x0),
  77         fChar(new Char_t[fnentries]),
  78         fInt(0x0),
  79         fUInt(0x0),
  80         fFloat(0x0),
  81         fString(0x0),
  82         fTimeStamp(timeStamp)
  83 {
  84         //
  85         // constructor for Char
  86         //
  87         for (Int_t i = 0; i<fnentries; i++){
  88                 fChar[i] = value[i];
  89         }
  90 }
  91
  92 //-------------------------------------------------------------------------
  93 AliDCSArray::AliDCSArray(Int_t nentries, Int_t* value, TTimeStamp* timeStamp) :
  94         TObject(),
  95         fType(kInt),
  96         fnentries(nentries),
  97         fBool(0x0),
  98         fChar(0x0),
  99         fInt(new Int_t[fnentries]),
 100         fUInt(0x0),
 101         fFloat(0x0),
 102         fString(0x0),
 103         fTimeStamp(timeStamp)
 104 {
 105         //
 106         // constructor for Int
 107         //
 108         for (Int_t i = 0; i<fnentries; i++){
 109                 fInt[i] = value[i];
 110         }
 111 }
 112
 113 //-------------------------------------------------------------------------
 114 AliDCSArray::AliDCSArray(Int_t nentries, UInt_t* value, TTimeStamp* timeStamp) :
 115         TObject(),
 116         fType(kUInt),
 117         fnentries(nentries),
 118         fBool(0x0),
 119         fChar(0x0),
 120         fInt(0x0),
 121         fUInt(new UInt_t[fnentries]),
 122         fFloat(0x0),
 123         fString(0x0),
 124         fTimeStamp(timeStamp)
 125 {
 126         //
 127         // constructor for UInt
 128         //
 129
 130         for (Int_t i = 0; i<fnentries; i++){
 131                 fUInt[i] = value[i];
 132         }
 133 }
 134
 135 //-------------------------------------------------------------------------
 136 AliDCSArray::AliDCSArray(Int_t nentries, Float_t* value, TTimeStamp* timeStamp) :
 137         TObject(),
 138         fType(kFloat),
 139         fnentries(nentries),
 140         fBool(0x0),
 141         fChar(0x0),
 142         fInt(0x0),
 143         fUInt(0x0),
 144         fFloat(new Float_t[fnentries]),
 145         fString(0x0),
 146         fTimeStamp(timeStamp)
 147 {
 148         //
 149         // constructor for Float
 150         //
 151
 152         for (Int_t i = 0; i<fnentries; i++){
 153                 fFloat[i] = value[i];
 154         }
 155 }
 156
 157 //------------------------------------------------------------------------
 158 AliDCSArray::AliDCSArray(Int_t nentries, TString* value, TTimeStamp* timeStamp) :
 159         TObject(),
 160         fType(kString),
 161         fnentries(nentries),
 162         fBool(0x0),
 163         fChar(0x0),
 164         fInt(0x0),
 165         fUInt(0x0),
 166         fFloat(0x0),
 167         fString(new TString[fnentries]),
 168         fTimeStamp(timeStamp)
 169 {
 170         //
 171         // constructor for String
 172         //
 173
 174         for (Int_t i = 0; i<fnentries; i++){
 175                 fString[i] = value[i];
 176         }
 177 }
 178
 179 //-----------------------------------------------------------------------
 180 AliDCSArray::AliDCSArray(const AliDCSArray& c) :
 181         TObject(c),
 182         fType(c.fType),
 183         fnentries(c.fnentries),
 184         fBool(0x0),
 185         fChar(0x0),
 186         fInt(0x0),
 187         fUInt(0x0),
 188         fFloat(0x0),
 189         fString(0x0),
 190         fTimeStamp(c.fTimeStamp)
 191 {
 192         //
 193         // copy constructor
 194         //
 195
 196         if (fType == kBool && c.fBool){
 197                 fBool = new Bool_t[fnentries];
 198                 memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
 199         }
 200         if (fType == kChar && c.fChar){
 201                 fChar = new Char_t[fnentries];
 202                 memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
 203         }
 204         if (fType == kUInt && c.fUInt){
 205                 fUInt = new UInt_t[fnentries];
 206                 memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
 207         }
 208         if (fType == kInt && c.fInt){
 209                 fInt = new Int_t[fnentries];
 210                 memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
 211         }
 212         if (fType == kFloat && c.fFloat){
 213                 fFloat = new Float_t[fnentries];
 214                 memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
 215         }
 216         if (fType == kString && c.fString){
 217                 fString = new TString[fnentries];
 218                 memcpy(fString,c.fString,fnentries*sizeof(TString));
 219         }
 220
 221 }
 222
 223 //-----------------------------------------------------------------------
 224 AliDCSArray::~AliDCSArray()
 225 {
 226         //
 227         // destructor
 228         //
 229
 230         if (fBool){
 231                 fBool = 0x0;
 232                 delete fBool;
 233         }
 234         if (fChar){
 235                 fChar = 0x0;
 236                 delete fChar;
 237         }
 238         if (fUInt){
 239                 fUInt = 0x0;
 240                 delete fUInt;
 241         }
 242         if (fInt){
 243                 fInt = 0x0;
 244                 delete fInt;
 245         }
 246         if (fFloat){
 247                 fFloat = 0x0;
 248                 delete fFloat;
 249         }
 250         if (fString){
 251                 fString = 0x0;
 252                 delete fString;
 253         }
 254         if (fTimeStamp){
 255                 fTimeStamp = 0x0;
 256                 delete fTimeStamp;
 257         }
 258 }
 259
 260 //-----------------------------------------------------------------------
 261 AliDCSArray &AliDCSArray::operator=(const AliDCSArray &c)
 262 {
 263         //
 264         // operator =
 265         //
 266
 267         if(&c == this) return *this;
 268         if (fType == kBool && c.fBool){
 269                 fBool = new Bool_t[fnentries];
 270                 memcpy(fBool,c.fBool,fnentries*sizeof(Bool_t));
 271         }
 272         if (fType == kChar && c.fChar){
 273                 fChar = new Char_t[fnentries];
 274                 memcpy(fChar,c.fChar,fnentries*sizeof(Char_t));
 275         }
 276         if (fType == kUInt && c.fUInt){
 277                 fUInt = new UInt_t[fnentries];
 278                 memcpy(fUInt,c.fUInt,fnentries*sizeof(UInt_t));
 279         }
 280         if (fType == kInt && c.fInt){
 281                 fInt = new Int_t[fnentries];
 282                 memcpy(fInt,c.fInt,fnentries*sizeof(Int_t));
 283         }
 284         if (fType == kFloat && c.fFloat){
 285                 fFloat = new Float_t[fnentries];
 286                 memcpy(fFloat,c.fFloat,fnentries*sizeof(Float_t));
 287         }
 288         if (fType == kString && c.fString){
 289                 fString = new TString[fnentries];
 290                 memcpy(fString,c.fString,fnentries*sizeof(TString));
 291         }
 292
 293         return *this;
 294 }
 295
 296 //-----------------------------------------------------------------------
 297 void AliDCSArray::Init()
 298 {
 299         //
 300         // init helper, that initializes everything to 0
 301         //
 302
 303         fType = kInvalid;
 304
 305         fnentries = 0;
 306         fBool = 0x0;
 307         fChar = 0x0;
 308         fInt = 0x0;
 309         fUInt = 0x0;
 310         fFloat = 0x0;
 311         fString = 0x0;
 312
 313         fTimeStamp = 0x0;
 314 }