Separate library for CDB (Jan)
[u/mrichter/AliRoot.git] / STEER / AliSimpleValue.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.2  2006/03/07 07:52:34  hristov
19 New version (B.Yordanov)
20
21 Revision 1.2  2005/11/17 14:43:23  byordano
22 import to local CVS
23
24 Revision 1.1.1.1  2005/10/28 07:33:58  hristov
25 Initial import as subdirectory in AliRoot
26
27 Revision 1.1.1.1  2005/09/12 22:11:40  byordano
28 SHUTTLE package
29
30 Revision 1.2  2005/08/30 10:53:23  byordano
31 some more descriptions added
32
33 */
34
35 //
36 // This class is a simple wrapper of
37 // all primitive types used in PVSS SCADA system.
38 //
39
40
41 #include "AliSimpleValue.h"
42
43 #include "AliLog.h"
44 #include <TClass.h>
45
46 TObject* AliSimpleValue::BoolHolder::Clone(const char* /*name*/) const {
47         return new BoolHolder(fValue);
48 }
49
50 Bool_t AliSimpleValue::BoolHolder::IsEqual(const TObject* obj) const {
51         
52         if (this == obj) {
53                 return kTRUE;
54         }
55
56         if (BoolHolder::Class() != obj->IsA()) {
57                 return kFALSE;
58         }
59
60         return fValue == ((const BoolHolder*) obj)->fValue;
61 }
62
63 TObject* AliSimpleValue::ByteHolder::Clone(const char* /*name*/) const {
64         return new ByteHolder(fValue);
65 }
66
67 Bool_t AliSimpleValue::ByteHolder::IsEqual(const TObject* obj) const {
68
69         if (this == obj) {
70                 return kTRUE;
71         }
72
73         if (ByteHolder::Class() != obj->IsA()) {
74                 return kFALSE;
75         }
76
77         return fValue == ((const ByteHolder*) obj)->fValue;
78 }
79
80 TObject* AliSimpleValue::IntHolder::Clone(const char* /*name*/) const {
81         return new IntHolder(fValue);
82 }
83
84 Bool_t AliSimpleValue::IntHolder::IsEqual(const TObject* obj) const {
85
86         if (this == obj) {
87                 return kTRUE;
88         }
89
90         if (IntHolder::Class() != obj->IsA()) {
91                 return kFALSE;
92         }
93
94         return fValue == ((const IntHolder*) obj)->fValue;
95 }
96
97 TObject* AliSimpleValue::UIntHolder::Clone(const char* /*name*/) const {
98         return new UIntHolder(fValue);
99 }
100
101 Bool_t AliSimpleValue::UIntHolder::IsEqual(const TObject* obj) const {
102
103         if (this == obj) {
104                 return kTRUE;
105         }
106
107         if (UIntHolder::Class() != obj->IsA()) {
108                 return kFALSE;
109         }
110
111         return fValue == ((const UIntHolder*) obj)->fValue;
112 }
113
114 TObject* AliSimpleValue::FloatHolder::Clone(const char* /*name*/) const {
115         return new FloatHolder(fValue);
116 }
117
118 Bool_t AliSimpleValue::FloatHolder::IsEqual(const TObject* obj) const {
119
120         if (this == obj) {
121                 return kTRUE;
122         }
123
124         if (FloatHolder::Class() != obj->IsA()) {
125                 return kFALSE;
126         }
127
128         return fValue == ((const FloatHolder*) obj)->fValue;
129 }
130
131 TObject* AliSimpleValue::DynBoolHolder::Clone(const char* /*name*/) const {
132         return new DynBoolHolder(fSize, fValues);
133 }
134
135 Bool_t AliSimpleValue::DynBoolHolder::IsEqual(const TObject* obj) const {
136
137         if (this == obj) {
138                 return kTRUE;
139         }
140
141         if (DynBoolHolder::Class() != obj->IsA()) {
142                 return kFALSE;
143         }
144
145         const DynBoolHolder* other = ((const DynBoolHolder*) obj);
146         
147         if (fSize != other->fSize) {
148                 return kFALSE;
149         }
150
151         return !memcmp(fValues, other->fValues, fSize * sizeof(Bool_t));
152 }
153
154 TObject* AliSimpleValue::DynByteHolder::Clone(const char* /*name*/) const {
155         return new DynByteHolder(fSize, fValues);
156 }
157
158 Bool_t AliSimpleValue::DynByteHolder::IsEqual(const TObject* obj) const {
159
160         if (this == obj) {
161                 return kTRUE;
162         }
163
164         if (DynByteHolder::Class() != obj->IsA()) {
165                 return kFALSE;
166         }
167
168         const DynByteHolder* other = ((const DynByteHolder*) obj);
169
170         if (fSize != other->fSize) {
171                 return kFALSE;
172         }
173
174         return !memcmp(fValues, other->fValues, fSize * sizeof(Char_t));
175 }
176
177 TObject* AliSimpleValue::DynIntHolder::Clone(const char* /*name*/) const {
178         return new DynIntHolder(fSize, fValues);
179 }
180
181 Bool_t AliSimpleValue::DynIntHolder::IsEqual(const TObject* obj) const {
182
183         if (this == obj) {
184                 return kTRUE;
185         }
186
187         if (DynIntHolder::Class() != obj->IsA()) {
188                 return kFALSE;
189         }
190
191         const DynIntHolder* other = ((const DynIntHolder*) obj);
192
193         if (fSize != other->fSize) {
194                 return kFALSE;
195         }
196
197         return !memcmp(fValues, other->fValues, fSize * sizeof(Int_t));
198 }
199
200 TObject* AliSimpleValue::DynUIntHolder::Clone(const char* /*name*/) const {
201         return new DynUIntHolder(fSize, fValues);
202 }
203
204 Bool_t AliSimpleValue::DynUIntHolder::IsEqual(const TObject* obj) const {
205
206         if (this == obj) {
207                 return kTRUE;
208         }
209
210         if (DynUIntHolder::Class() != obj->IsA()) {
211                 return kFALSE;
212         }
213
214         const DynUIntHolder* other = ((const DynUIntHolder*) obj);
215
216         if (fSize != other->fSize) {
217                 return kFALSE;
218         }
219
220         return !memcmp(fValues, other->fValues, fSize * sizeof(UInt_t));
221 }
222
223 TObject* AliSimpleValue::DynFloatHolder::Clone(const char* /*name*/) const {
224         return new DynFloatHolder(fSize, fValues);
225 }
226
227 Bool_t AliSimpleValue::DynFloatHolder::IsEqual(const TObject* obj) const {
228
229         if (this == obj) {
230                 return kTRUE;
231         }
232
233         if (DynFloatHolder::Class() != obj->IsA()) {
234                 return kFALSE;
235         }
236
237         const DynFloatHolder* other = ((const DynFloatHolder*) obj);
238
239         if (fSize != other->fSize) {
240                 return kFALSE;
241         }
242
243         return !memcmp(fValues, other->fValues, fSize * sizeof(Float_t));
244 }
245
246 ClassImp(AliSimpleValue)
247
248 AliSimpleValue::AliSimpleValue():
249         fHolder(NULL), fType(kInvalid)
250 {
251
252 }
253
254 AliSimpleValue::AliSimpleValue(const AliSimpleValue& other):
255         TObject(other), fHolder(NULL), fType(other.fType)
256 {
257         if (other.fHolder) {
258                 fHolder = other.fHolder->Clone();
259         }
260 }
261
262 AliSimpleValue::AliSimpleValue(AliSimpleValue::Type type, Int_t size):
263         fHolder(NULL), fType(type)
264 {
265         
266         switch (type) {
267                 case kBool:
268                         fHolder = new BoolHolder();
269                         break;
270                 case kByte:
271                         fHolder = new ByteHolder();
272                         break;
273                 case kInt:
274                         fHolder = new IntHolder();
275                         break;
276                 case kUInt:
277                         fHolder = new UIntHolder();
278                         break;
279                 case kFloat:
280                         fHolder = new FloatHolder();
281                         break;
282                 case kDynBool:
283                         fHolder = new DynBoolHolder(size);
284                         break;
285                 case kDynByte:
286                         fHolder = new DynByteHolder(size);
287                         break;
288                 case kDynInt:
289                         fHolder = new DynIntHolder(size);
290                         break;
291                 case kDynUInt:
292                         fHolder = new DynUIntHolder(size);
293                         break;
294                 case kDynFloat:
295                         fHolder = new DynFloatHolder(size);
296                         break;
297                 default:        
298                         break;
299         }
300 }
301
302 AliSimpleValue::AliSimpleValue(Bool_t val) {
303
304         fType = kBool;
305         fHolder = new BoolHolder(val);
306 }
307
308 AliSimpleValue::AliSimpleValue(Char_t val) {
309         
310         fType = kByte;
311         fHolder = new ByteHolder(val);
312 }
313
314 AliSimpleValue::AliSimpleValue(Int_t val) {
315         
316         fType = kInt;
317         fHolder = new IntHolder(val);
318 }
319
320 AliSimpleValue::AliSimpleValue(UInt_t val) {
321         
322         fType = kUInt;
323         fHolder = new UIntHolder(val);
324 }
325
326 AliSimpleValue::AliSimpleValue(Float_t val) {
327
328         fType = kFloat;
329         fHolder = new FloatHolder(val);
330 }
331
332 AliSimpleValue::AliSimpleValue(Int_t size, const Bool_t* buf) {
333         
334         fType = kDynBool;
335         fHolder = new DynBoolHolder(size, buf);
336 }
337
338 AliSimpleValue::AliSimpleValue(Int_t size, const Char_t* buf) {
339
340         fType = kDynByte;
341         fHolder = new DynByteHolder(size, buf);
342 }
343
344 AliSimpleValue::AliSimpleValue(Int_t size, const Int_t* buf) {
345
346         fType = kDynInt;
347         fHolder = new DynIntHolder(size, buf);
348 }
349
350 AliSimpleValue::AliSimpleValue(Int_t size, const UInt_t* buf) {
351
352         fType = kDynUInt;
353         fHolder = new DynUIntHolder(size, buf);
354 }
355
356 AliSimpleValue::AliSimpleValue(Int_t size, const Float_t* buf) {
357
358         fType = kDynFloat;
359         fHolder = new DynFloatHolder(size, buf);
360 }
361
362 AliSimpleValue::~AliSimpleValue() {
363         
364         if (fHolder) {
365                 delete fHolder;
366         }
367 }
368
369 AliSimpleValue& AliSimpleValue::operator=(const AliSimpleValue& other) {
370         
371         if (fHolder) {
372                 delete fHolder;
373         }
374
375         fType = other.fType;
376         
377         if (other.fHolder) {
378                 fHolder = other.fHolder->Clone();
379         } else {
380                 fHolder = NULL;
381         }
382
383         return *this;
384 }
385
386 Bool_t AliSimpleValue::operator==(const AliSimpleValue& other) const {
387
388         if (fType != other.fType) {
389                 return kFALSE;
390         }
391
392         if (!(fHolder && other.fHolder)) {
393                 return kFALSE;
394         }
395
396         return fHolder->IsEqual(other.fHolder);
397 }
398
399 void AliSimpleValue::SetBool(Bool_t val) {
400
401         if (!TypeOk(kBool)) {
402                 return;
403         }
404
405         ((BoolHolder*) fHolder)->fValue = val;
406 }
407
408 void AliSimpleValue::SetByte(Char_t val) {
409
410         if (!TypeOk(kByte)) {
411                 return;
412         }
413
414         ((ByteHolder*) fHolder)->fValue = val;
415 }
416
417 void AliSimpleValue::SetInt(Int_t val) {
418
419         if (!TypeOk(kInt)) {
420                 return;
421         }
422
423         ((IntHolder*) fHolder)->fValue = val;
424 }
425
426 void AliSimpleValue::SetUInt(UInt_t val) {
427
428         if (!TypeOk(kUInt)) {
429                 return;
430         }
431         
432         ((UIntHolder*) fHolder)->fValue = val;
433 }
434
435 void AliSimpleValue::SetFloat(Float_t val) {
436
437         if (!TypeOk(kFloat)) {
438                 return;
439         }
440
441         ((FloatHolder*) fHolder)->fValue = val;
442 }
443
444 Bool_t AliSimpleValue::GetBool() const {
445
446         if (!TypeOk(kBool)) {
447                 return kFALSE;
448         }       
449
450         return ((BoolHolder*) fHolder)->fValue;
451 }
452
453 Char_t AliSimpleValue::GetByte() const {
454
455         if (!TypeOk(kByte)) {
456                 return 0;
457         }
458         
459         return ((ByteHolder*) fHolder)->fValue;
460 }
461
462 Int_t AliSimpleValue::GetInt() const {
463
464         if (!TypeOk(kInt)) {
465                 return 0;
466         }
467         return ((IntHolder*) fHolder)->fValue;
468 }
469
470 UInt_t AliSimpleValue::GetUInt() const {
471
472         if (!TypeOk(kUInt)) {
473                 return 0;
474         }
475
476         return ((UIntHolder*) fHolder)->fValue;
477 }
478
479 Float_t AliSimpleValue::GetFloat() const {
480
481         if (!TypeOk(kFloat)) {
482                 return 0;
483         }
484
485         return ((FloatHolder*) fHolder)->fValue;
486 }
487
488 void AliSimpleValue::SetDynBool(Int_t n, Bool_t val) {
489         
490         if (!TypeOk(kDynBool)) {
491                 return;
492         }
493
494         if (!BoundsOk(n)) {
495                 return;
496         }
497
498         ((DynBoolHolder*) fHolder)->fValues[n] = val;
499 }
500
501 void AliSimpleValue::SetDynByte(Int_t n, Char_t val) {
502
503         if (!TypeOk(kDynByte)) {
504                 return;
505         }
506
507         if (!BoundsOk(n)) {
508                 return;
509         }
510
511         ((DynByteHolder*) fHolder)->fValues[n] = val;
512 }
513
514 void AliSimpleValue::SetDynInt(Int_t n, Int_t val) {
515
516         if (!TypeOk(kDynInt)) {
517                 return;
518         }
519
520         if (!BoundsOk(n)) {
521                 return;
522         }
523
524         ((DynIntHolder*) fHolder)->fValues[n] = val;
525 }
526
527 void AliSimpleValue::SetDynUInt(Int_t n, UInt_t val) {
528
529         if (!TypeOk(kDynUInt)) {
530                 return;
531         }
532
533         if (!BoundsOk(n)) {
534                 return;
535         }
536
537         ((DynUIntHolder*) fHolder)->fValues[n] = val;
538 }
539
540 void AliSimpleValue::SetDynFloat(Int_t n, Float_t val) {
541
542         if (!TypeOk(kDynFloat)) {
543                 return;
544         }
545
546         if (!BoundsOk(n)) {
547                 return;
548         }
549
550         ((DynFloatHolder*) fHolder)->fValues[n] = val;
551 }
552
553 Bool_t AliSimpleValue::GetDynBool(Int_t n) const {
554
555         if (!TypeOk(kDynBool)) {
556                 return kFALSE;
557         }
558
559         if (!BoundsOk(n)) {
560                 return kFALSE;
561         }
562
563         return ((DynBoolHolder*) fHolder)->fValues[n];
564 }
565
566 Char_t AliSimpleValue::GetDynByte(Int_t n) const {
567
568         if (!TypeOk(kDynByte)) {
569                 return 0;
570         }
571
572         if (!BoundsOk(n)) {
573                 return 0;
574         }
575
576         return ((DynByteHolder*) fHolder)->fValues[n];
577 }
578
579 Int_t AliSimpleValue::GetDynInt(Int_t n) const {
580
581         if (!TypeOk(kDynInt)) {
582                 return 0;
583         }
584
585         if (!BoundsOk(n)) {
586                 return 0;
587         }
588
589         return ((DynIntHolder*) fHolder)->fValues[n];
590 }
591
592 UInt_t AliSimpleValue::GetDynUInt(Int_t n) const {
593
594         if (!TypeOk(kDynUInt)) {
595                 return 0;
596         }
597
598         if (!BoundsOk(n)) {
599                 return 0;
600         }
601
602         return ((DynUIntHolder*) fHolder)->fValues[n];
603 }
604
605 Float_t AliSimpleValue::GetDynFloat(Int_t n) const {
606
607         if (!TypeOk(kDynFloat)) {
608                 return 0;
609         }
610
611         if (!BoundsOk(n)) {
612                 return 0;
613         }
614
615         return ((DynFloatHolder*) fHolder)->fValues[n];
616 }
617
618 Bool_t AliSimpleValue::TypeOk(AliSimpleValue::Type type) const {
619
620         if (fType != type) {
621                 AliError(Form("SimpleValue type is not %s!", 
622                         GetTypeString(type)));
623                 return kFALSE;
624         }
625
626         return kTRUE;
627 }
628
629 Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
630
631         switch (fType) {
632                 case kDynBool:
633                 case kDynByte:
634                 case kDynInt:
635                 case kDynUInt:
636                 case kDynFloat: {
637                         Int_t size = ((DynHolder*) fHolder)->fSize;
638                         if (n < 0 || n >= size) {
639                                 AliError(Form("Index %d out of bounds!", n));
640                                 return kFALSE;
641                         }
642                         return kTRUE;
643                 }
644                 case kBool:
645                 case kByte:
646                 case kInt:
647                 case kUInt:
648                 case kFloat:
649                         AliError(Form("SimpleValue type %s is not dynamic!",
650                                 GetTypeString(fType)));
651                         return kFALSE;
652                 default:
653                         AliError("Invalid or unknown type!");
654                         return kFALSE;
655         }
656 }
657
658 Int_t AliSimpleValue::GetDynamicSize() const {
659         //
660         // returns the size of dynamic type or 0 in case of 
661         // none dynamic type.
662         //
663
664         if (!fHolder) {
665                 return 0;
666         }
667
668         if (!fHolder->IsA()->InheritsFrom(DynHolder::Class())) {
669                 return 0;
670         }
671
672         return ((DynHolder*) fHolder)->fSize;
673 }
674
675 TString AliSimpleValue::ToString() const {
676         
677         TString result;
678         
679         result += "Type: ";
680         result += GetTypeString(fType);
681         
682         result += ", Value: ";
683         switch (fType) {
684                 case kBool:
685                         result += GetBool();
686                         break;
687                 case kByte:
688                         result += (Int_t) GetByte();
689                         break;
690                 case kInt:
691                         result += GetInt();
692                         break;
693                 case kUInt:
694                         result += GetUInt();
695                         break;
696                 case kFloat:
697                         result += GetFloat();
698                         break;
699                 case kDynBool: {
700                                 result += "[";
701                                 Int_t size = GetDynamicSize();
702                                 for (Int_t k = 0; k < size; k ++) {
703                                         result += GetDynBool(k);
704                                         if (k + 1 < size) {
705                                                 result += ", ";
706                                         }
707                                 }
708                                 result += "]";
709                         }
710                         break;
711                 case kDynByte: {
712                                 result += "[";
713                                 Int_t size = GetDynamicSize();
714                                 for (Int_t k = 0; k < size; k ++) {
715                                         result += GetDynByte(k);
716                                         if (k + 1 < size) {
717                                                 result += ", ";
718                                         }
719                                 }
720                                 result += "]";
721                         }
722                         break;
723                 case kDynInt: {
724                                 result += "[";
725                                 Int_t size = GetDynamicSize();
726                                 for (Int_t k = 0; k < size; k ++) {
727                                         result += GetDynInt(k);
728                                         if (k + 1 < size) {
729                                                 result += ", ";
730                                         }
731                                 }
732                                 result += "]";
733                         }
734                         break;
735                 case kDynUInt: {
736                                 result += "[";
737                                 Int_t size = GetDynamicSize();
738                                 for (Int_t k = 0; k < size; k ++) {
739                                         result += GetDynUInt(k);
740                                         if (k + 1 < size) {
741                                                 result += ", ";
742                                         }
743                                 }
744                                 result += "]";
745                         }
746                         break;
747                 case kDynFloat: {
748                                 result += "[";
749                                 Int_t size = GetDynamicSize();
750                                 for (Int_t k = 0; k < size; k ++) {
751                                         result += GetDynFloat(k);
752                                         if (k + 1 < size) {
753                                                 result += ", ";
754                                         }
755                                 }
756                                 result += "]";
757                         }
758                         break;
759                 default:
760                         result += "Unknown";            
761         }       
762
763         return result;
764 }
765
766 Bool_t AliSimpleValue::IsDynamic(AliSimpleValue::Type type) {
767
768          switch (type) {
769                 case kDynBool:
770                 case kDynByte:
771                 case kDynInt:
772                 case kDynUInt:
773                 case kDynFloat:
774                         return kTRUE;
775                 default:
776                         return kFALSE; 
777         }
778 }
779
780 Int_t AliSimpleValue::GetSize() const {
781         //
782         // return the number of bytes used by this value.
783         // In case of dynamic type it returns dynamic size multiplied
784         // by the size of corresponding primitive type.
785         //
786         
787         return IsDynamic(fType) ? 
788                 GetDynamicSize() * AliSimpleValue::GetPrimitiveSize(fType): 
789                 AliSimpleValue::GetPrimitiveSize(fType);
790
791
792 Int_t AliSimpleValue::GetPrimitiveSize(AliSimpleValue::Type type) {
793         //
794         // returns the number of bytes used by particular primitive type
795         // or by the corresponding primitive type in case of dynamic type.
796         //
797
798
799         switch (type) {
800
801                 case kBool: 
802                 case kDynBool: return sizeof(Bool_t);
803                 case kByte: 
804                 case kDynByte: return sizeof(Char_t);
805                 case kInt: 
806                 case kDynInt: return sizeof(Int_t);
807                 case kUInt: 
808                 case kDynUInt: return sizeof(UInt_t);
809                 case kFloat: 
810                 case kDynFloat: return sizeof(Float_t);
811                 default:
812                         return 0;
813         }
814
815
816 const char* AliSimpleValue::GetTypeString(AliSimpleValue::Type type) {
817
818         switch (type) {
819                 case kBool: return "Bool";
820                 case kByte: return "Byte";
821                 case kInt: return "Int";
822                 case kUInt: return "UInt";
823                 case kFloat: return "Float";
824                 case kDynBool: return "DynBool";
825                 case kDynByte: return "DynByte";
826                 case kDynInt: return "DynInt";
827                 case kDynUInt: return "DynUInt";
828                 case kDynFloat: return "DynFloat";
829                 default:
830                         return "Unknown";
831         }
832 }