Coding conventions (Alberto)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Jun 2006 11:19:48 +0000 (11:19 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Jun 2006 11:19:48 +0000 (11:19 +0000)
STEER/AliSimpleValue.cxx
STEER/AliSimpleValue.h
STEER/CDBLinkDef.h

index 1dbcd82..80f8257 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.1  2006/06/02 14:14:36  hristov
+Separate library for CDB (Jan)
+
 Revision 1.2  2006/03/07 07:52:34  hristov
 New version (B.Yordanov)
 
@@ -43,106 +46,132 @@ some more descriptions added
 #include "AliLog.h"
 #include <TClass.h>
 
-TObject* AliSimpleValue::BoolHolder::Clone(const char* /*name*/) const {
-       return new BoolHolder(fValue);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliBoolHolder::Clone(const char* /*name*/) const {
+       return new AliBoolHolder(fValue);
+// Clone a value
+
 }
 
-Bool_t AliSimpleValue::BoolHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliBoolHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
        
        if (this == obj) {
                return kTRUE;
        }
 
-       if (BoolHolder::Class() != obj->IsA()) {
+       if (AliBoolHolder::Class() != obj->IsA()) {
                return kFALSE;
        }
 
-       return fValue == ((const BoolHolder*) obj)->fValue;
+       return fValue == ((const AliBoolHolder*) obj)->fValue;
 }
 
-TObject* AliSimpleValue::ByteHolder::Clone(const char* /*name*/) const {
-        return new ByteHolder(fValue);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliByteHolder::Clone(const char* /*name*/) const {
+// Clone a value
+
+        return new AliByteHolder(fValue);
 }
 
-Bool_t AliSimpleValue::ByteHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliByteHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (ByteHolder::Class() != obj->IsA()) {
+        if (AliByteHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        return fValue == ((const ByteHolder*) obj)->fValue;
+        return fValue == ((const AliByteHolder*) obj)->fValue;
 }
 
-TObject* AliSimpleValue::IntHolder::Clone(const char* /*name*/) const {
-       return new IntHolder(fValue);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliIntHolder::Clone(const char* /*name*/) const {
+// Clone a value
+       return new AliIntHolder(fValue);
 }
 
-Bool_t AliSimpleValue::IntHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliIntHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (IntHolder::Class() != obj->IsA()) {
+        if (AliIntHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        return fValue == ((const IntHolder*) obj)->fValue;
+        return fValue == ((const AliIntHolder*) obj)->fValue;
 }
 
-TObject* AliSimpleValue::UIntHolder::Clone(const char* /*name*/) const {
-        return new UIntHolder(fValue);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliUIntHolder::Clone(const char* /*name*/) const {
+// Clone a value
+        return new AliUIntHolder(fValue);
 }
 
-Bool_t AliSimpleValue::UIntHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliUIntHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (UIntHolder::Class() != obj->IsA()) {
+        if (AliUIntHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        return fValue == ((const UIntHolder*) obj)->fValue;
+        return fValue == ((const AliUIntHolder*) obj)->fValue;
 }
 
-TObject* AliSimpleValue::FloatHolder::Clone(const char* /*name*/) const {
-        return new FloatHolder(fValue);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliFloatHolder::Clone(const char* /*name*/) const {
+ // Clone a value
+       return new AliFloatHolder(fValue);
 }
 
-Bool_t AliSimpleValue::FloatHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliFloatHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (FloatHolder::Class() != obj->IsA()) {
+        if (AliFloatHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        return fValue == ((const FloatHolder*) obj)->fValue;
+        return fValue == ((const AliFloatHolder*) obj)->fValue;
 }
 
-TObject* AliSimpleValue::DynBoolHolder::Clone(const char* /*name*/) const {
-        return new DynBoolHolder(fSize, fValues);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliDynBoolHolder::Clone(const char* /*name*/) const {
+ // Clone a value
+       return new AliDynBoolHolder(fSize, fValues);
 }
 
-Bool_t AliSimpleValue::DynBoolHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliDynBoolHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (DynBoolHolder::Class() != obj->IsA()) {
+        if (AliDynBoolHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-       const DynBoolHolder* other = ((const DynBoolHolder*) obj);
+       const AliDynBoolHolder* other = ((const AliDynBoolHolder*) obj);
        
        if (fSize != other->fSize) {
                return kFALSE;
@@ -151,21 +180,25 @@ Bool_t AliSimpleValue::DynBoolHolder::IsEqual(const TObject* obj) const {
         return !memcmp(fValues, other->fValues, fSize * sizeof(Bool_t));
 }
 
-TObject* AliSimpleValue::DynByteHolder::Clone(const char* /*name*/) const {
-        return new DynByteHolder(fSize, fValues);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliDynByteHolder::Clone(const char* /*name*/) const {
+// Clone a value
+        return new AliDynByteHolder(fSize, fValues);
 }
 
-Bool_t AliSimpleValue::DynByteHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliDynByteHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (DynByteHolder::Class() != obj->IsA()) {
+        if (AliDynByteHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        const DynByteHolder* other = ((const DynByteHolder*) obj);
+        const AliDynByteHolder* other = ((const AliDynByteHolder*) obj);
 
         if (fSize != other->fSize) {
                 return kFALSE;
@@ -174,21 +207,25 @@ Bool_t AliSimpleValue::DynByteHolder::IsEqual(const TObject* obj) const {
         return !memcmp(fValues, other->fValues, fSize * sizeof(Char_t));
 }
 
-TObject* AliSimpleValue::DynIntHolder::Clone(const char* /*name*/) const {
-        return new DynIntHolder(fSize, fValues);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliDynIntHolder::Clone(const char* /*name*/) const {
+// Clone a value
+        return new AliDynIntHolder(fSize, fValues);
 }
 
-Bool_t AliSimpleValue::DynIntHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliDynIntHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
-        if (this == obj) {
+       if (this == obj) {
                 return kTRUE;
         }
 
-        if (DynIntHolder::Class() != obj->IsA()) {
+        if (AliDynIntHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        const DynIntHolder* other = ((const DynIntHolder*) obj);
+        const AliDynIntHolder* other = ((const AliDynIntHolder*) obj);
 
         if (fSize != other->fSize) {
                 return kFALSE;
@@ -197,21 +234,25 @@ Bool_t AliSimpleValue::DynIntHolder::IsEqual(const TObject* obj) const {
         return !memcmp(fValues, other->fValues, fSize * sizeof(Int_t));
 }
 
-TObject* AliSimpleValue::DynUIntHolder::Clone(const char* /*name*/) const {
-        return new DynUIntHolder(fSize, fValues);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliDynUIntHolder::Clone(const char* /*name*/) const {
+// Clone a value
+        return new AliDynUIntHolder(fSize, fValues);
 }
 
-Bool_t AliSimpleValue::DynUIntHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliDynUIntHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (DynUIntHolder::Class() != obj->IsA()) {
+        if (AliDynUIntHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        const DynUIntHolder* other = ((const DynUIntHolder*) obj);
+        const AliDynUIntHolder* other = ((const AliDynUIntHolder*) obj);
 
         if (fSize != other->fSize) {
                 return kFALSE;
@@ -220,21 +261,24 @@ Bool_t AliSimpleValue::DynUIntHolder::IsEqual(const TObject* obj) const {
         return !memcmp(fValues, other->fValues, fSize * sizeof(UInt_t));
 }
 
-TObject* AliSimpleValue::DynFloatHolder::Clone(const char* /*name*/) const {
-        return new DynFloatHolder(fSize, fValues);
+//______________________________________________________________________
+TObject* AliSimpleValue::AliDynFloatHolder::Clone(const char* /*name*/) const {
+        return new AliDynFloatHolder(fSize, fValues);
 }
 
-Bool_t AliSimpleValue::DynFloatHolder::IsEqual(const TObject* obj) const {
+//______________________________________________________________________
+Bool_t AliSimpleValue::AliDynFloatHolder::IsEqual(const TObject* obj) const {
+// check whether this is equal to obj
 
         if (this == obj) {
                 return kTRUE;
         }
 
-        if (DynFloatHolder::Class() != obj->IsA()) {
+        if (AliDynFloatHolder::Class() != obj->IsA()) {
                 return kFALSE;
         }
 
-        const DynFloatHolder* other = ((const DynFloatHolder*) obj);
+        const AliDynFloatHolder* other = ((const AliDynFloatHolder*) obj);
 
         if (fSize != other->fSize) {
                 return kFALSE;
@@ -243,131 +287,163 @@ Bool_t AliSimpleValue::DynFloatHolder::IsEqual(const TObject* obj) const {
         return !memcmp(fValues, other->fValues, fSize * sizeof(Float_t));
 }
 
+//______________________________________________________________________
+//______________________________________________________________________
+
 ClassImp(AliSimpleValue)
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue():
        fHolder(NULL), fType(kInvalid)
 {
-
+// empty constructor
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(const AliSimpleValue& other):
        TObject(other), fHolder(NULL), fType(other.fType)
 {
+// copy contructor
        if (other.fHolder) {
                fHolder = other.fHolder->Clone();
        }
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(AliSimpleValue::Type type, Int_t size):
        fHolder(NULL), fType(type)
 {
+// constructor
        
        switch (type) {
                case kBool:
-                       fHolder = new BoolHolder();
+                       fHolder = new AliBoolHolder();
                        break;
                case kByte:
-                       fHolder = new ByteHolder();
+                       fHolder = new AliByteHolder();
                        break;
                case kInt:
-                       fHolder = new IntHolder();
+                       fHolder = new AliIntHolder();
                        break;
                case kUInt:
-                       fHolder = new UIntHolder();
+                       fHolder = new AliUIntHolder();
                        break;
                case kFloat:
-                       fHolder = new FloatHolder();
+                       fHolder = new AliFloatHolder();
                        break;
                case kDynBool:
-                       fHolder = new DynBoolHolder(size);
+                       fHolder = new AliDynBoolHolder(size);
                        break;
                case kDynByte:
-                       fHolder = new DynByteHolder(size);
+                       fHolder = new AliDynByteHolder(size);
                        break;
                case kDynInt:
-                       fHolder = new DynIntHolder(size);
+                       fHolder = new AliDynIntHolder(size);
                        break;
                case kDynUInt:
-                       fHolder = new DynUIntHolder(size);
+                       fHolder = new AliDynUIntHolder(size);
                        break;
                case kDynFloat:
-                       fHolder = new DynFloatHolder(size);
+                       fHolder = new AliDynFloatHolder(size);
                        break;
                default:        
                        break;
        }
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Bool_t val) {
+// contructor
 
        fType = kBool;
-       fHolder = new BoolHolder(val);
+       fHolder = new AliBoolHolder(val);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Char_t val) {
+// contructor
        
        fType = kByte;
-       fHolder = new ByteHolder(val);
+       fHolder = new AliByteHolder(val);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t val) {
+// contructor
        
        fType = kInt;
-       fHolder = new IntHolder(val);
+       fHolder = new AliIntHolder(val);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(UInt_t val) {
+// contructor
        
        fType = kUInt;
-       fHolder = new UIntHolder(val);
+       fHolder = new AliUIntHolder(val);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Float_t val) {
+// contructor
 
        fType = kFloat;
-       fHolder = new FloatHolder(val);
+       fHolder = new AliFloatHolder(val);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t size, const Bool_t* buf) {
+// contructor
        
        fType = kDynBool;
-       fHolder = new DynBoolHolder(size, buf);
+       fHolder = new AliDynBoolHolder(size, buf);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t size, const Char_t* buf) {
+// contructor
 
         fType = kDynByte;
-        fHolder = new DynByteHolder(size, buf);
+        fHolder = new AliDynByteHolder(size, buf);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t size, const Int_t* buf) {
+// contructor
 
         fType = kDynInt;
-        fHolder = new DynIntHolder(size, buf);
+        fHolder = new AliDynIntHolder(size, buf);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t size, const UInt_t* buf) {
+// contructor
 
         fType = kDynUInt;
-        fHolder = new DynUIntHolder(size, buf);
+        fHolder = new AliDynUIntHolder(size, buf);
 }
 
+//______________________________________________________________________
 AliSimpleValue::AliSimpleValue(Int_t size, const Float_t* buf) {
+// contructor
 
         fType = kDynFloat;
-        fHolder = new DynFloatHolder(size, buf);
+        fHolder = new AliDynFloatHolder(size, buf);
 }
 
+//______________________________________________________________________
 AliSimpleValue::~AliSimpleValue() {
+// destructor
        
        if (fHolder) {
                delete fHolder;
        }
 }
 
+//______________________________________________________________________
 AliSimpleValue& AliSimpleValue::operator=(const AliSimpleValue& other) {
-       
+// assignment op
+
        if (fHolder) {
                delete fHolder;
        }
@@ -383,7 +459,9 @@ AliSimpleValue& AliSimpleValue::operator=(const AliSimpleValue& other) {
        return *this;
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::operator==(const AliSimpleValue& other) const {
+// equality op
 
        if (fType != other.fType) {
                return kFALSE;
@@ -396,96 +474,118 @@ Bool_t AliSimpleValue::operator==(const AliSimpleValue& other) const {
        return fHolder->IsEqual(other.fHolder);
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetBool(Bool_t val) {
+// set value
 
        if (!TypeOk(kBool)) {
                return;
        }
 
-       ((BoolHolder*) fHolder)->fValue = val;
+       ((AliBoolHolder*) fHolder)->fValue = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetByte(Char_t val) {
+// set value
 
        if (!TypeOk(kByte)) {
                return;
        }
 
-       ((ByteHolder*) fHolder)->fValue = val;
+       ((AliByteHolder*) fHolder)->fValue = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetInt(Int_t val) {
+// set value
 
        if (!TypeOk(kInt)) {
                return;
        }
 
-       ((IntHolder*) fHolder)->fValue = val;
+       ((AliIntHolder*) fHolder)->fValue = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetUInt(UInt_t val) {
+// set value
 
        if (!TypeOk(kUInt)) {
                return;
        }
        
-       ((UIntHolder*) fHolder)->fValue = val;
+       ((AliUIntHolder*) fHolder)->fValue = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetFloat(Float_t val) {
+// set value
 
        if (!TypeOk(kFloat)) {
                return;
        }
 
-       ((FloatHolder*) fHolder)->fValue = val;
+       ((AliFloatHolder*) fHolder)->fValue = val;
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::GetBool() const {
+// get value
 
        if (!TypeOk(kBool)) {
                return kFALSE;
        }       
 
-       return ((BoolHolder*) fHolder)->fValue;
+       return ((AliBoolHolder*) fHolder)->fValue;
 }
 
+//______________________________________________________________________
 Char_t AliSimpleValue::GetByte() const {
+// get value
 
        if (!TypeOk(kByte)) {
                return 0;
        }
        
-        return ((ByteHolder*) fHolder)->fValue;
+        return ((AliByteHolder*) fHolder)->fValue;
 }
 
+//______________________________________________________________________
 Int_t AliSimpleValue::GetInt() const {
+// get value
 
        if (!TypeOk(kInt)) {
                return 0;
        }
-        return ((IntHolder*) fHolder)->fValue;
+        return ((AliIntHolder*) fHolder)->fValue;
 }
 
+//______________________________________________________________________
 UInt_t AliSimpleValue::GetUInt() const {
+// get value
 
        if (!TypeOk(kUInt)) {
                return 0;
         }
 
-        return ((UIntHolder*) fHolder)->fValue;
+        return ((AliUIntHolder*) fHolder)->fValue;
 }
 
+//______________________________________________________________________
 Float_t AliSimpleValue::GetFloat() const {
+// get value
 
        if (!TypeOk(kFloat)) {
                return 0;
        }
 
-        return ((FloatHolder*) fHolder)->fValue;
+        return ((AliFloatHolder*) fHolder)->fValue;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetDynBool(Int_t n, Bool_t val) {
+// set dyn value
        
        if (!TypeOk(kDynBool)) {
                return;
@@ -495,10 +595,12 @@ void AliSimpleValue::SetDynBool(Int_t n, Bool_t val) {
                return;
        }
 
-       ((DynBoolHolder*) fHolder)->fValues[n] = val;
+       ((AliDynBoolHolder*) fHolder)->fValues[n] = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetDynByte(Int_t n, Char_t val) {
+// set dyn value
 
        if (!TypeOk(kDynByte)) {
                 return;
@@ -508,10 +610,12 @@ void AliSimpleValue::SetDynByte(Int_t n, Char_t val) {
                 return;
         }
 
-        ((DynByteHolder*) fHolder)->fValues[n] = val;
+        ((AliDynByteHolder*) fHolder)->fValues[n] = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetDynInt(Int_t n, Int_t val) {
+// set dyn value
 
         if (!TypeOk(kDynInt)) {
                 return;
@@ -521,10 +625,12 @@ void AliSimpleValue::SetDynInt(Int_t n, Int_t val) {
                 return;
         }
 
-        ((DynIntHolder*) fHolder)->fValues[n] = val;
+        ((AliDynIntHolder*) fHolder)->fValues[n] = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetDynUInt(Int_t n, UInt_t val) {
+// set dyn value
 
         if (!TypeOk(kDynUInt)) {
                 return;
@@ -534,10 +640,12 @@ void AliSimpleValue::SetDynUInt(Int_t n, UInt_t val) {
                 return;
         }
 
-        ((DynUIntHolder*) fHolder)->fValues[n] = val;
+        ((AliDynUIntHolder*) fHolder)->fValues[n] = val;
 }
 
+//______________________________________________________________________
 void AliSimpleValue::SetDynFloat(Int_t n, Float_t val) {
+// set dyn value
 
         if (!TypeOk(kDynFloat)) {
                 return;
@@ -547,10 +655,12 @@ void AliSimpleValue::SetDynFloat(Int_t n, Float_t val) {
                 return;
         }
 
-        ((DynFloatHolder*) fHolder)->fValues[n] = val;
+        ((AliDynFloatHolder*) fHolder)->fValues[n] = val;
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::GetDynBool(Int_t n) const {
+// get dyn value
 
        if (!TypeOk(kDynBool)) {
                 return kFALSE;
@@ -560,10 +670,12 @@ Bool_t AliSimpleValue::GetDynBool(Int_t n) const {
                 return kFALSE;
         }
 
-       return ((DynBoolHolder*) fHolder)->fValues[n];
+       return ((AliDynBoolHolder*) fHolder)->fValues[n];
 }
 
+//______________________________________________________________________
 Char_t AliSimpleValue::GetDynByte(Int_t n) const {
+// get dyn value
 
         if (!TypeOk(kDynByte)) {
                 return 0;
@@ -573,10 +685,12 @@ Char_t AliSimpleValue::GetDynByte(Int_t n) const {
                 return 0;
         }
 
-        return ((DynByteHolder*) fHolder)->fValues[n];
+        return ((AliDynByteHolder*) fHolder)->fValues[n];
 }
 
+//______________________________________________________________________
 Int_t AliSimpleValue::GetDynInt(Int_t n) const {
+// get dyn value
 
         if (!TypeOk(kDynInt)) {
                 return 0;
@@ -586,10 +700,12 @@ Int_t AliSimpleValue::GetDynInt(Int_t n) const {
                 return 0;
         }
 
-        return ((DynIntHolder*) fHolder)->fValues[n];
+        return ((AliDynIntHolder*) fHolder)->fValues[n];
 }
 
+//______________________________________________________________________
 UInt_t AliSimpleValue::GetDynUInt(Int_t n) const {
+// get dyn value
 
         if (!TypeOk(kDynUInt)) {
                 return 0;
@@ -599,10 +715,12 @@ UInt_t AliSimpleValue::GetDynUInt(Int_t n) const {
                 return 0;
         }
 
-        return ((DynUIntHolder*) fHolder)->fValues[n];
+        return ((AliDynUIntHolder*) fHolder)->fValues[n];
 }
 
+//______________________________________________________________________
 Float_t AliSimpleValue::GetDynFloat(Int_t n) const {
+// get dyn value
 
         if (!TypeOk(kDynFloat)) {
                 return 0;
@@ -612,10 +730,12 @@ Float_t AliSimpleValue::GetDynFloat(Int_t n) const {
                 return 0;
         }
 
-        return ((DynFloatHolder*) fHolder)->fValues[n];
+        return ((AliDynFloatHolder*) fHolder)->fValues[n];
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::TypeOk(AliSimpleValue::Type type) const {
+// check that AliSimpleValue is of type type
 
        if (fType != type) {
                AliError(Form("SimpleValue type is not %s!", 
@@ -626,7 +746,9 @@ Bool_t AliSimpleValue::TypeOk(AliSimpleValue::Type type) const {
        return kTRUE;
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
+// Check that n is within bounds of dyn value
 
        switch (fType) {
                case kDynBool:
@@ -634,7 +756,7 @@ Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
                case kDynInt:
                case kDynUInt:
                case kDynFloat: {
-                       Int_t size = ((DynHolder*) fHolder)->fSize;
+                       Int_t size = ((AliDynHolder*) fHolder)->fSize;
                        if (n < 0 || n >= size) {
                                AliError(Form("Index %d out of bounds!", n));
                                return kFALSE;
@@ -655,6 +777,7 @@ Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
        }
 }
 
+//______________________________________________________________________
 Int_t AliSimpleValue::GetDynamicSize() const {
        //
        // returns the size of dynamic type or 0 in case of 
@@ -665,14 +788,16 @@ Int_t AliSimpleValue::GetDynamicSize() const {
                return 0;
        }
 
-       if (!fHolder->IsA()->InheritsFrom(DynHolder::Class())) {
+       if (!fHolder->IsA()->InheritsFrom(AliDynHolder::Class())) {
                return 0;
        }
 
-       return ((DynHolder*) fHolder)->fSize;
+       return ((AliDynHolder*) fHolder)->fSize;
 }
 
+//______________________________________________________________________
 TString AliSimpleValue::ToString() const {
+// Print value
        
        TString result;
        
@@ -763,7 +888,9 @@ TString AliSimpleValue::ToString() const {
        return result;
 }
 
+//______________________________________________________________________
 Bool_t AliSimpleValue::IsDynamic(AliSimpleValue::Type type) {
+// check that type is dynamic
 
         switch (type) {
                 case kDynBool:
@@ -777,6 +904,7 @@ Bool_t AliSimpleValue::IsDynamic(AliSimpleValue::Type type) {
        }
 }
 
+//______________________________________________________________________
 Int_t AliSimpleValue::GetSize() const {
        //
        // return the number of bytes used by this value.
@@ -789,6 +917,7 @@ Int_t AliSimpleValue::GetSize() const {
                AliSimpleValue::GetPrimitiveSize(fType);
 } 
 
+//______________________________________________________________________
 Int_t AliSimpleValue::GetPrimitiveSize(AliSimpleValue::Type type) {
        //
        // returns the number of bytes used by particular primitive type
@@ -813,7 +942,9 @@ Int_t AliSimpleValue::GetPrimitiveSize(AliSimpleValue::Type type) {
        }
 } 
 
+//______________________________________________________________________
 const char* AliSimpleValue::GetTypeString(AliSimpleValue::Type type) {
+// return type name correspondyng to type
 
        switch (type) {
                case kBool: return "Bool";
index 4aa35b6..817163f 100644 (file)
@@ -9,6 +9,7 @@
 //
 // This class is a simple wrapper of
 // all primitive types used in PVSS SCADA system.
+// bool, char, byte, int ,uint, float, and arrays of these values
 //
 
 #include <TObject.h>
@@ -125,200 +126,274 @@ public:
 
 private:
 
-       class BoolHolder: public TObject {
+       class AliBoolHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Bool_t fValue;
-
-               BoolHolder() {}
+               AliBoolHolder() {}
+               virtual ~AliBoolHolder() {}
 
-               BoolHolder(Bool_t val):fValue(val) {}
+               AliBoolHolder(Bool_t val):fValue(val) {}
                
                virtual TObject* Clone(const char* name) const; 
        
                virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(BoolHolder, 1);
+       private:
+               Bool_t fValue;          // The value
+
+               ClassDef(AliBoolHolder, 1);
        };
 
-       class ByteHolder: public TObject {
+       class AliByteHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Char_t fValue;
 
-               ByteHolder() {};
+               AliByteHolder() {};
+               virtual ~AliByteHolder() {}
 
-               ByteHolder(Char_t val):fValue(val) {}
+               AliByteHolder(Char_t val):fValue(val) {}
                
                virtual TObject* Clone(const char* name) const;
 
                virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(ByteHolder, 1);
+       private:
+               Char_t fValue;          // The value
+
+               ClassDef(AliByteHolder, 1);
        };
 
-       class IntHolder: public TObject {
+       class AliIntHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Int_t fValue;
 
-               IntHolder() {}
+               AliIntHolder() {}
+               virtual ~AliIntHolder() {}
 
-               IntHolder(Int_t val):fValue(val) {}
+               AliIntHolder(Int_t val):fValue(val) {}
                
                virtual TObject* Clone(const char* name) const; 
 
                virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(IntHolder, 1);
+
+       private:
+               Int_t fValue;           // The value
+
+               ClassDef(AliIntHolder, 1);
        };
 
-       class UIntHolder: public TObject {
+       class AliUIntHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               UInt_t fValue;
 
-               UIntHolder() {}
+               AliUIntHolder() {}
+               virtual ~AliUIntHolder() {}
 
-               UIntHolder(UInt_t val):fValue(val) {}
+               AliUIntHolder(UInt_t val):fValue(val) {}
                
                virtual TObject* Clone(const char* name) const;
 
                virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(UIntHolder, 1);
+
+       private:
+               UInt_t fValue;          // The value
+
+               ClassDef(AliUIntHolder, 1);
        };
 
-       class FloatHolder: public TObject {
+       class AliFloatHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Float_t fValue;
 
-               FloatHolder() {}
+               AliFloatHolder() {}
+               virtual ~AliFloatHolder() {}
        
-               FloatHolder(Float_t val):fValue(val) {}
+               AliFloatHolder(Float_t val):fValue(val) {}
                
                virtual TObject* Clone(const char* name) const;
 
                virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(FloatHolder, 1);
+       private:
+               Float_t fValue;         // The value
+
+               ClassDef(AliFloatHolder, 1);
        };
 
-       class DynHolder: public TObject {
+       class AliDynHolder: public TObject {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Int_t fSize;
 
-               DynHolder(): fSize(0) {}
-               DynHolder(Int_t size): fSize(size){}
+               AliDynHolder(): fSize(0) {}
+               AliDynHolder(Int_t size): fSize(size){}
 
-               ClassDef(DynHolder, 0);
+               Int_t fSize;            // The size
+               ClassDef(AliDynHolder, 0);
        };
 
-       class DynBoolHolder: public DynHolder {
+       class AliDynBoolHolder: public AliDynHolder {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Bool_t* fValues; //[fSize]
 
-               DynBoolHolder(): fValues(NULL) {}
+               AliDynBoolHolder(): fValues(NULL) {}
 
-               DynBoolHolder(Int_t size, const Bool_t* buf = NULL):
-                       DynHolder(size) {
+               AliDynBoolHolder(Int_t size, const Bool_t* buf = NULL):
+                       AliDynHolder(size) {
                        fValues = new Bool_t[size];
                        if (buf) memcpy(fValues, buf, size * sizeof(Bool_t));
                }
 
-               virtual ~DynBoolHolder() {if (fValues) delete[] fValues;}
+               virtual ~AliDynBoolHolder() {if (fValues) delete[] fValues;}
 
                virtual TObject* Clone(const char* name) const;
 
                 virtual Bool_t IsEqual(const TObject* object) const; 
 
-               ClassDef(DynBoolHolder, 1);
+
+       private:
+               AliDynBoolHolder(const AliDynBoolHolder& /*other*/): AliDynHolder() { }
+               AliDynBoolHolder& operator= (const AliDynBoolHolder& /*other*/) {return *this;}
+               Bool_t* fValues; //[fSize]       The value
+
+               ClassDef(AliDynBoolHolder, 1);
        };
 
-       class DynByteHolder: public DynHolder {
+       class AliDynByteHolder: public AliDynHolder {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Char_t* fValues; //[fSize]
        
-               DynByteHolder(): fValues(NULL) {}
+               AliDynByteHolder(): fValues(NULL) {}
 
-               DynByteHolder(Int_t size, const Char_t* buf = NULL):
-                       DynHolder(size) {
+               AliDynByteHolder(Int_t size, const Char_t* buf = NULL):
+                       AliDynHolder(size) {
                        fValues = new Char_t[size];
                        if (buf) memcpy(fValues, buf, size * sizeof(Char_t));
                }
 
-               virtual ~DynByteHolder() {if (fValues) delete[] fValues;}
+               virtual ~AliDynByteHolder() {if (fValues) delete[] fValues;}
 
                virtual TObject* Clone(const char* name) const;
 
                 virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(DynByteHolder, 1);
+
+       private:
+               AliDynByteHolder(const AliDynByteHolder& /*other*/): AliDynHolder() { }
+               AliDynByteHolder& operator= (const AliDynByteHolder& /*other*/) {return *this;}
+               Char_t* fValues; //[fSize]       The value
+
+               ClassDef(AliDynByteHolder, 1);
        };
 
-       class DynIntHolder: public DynHolder {
+       class AliDynIntHolder: public AliDynHolder {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Int_t* fValues; //[fSize]
 
-               DynIntHolder(): fValues(NULL) {}
+               AliDynIntHolder(): fValues(NULL) {}
 
-               DynIntHolder(Int_t size, const Int_t* buf = NULL):
-                       DynHolder(size) {
+               AliDynIntHolder(Int_t size, const Int_t* buf = NULL):
+                       AliDynHolder(size) {
                        fValues = new Int_t[size];
                        if (buf) memcpy(fValues, buf, size * sizeof(Int_t));
                }
 
-               virtual ~DynIntHolder() {if (fValues) delete[] fValues;}
+               virtual ~AliDynIntHolder() {if (fValues) delete[] fValues;}
 
                virtual TObject* Clone(const char* name) const;
 
                 virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(DynIntHolder, 1);
+
+       private:
+               AliDynIntHolder(const AliDynIntHolder& /*other*/): AliDynHolder() { }
+               AliDynIntHolder& operator= (const AliDynIntHolder& /*other*/) {return *this;}
+               Int_t* fValues; //[fSize]        The value
+
+               ClassDef(AliDynIntHolder, 1);
        };
 
-       class DynUIntHolder: public DynHolder {
+       class AliDynUIntHolder: public AliDynHolder {
+       
+       friend class AliSimpleValue;
+       
        public:
-               UInt_t* fValues; //[fSize]
 
-               DynUIntHolder(): fValues(NULL) {}
+               AliDynUIntHolder(): fValues(NULL) {}
 
-               DynUIntHolder(Int_t size, const UInt_t* buf = NULL):
-                       DynHolder(size) {
+               AliDynUIntHolder(Int_t size, const UInt_t* buf = NULL):
+                       AliDynHolder(size) {
                        fValues = new UInt_t[size];
                        if (buf) memcpy(fValues, buf, size * sizeof(UInt_t));   
                } 
 
-               virtual ~DynUIntHolder() {if (fValues) delete[] fValues;}
+               virtual ~AliDynUIntHolder() {if (fValues) delete[] fValues;}
 
                virtual TObject* Clone(const char* name) const;
 
                 virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(DynUIntHolder, 1);
+
+       private:
+               AliDynUIntHolder(const AliDynUIntHolder& /*other*/): AliDynHolder() { }
+               AliDynUIntHolder& operator= (const AliDynUIntHolder& /*other*/) {return *this;}
+               UInt_t* fValues; //[fSize]       The value
+
+               ClassDef(AliDynUIntHolder, 1);
        };
 
-       class DynFloatHolder: public DynHolder {
+       class AliDynFloatHolder: public AliDynHolder {
+       
+       friend class AliSimpleValue;
+       
        public:
-               Float_t* fValues; //[fSize]
 
-               DynFloatHolder(): fValues(NULL) {}
+               AliDynFloatHolder(): fValues(NULL) {}
 
-               DynFloatHolder(Int_t size, const Float_t* buf = NULL):
-                       DynHolder(size) {
+               AliDynFloatHolder(Int_t size, const Float_t* buf = NULL):
+                       AliDynHolder(size) {
                        fValues = new Float_t[size];
                        if (buf) memcpy(fValues, buf, size * sizeof(Float_t));
                }
 
-               virtual ~DynFloatHolder() {if (fValues) delete[] fValues;}
+               virtual ~AliDynFloatHolder() {if (fValues) delete[] fValues;}
 
                virtual TObject* Clone(const char* name) const;
 
                 virtual Bool_t IsEqual(const TObject* object) const;
 
-               ClassDef(DynFloatHolder, 1);
+
+       private:
+               AliDynFloatHolder(const AliDynFloatHolder& /*other*/): AliDynHolder() { }
+               AliDynFloatHolder& operator= (const AliDynFloatHolder& /*other*/) {return *this;}
+               Float_t* fValues; //[fSize]      The value
+
+               ClassDef(AliDynFloatHolder, 1);
        };
 
 
-       TObject* fHolder;
+       TObject* fHolder;       // Holder of the basic type value
 
-       Type fType;
+       Type fType;     // Type of the basic type value
 
 
        Bool_t TypeOk(Type type) const;
index 8750ea8..3b7f2de 100644 (file)
 #pragma link C++ class AliCDBGridParam;
 
 #pragma link C++ class AliSimpleValue;
-#pragma link C++ class AliSimpleValue::BoolHolder;
-#pragma link C++ class AliSimpleValue::ByteHolder;
-#pragma link C++ class AliSimpleValue::IntHolder;
-#pragma link C++ class AliSimpleValue::UIntHolder;
-#pragma link C++ class AliSimpleValue::FloatHolder;
-#pragma link C++ class AliSimpleValue::DynHolder;
-#pragma link C++ class AliSimpleValue::DynBoolHolder;
-#pragma link C++ class AliSimpleValue::DynByteHolder;
-#pragma link C++ class AliSimpleValue::DynIntHolder;
-#pragma link C++ class AliSimpleValue::DynUIntHolder;
-#pragma link C++ class AliSimpleValue::DynFloatHolder;
+#pragma link C++ class AliSimpleValue::AliBoolHolder;
+#pragma link C++ class AliSimpleValue::AliByteHolder;
+#pragma link C++ class AliSimpleValue::AliIntHolder;
+#pragma link C++ class AliSimpleValue::AliUIntHolder;
+#pragma link C++ class AliSimpleValue::AliFloatHolder;
+#pragma link C++ class AliSimpleValue::AliDynHolder;
+#pragma link C++ class AliSimpleValue::AliDynBoolHolder;
+#pragma link C++ class AliSimpleValue::AliDynByteHolder;
+#pragma link C++ class AliSimpleValue::AliDynIntHolder;
+#pragma link C++ class AliSimpleValue::AliDynUIntHolder;
+#pragma link C++ class AliSimpleValue::AliDynFloatHolder;
 #pragma link C++ class AliDCSValue;
 
 #pragma link C++ class AliPreprocessor;