Fixes for coverity.
[u/mrichter/AliRoot.git] / STEER / STEER / AliLHCDipValT.h
1 #ifndef ALILHCDIPVALT_H
2 #define ALILHCDIPVALT_H
3
4 #include <typeinfo>
5 #include <TString.h>
6 #include <TObjString.h>
7 #include <TObject.h>
8 #include "AliLog.h"
9
10
11 /////////////////////////////////////////////////////////////////////////////////
12 //                                                                             //
13 //  AliLHCDipValT: templated class to store the array from processed           //
14 //  LHC DIP data. Associated with the time stamp either of the value           //
15 //  acquisition or the last sample timestamp if many samples were processed    //
16 //                                                                             //
17 //  Author: ruben.shahoyan@cern.ch                                             //
18 //                                                                             //
19 /////////////////////////////////////////////////////////////////////////////////
20
21 //_______________________________________________________________________________________
22 template<class Element> class AliLHCDipValT : public TObject
23 {
24  public:
25   //
26   enum {
27     kLastSpecial=BIT(14),         // last element of array is special (e.g. assigned error etc) 
28     kProcessed1 =BIT(15),         // last element of array is special (e.g. assigned error etc) 
29     kChar=BIT(22),
30     kFloat=BIT(23)
31   };
32   //
33   AliLHCDipValT(Int_t size=0, Double_t t=0);
34   AliLHCDipValT(const AliLHCDipValT<Element> &src);
35   virtual ~AliLHCDipValT() {delete[] fArray;}
36   AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src);
37   virtual Element&       operator[](Int_t i);
38   virtual Element        operator[](Int_t i)                          const;
39   //
40   virtual void        SetSize(Int_t size);
41   virtual void        SetValue(Int_t i,Element v);
42   virtual void        SetValues(const Element *v, Int_t n);
43   void                SetTimeStamp(Double_t v)                      {fTimeStamp = v;}
44   // 
45   Int_t               GetSizeTotal()                          const {return fSizeTot;}
46   virtual Element     GetValue(Int_t i=0)                     const;
47   virtual Element*    GetValues()                             const {return (Element*)fArray;}
48   Double_t            GetTimeStamp()                          const {return fTimeStamp;}
49   Char_t*             GetTimeAsString(Bool_t utc=kTRUE)       const {return TimeAsString(fTimeStamp,utc);}
50   //
51   void                SetProcessed1(Bool_t v=kTRUE)                 {SetBit(kProcessed1,v);}
52   void                SetLastSpecial(Bool_t v=kTRUE)                {SetBit(kLastSpecial,v);}
53   Bool_t              IsProcessed1()                          const {return TestBit(kProcessed1);}
54   Bool_t              IsLastSpecial()                         const {return TestBit(kLastSpecial);}
55   Int_t               GetSize()                               const {return IsLastSpecial() ? GetSizeTotal()-1:GetSizeTotal();}
56   Bool_t              IsTypeC()                               const {return TestBit(kChar);}
57   Bool_t              IsTypeF()                               const {return TestBit(kFloat);}
58   Bool_t              IsTypeI()                               const {return !TestBit(kFloat|kChar);}
59   //
60   virtual void Clear(const Option_t *opt="");
61   virtual void Print(const Option_t *opt="")                  const;
62   //
63   static Char_t*      TimeAsString(double t,Bool_t utc=kTRUE);
64   //
65  protected:
66   //
67   Double_t            fTimeStamp;        // timestamp of the entry
68   Int_t               fSizeTot;          // vector total size (including special slots, like for errors)
69   Element*            fArray;            //[fSizeTot] array of entries
70   //
71   ClassDef(AliLHCDipValT,1)
72 };
73
74
75 //__________________________________________________________________________
76 template<class Element>
77 AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t) 
78 : fTimeStamp(t),fSizeTot(0),fArray(0)
79 {
80   //def. constructor
81   SetSize(size);
82   if      (!strcmp(typeid(fArray).name(),typeid(Char_t*).name())) SetBit(kChar);
83   else if (!strcmp(typeid(fArray).name(),typeid(Double_t*).name()) ||
84            !strcmp(typeid(fArray).name(),typeid(Float_t*).name() )) SetBit(kFloat);
85   //
86 }
87
88 //__________________________________________________________________________
89 template<class Element>
90 AliLHCDipValT<Element>::AliLHCDipValT(const AliLHCDipValT<Element> &src)
91 : TObject(src),fTimeStamp(src.fTimeStamp),fSizeTot(0),fArray(0)
92 {
93   //copy constructor
94   SetSize(src.GetSizeTotal());
95   memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));
96 }
97
98 //__________________________________________________________________________
99 template<class Element>
100 AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator=(const AliLHCDipValT<Element> &src)
101 {
102   //assingment
103   if (this != &src) {
104     ((TObject*)this)->operator=(src);
105     if (GetSizeTotal()!=src.GetSizeTotal()) SetSize(src.GetSizeTotal());
106     SetTimeStamp(src.GetTimeStamp());
107     memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));    
108   }
109   return *this;
110 }
111
112 //__________________________________________________________________________
113 template<class Element>
114 Char_t* AliLHCDipValT<Element>::TimeAsString(double t, Bool_t utc)
115 {
116   // time as string in UTC or local format
117   static char buff[22];
118   time_t tt = (time_t) t;
119   struct tm *time = utc ? gmtime(&tt) : localtime(&tt);
120   snprintf(buff,21,"%02d:%02d:%02d %02d/%02d/%04d",time->tm_hour,time->tm_min,time->tm_sec,
121           time->tm_mday,time->tm_mon+1,time->tm_year+1900);
122   return (char*)buff;
123 }
124
125 //__________________________________________________________________________
126 template<class Element>
127 void AliLHCDipValT<Element>::SetValue(Int_t i,Element v)
128 {
129   //assign value
130   if (i>=GetSizeTotal() || i<0) {
131     AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
132     return;
133   }
134   fArray[i] = v;
135 }
136
137 //__________________________________________________________________________
138 template<class Element>
139 void AliLHCDipValT<Element>::SetValues(const Element* v, Int_t n)
140 {
141   //assign value
142   if (n!=GetSizeTotal()) SetSize(n);
143   memcpy(fArray,v,n*sizeof(Element));
144 }
145
146 //__________________________________________________________________________
147 template<class Element>
148 Element& AliLHCDipValT<Element>::operator[](Int_t i)
149 {
150   //obtain value refeterence
151   if (i>=GetSizeTotal() || i<0) {
152     AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
153     return fArray[0];
154   }
155   return (Element&)fArray[i];
156 }
157
158 //__________________________________________________________________________
159 template<class Element>
160 Element AliLHCDipValT<Element>::operator[](Int_t i) const
161 {
162   //obtain value
163   if (i>=GetSizeTotal() || i<0) {
164     AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
165     return 0;
166   }
167   return (Element)fArray[i];
168 }
169
170 //__________________________________________________________________________
171 template<class Element>
172 Element AliLHCDipValT<Element>::GetValue(Int_t i) const
173 {
174   //obtain value
175   if (i>=GetSizeTotal() || i<0) {
176     AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
177     return 0;
178   }
179   return (Element)fArray[i];
180 }
181
182 //__________________________________________________________________________
183 template<class Element>
184 void AliLHCDipValT<Element>::SetSize(Int_t sz)
185 {
186   //resize
187   Element* arr = 0;
188   if (sz>0) {
189     arr = new Element[sz];
190     int nc = GetSizeTotal() > sz ? sz:GetSizeTotal(); // n elems to copy
191     if (nc && fArray) memcpy(arr, fArray, nc*sizeof(Element));
192     if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element));
193     if (fArray) delete[] fArray;
194     fArray = arr;
195     fSizeTot = sz;
196   }
197   else {
198     delete[] fArray;
199     fArray = 0;
200     fSizeTot = 0;
201   }
202 }
203
204 //__________________________________________________________________________
205 template<class Element>
206 void AliLHCDipValT<Element>::Print(const Option_t *opt) const
207 {
208   // print time and value
209   TString str = opt; 
210   str.ToLower();
211   if (str.Contains("raw")) printf("%.1f ",GetTimeStamp());
212   else printf("[%s] ",GetTimeAsString(!str.Contains("loc")));
213   //
214   TString tp = typeid(fArray).name();
215   if ( tp==typeid(Char_t*).name() ) printf(": %s\n",(Char_t*)fArray);
216   else {
217     int sz = GetSize();
218     if (sz>1) printf("\n");
219     Bool_t eolOK = kFALSE;
220     for (int i=0;i<sz;i++) {
221       if      (tp == typeid(Int_t*).name()    || tp == typeid(UInt_t*).name() ) {
222         if (!str.Contains("bit")) printf(" %6d |" ,(Int_t)fArray[i]);
223         else {
224           printf(" ");
225           int val = (int)fArray[i];
226           for (int j=sizeof(int)*8;j--;) printf("%d",(val>>j)&0x1);
227           printf(" |");
228         }
229
230       }
231       else if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) printf(" %+.3e |",(Double_t)fArray[i]);
232       else printf(" ");
233       eolOK = kFALSE;
234       if ( (i+1)%5 == 0) {printf("\n"); eolOK = kTRUE;}
235     }
236     if (IsLastSpecial()) {
237       if (sz>1 && !eolOK) {printf("\n"); eolOK = kTRUE;}
238       if (tp == typeid(Double_t*).name() || tp == typeid(Double_t*).name()) {
239         printf(" Error: %+e\n",(Double_t)fArray[sz]);
240         eolOK = kTRUE;
241       }
242     }
243     if (!eolOK) printf("\n");
244   }
245   //
246 }
247
248 //__________________________________________________________________________
249 template<class Element>
250 void AliLHCDipValT<Element>::Clear(const Option_t *)
251 {
252   // reset to 0 everything
253   SetTimeStamp(0);
254   memset(fArray,0,GetSizeTotal()*sizeof(Element));
255 }
256
257
258 typedef AliLHCDipValT<Double_t> AliLHCDipValD;
259 typedef AliLHCDipValT<Float_t>  AliLHCDipValF;
260 typedef AliLHCDipValT<Int_t>    AliLHCDipValI;
261 typedef AliLHCDipValT<Char_t>   AliLHCDipValC;
262
263
264
265 #endif