/*
$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)
#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;
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;
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;
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;
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;
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;
}
return *this;
}
+//______________________________________________________________________
Bool_t AliSimpleValue::operator==(const AliSimpleValue& other) const {
+// equality op
if (fType != other.fType) {
return kFALSE;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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!",
return kTRUE;
}
+//______________________________________________________________________
Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
+// Check that n is within bounds of dyn value
switch (fType) {
case kDynBool:
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;
}
}
+//______________________________________________________________________
Int_t AliSimpleValue::GetDynamicSize() const {
//
// returns the size of dynamic type or 0 in case of
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;
return result;
}
+//______________________________________________________________________
Bool_t AliSimpleValue::IsDynamic(AliSimpleValue::Type type) {
+// check that type is dynamic
switch (type) {
case kDynBool:
}
}
+//______________________________________________________________________
Int_t AliSimpleValue::GetSize() const {
//
// return the number of bytes used by this value.
AliSimpleValue::GetPrimitiveSize(fType);
}
+//______________________________________________________________________
Int_t AliSimpleValue::GetPrimitiveSize(AliSimpleValue::Type type) {
//
// returns the number of bytes used by particular primitive type
}
}
+//______________________________________________________________________
const char* AliSimpleValue::GetTypeString(AliSimpleValue::Type type) {
+// return type name correspondyng to type
switch (type) {
case kBool: return "Bool";
//
// 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>
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;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff