+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/*
-$Log$
-Revision 1.2 2005/11/17 14:43:23 byordano
-import to local CVS
-
-Revision 1.1.1.1 2005/10/28 07:33:58 hristov
-Initial import as subdirectory in AliRoot
-
-Revision 1.1.1.1 2005/09/12 22:11:40 byordano
-SHUTTLE package
-
-Revision 1.2 2005/08/30 10:53:23 byordano
-some more descriptions added
-
-*/
-
-//
-// This class is a simple wrapper of
-// all primitive types used in PVSS SCADA system.
-//
-
-
-#include "AliSimpleValue.h"
-
-#include "AliLog.h"
-#include <TClass.h>
-
-TObject* AliSimpleValue::BoolHolder::Clone(const char* /*name*/) const {
- return new BoolHolder(fValue);
-}
-
-Bool_t AliSimpleValue::BoolHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (BoolHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- return fValue == ((const BoolHolder*) obj)->fValue;
-}
-
-TObject* AliSimpleValue::ByteHolder::Clone(const char* /*name*/) const {
- return new ByteHolder(fValue);
-}
-
-Bool_t AliSimpleValue::ByteHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (ByteHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- return fValue == ((const ByteHolder*) obj)->fValue;
-}
-
-TObject* AliSimpleValue::IntHolder::Clone(const char* /*name*/) const {
- return new IntHolder(fValue);
-}
-
-Bool_t AliSimpleValue::IntHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (IntHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- return fValue == ((const IntHolder*) obj)->fValue;
-}
-
-TObject* AliSimpleValue::UIntHolder::Clone(const char* /*name*/) const {
- return new UIntHolder(fValue);
-}
-
-Bool_t AliSimpleValue::UIntHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (UIntHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- return fValue == ((const UIntHolder*) obj)->fValue;
-}
-
-TObject* AliSimpleValue::FloatHolder::Clone(const char* /*name*/) const {
- return new FloatHolder(fValue);
-}
-
-Bool_t AliSimpleValue::FloatHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (FloatHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- return fValue == ((const FloatHolder*) obj)->fValue;
-}
-
-TObject* AliSimpleValue::DynBoolHolder::Clone(const char* /*name*/) const {
- return new DynBoolHolder(fSize, fValues);
-}
-
-Bool_t AliSimpleValue::DynBoolHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (DynBoolHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- const DynBoolHolder* other = ((const DynBoolHolder*) 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);
-}
-
-Bool_t AliSimpleValue::DynByteHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (DynByteHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- const DynByteHolder* other = ((const DynByteHolder*) 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);
-}
-
-Bool_t AliSimpleValue::DynIntHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (DynIntHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- const DynIntHolder* other = ((const DynIntHolder*) 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);
-}
-
-Bool_t AliSimpleValue::DynUIntHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (DynUIntHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- const DynUIntHolder* other = ((const DynUIntHolder*) 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);
-}
-
-Bool_t AliSimpleValue::DynFloatHolder::IsEqual(const TObject* obj) const {
-
- if (this == obj) {
- return kTRUE;
- }
-
- if (DynFloatHolder::Class() != obj->IsA()) {
- return kFALSE;
- }
-
- const DynFloatHolder* other = ((const DynFloatHolder*) obj);
-
- if (fSize != other->fSize) {
- return kFALSE;
- }
-
- return !memcmp(fValues, other->fValues, fSize * sizeof(Float_t));
-}
-
-ClassImp(AliSimpleValue)
-
-AliSimpleValue::AliSimpleValue():
- fHolder(NULL), fType(kInvalid)
-{
-
-}
-
-AliSimpleValue::AliSimpleValue(const AliSimpleValue& other):
- TObject(other), fHolder(NULL), fType(other.fType)
-{
- if (other.fHolder) {
- fHolder = other.fHolder->Clone();
- }
-}
-
-AliSimpleValue::AliSimpleValue(AliSimpleValue::Type type, Int_t size):
- fHolder(NULL), fType(type)
-{
-
- switch (type) {
- case kBool:
- fHolder = new BoolHolder();
- break;
- case kByte:
- fHolder = new ByteHolder();
- break;
- case kInt:
- fHolder = new IntHolder();
- break;
- case kUInt:
- fHolder = new UIntHolder();
- break;
- case kFloat:
- fHolder = new FloatHolder();
- break;
- case kDynBool:
- fHolder = new DynBoolHolder(size);
- break;
- case kDynByte:
- fHolder = new DynByteHolder(size);
- break;
- case kDynInt:
- fHolder = new DynIntHolder(size);
- break;
- case kDynUInt:
- fHolder = new DynUIntHolder(size);
- break;
- case kDynFloat:
- fHolder = new DynFloatHolder(size);
- break;
- default:
- break;
- }
-}
-
-AliSimpleValue::AliSimpleValue(Bool_t val) {
-
- fType = kBool;
- fHolder = new BoolHolder(val);
-}
-
-AliSimpleValue::AliSimpleValue(Char_t val) {
-
- fType = kByte;
- fHolder = new ByteHolder(val);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t val) {
-
- fType = kInt;
- fHolder = new IntHolder(val);
-}
-
-AliSimpleValue::AliSimpleValue(UInt_t val) {
-
- fType = kUInt;
- fHolder = new UIntHolder(val);
-}
-
-AliSimpleValue::AliSimpleValue(Float_t val) {
-
- fType = kFloat;
- fHolder = new FloatHolder(val);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Bool_t* buf) {
-
- fType = kDynBool;
- fHolder = new DynBoolHolder(size, buf);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Char_t* buf) {
-
- fType = kDynByte;
- fHolder = new DynByteHolder(size, buf);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Int_t* buf) {
-
- fType = kDynInt;
- fHolder = new DynIntHolder(size, buf);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t size, const UInt_t* buf) {
-
- fType = kDynUInt;
- fHolder = new DynUIntHolder(size, buf);
-}
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Float_t* buf) {
-
- fType = kDynFloat;
- fHolder = new DynFloatHolder(size, buf);
-}
-
-AliSimpleValue::~AliSimpleValue() {
-
- if (fHolder) {
- delete fHolder;
- }
-}
-
-AliSimpleValue& AliSimpleValue::operator=(const AliSimpleValue& other) {
-
- if (fHolder) {
- delete fHolder;
- }
-
- fType = other.fType;
-
- if (other.fHolder) {
- fHolder = other.fHolder->Clone();
- } else {
- fHolder = NULL;
- }
-
- return *this;
-}
-
-Bool_t AliSimpleValue::operator==(const AliSimpleValue& other) const {
-
- if (fType != other.fType) {
- return kFALSE;
- }
-
- if (!(fHolder && other.fHolder)) {
- return kFALSE;
- }
-
- return fHolder->IsEqual(other.fHolder);
-}
-
-void AliSimpleValue::SetBool(Bool_t val) {
-
- if (!TypeOk(kBool)) {
- return;
- }
-
- ((BoolHolder*) fHolder)->fValue = val;
-}
-
-void AliSimpleValue::SetByte(Char_t val) {
-
- if (!TypeOk(kByte)) {
- return;
- }
-
- ((ByteHolder*) fHolder)->fValue = val;
-}
-
-void AliSimpleValue::SetInt(Int_t val) {
-
- if (!TypeOk(kInt)) {
- return;
- }
-
- ((IntHolder*) fHolder)->fValue = val;
-}
-
-void AliSimpleValue::SetUInt(UInt_t val) {
-
- if (!TypeOk(kUInt)) {
- return;
- }
-
- ((UIntHolder*) fHolder)->fValue = val;
-}
-
-void AliSimpleValue::SetFloat(Float_t val) {
-
- if (!TypeOk(kFloat)) {
- return;
- }
-
- ((FloatHolder*) fHolder)->fValue = val;
-}
-
-Bool_t AliSimpleValue::GetBool() const {
-
- if (!TypeOk(kBool)) {
- return kFALSE;
- }
-
- return ((BoolHolder*) fHolder)->fValue;
-}
-
-Char_t AliSimpleValue::GetByte() const {
-
- if (!TypeOk(kByte)) {
- return 0;
- }
-
- return ((ByteHolder*) fHolder)->fValue;
-}
-
-Int_t AliSimpleValue::GetInt() const {
-
- if (!TypeOk(kInt)) {
- return 0;
- }
- return ((IntHolder*) fHolder)->fValue;
-}
-
-UInt_t AliSimpleValue::GetUInt() const {
-
- if (!TypeOk(kUInt)) {
- return 0;
- }
-
- return ((UIntHolder*) fHolder)->fValue;
-}
-
-Float_t AliSimpleValue::GetFloat() const {
-
- if (!TypeOk(kFloat)) {
- return 0;
- }
-
- return ((FloatHolder*) fHolder)->fValue;
-}
-
-void AliSimpleValue::SetDynBool(Int_t n, Bool_t val) {
-
- if (!TypeOk(kDynBool)) {
- return;
- }
-
- if (!BoundsOk(n)) {
- return;
- }
-
- ((DynBoolHolder*) fHolder)->fValues[n] = val;
-}
-
-void AliSimpleValue::SetDynByte(Int_t n, Char_t val) {
-
- if (!TypeOk(kDynByte)) {
- return;
- }
-
- if (!BoundsOk(n)) {
- return;
- }
-
- ((DynByteHolder*) fHolder)->fValues[n] = val;
-}
-
-void AliSimpleValue::SetDynInt(Int_t n, Int_t val) {
-
- if (!TypeOk(kDynInt)) {
- return;
- }
-
- if (!BoundsOk(n)) {
- return;
- }
-
- ((DynIntHolder*) fHolder)->fValues[n] = val;
-}
-
-void AliSimpleValue::SetDynUInt(Int_t n, UInt_t val) {
-
- if (!TypeOk(kDynUInt)) {
- return;
- }
-
- if (!BoundsOk(n)) {
- return;
- }
-
- ((DynUIntHolder*) fHolder)->fValues[n] = val;
-}
-
-void AliSimpleValue::SetDynFloat(Int_t n, Float_t val) {
-
- if (!TypeOk(kDynFloat)) {
- return;
- }
-
- if (!BoundsOk(n)) {
- return;
- }
-
- ((DynFloatHolder*) fHolder)->fValues[n] = val;
-}
-
-Bool_t AliSimpleValue::GetDynBool(Int_t n) const {
-
- if (!TypeOk(kDynBool)) {
- return kFALSE;
- }
-
- if (!BoundsOk(n)) {
- return kFALSE;
- }
-
- return ((DynBoolHolder*) fHolder)->fValues[n];
-}
-
-Char_t AliSimpleValue::GetDynByte(Int_t n) const {
-
- if (!TypeOk(kDynByte)) {
- return 0;
- }
-
- if (!BoundsOk(n)) {
- return 0;
- }
-
- return ((DynByteHolder*) fHolder)->fValues[n];
-}
-
-Int_t AliSimpleValue::GetDynInt(Int_t n) const {
-
- if (!TypeOk(kDynInt)) {
- return 0;
- }
-
- if (!BoundsOk(n)) {
- return 0;
- }
-
- return ((DynIntHolder*) fHolder)->fValues[n];
-}
-
-UInt_t AliSimpleValue::GetDynUInt(Int_t n) const {
-
- if (!TypeOk(kDynUInt)) {
- return 0;
- }
-
- if (!BoundsOk(n)) {
- return 0;
- }
-
- return ((DynUIntHolder*) fHolder)->fValues[n];
-}
-
-Float_t AliSimpleValue::GetDynFloat(Int_t n) const {
-
- if (!TypeOk(kDynFloat)) {
- return 0;
- }
-
- if (!BoundsOk(n)) {
- return 0;
- }
-
- return ((DynFloatHolder*) fHolder)->fValues[n];
-}
-
-Bool_t AliSimpleValue::TypeOk(AliSimpleValue::Type type) const {
-
- if (fType != type) {
- AliError(Form("SimpleValue type is not %s!",
- GetTypeString(type)));
- return kFALSE;
- }
-
- return kTRUE;
-}
-
-Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
-
- switch (fType) {
- case kDynBool:
- case kDynByte:
- case kDynInt:
- case kDynUInt:
- case kDynFloat: {
- Int_t size = ((DynHolder*) fHolder)->fSize;
- if (n < 0 || n >= size) {
- AliError(Form("Index %d out of bounds!", n));
- return kFALSE;
- }
- return kTRUE;
- }
- case kBool:
- case kByte:
- case kInt:
- case kUInt:
- case kFloat:
- AliError(Form("SimpleValue type %s is not dynamic!",
- GetTypeString(fType)));
- return kFALSE;
- default:
- AliError("Invalid or unknown type!");
- return kFALSE;
- }
-}
-
-Int_t AliSimpleValue::GetDynamicSize() const {
- //
- // returns the size of dynamic type or 0 in case of
- // none dynamic type.
- //
-
- if (!fHolder) {
- return 0;
- }
-
- if (!fHolder->IsA()->InheritsFrom(DynHolder::Class())) {
- return 0;
- }
-
- return ((DynHolder*) fHolder)->fSize;
-}
-
-TString AliSimpleValue::ToString() const {
-
- TString result;
-
- result += "Type: ";
- result += GetTypeString(fType);
-
- result += ", Value: ";
- switch (fType) {
- case kBool:
- result += GetBool();
- break;
- case kByte:
- result += (Int_t) GetByte();
- break;
- case kInt:
- result += GetInt();
- break;
- case kUInt:
- result += GetUInt();
- break;
- case kFloat:
- result += GetFloat();
- break;
- case kDynBool: {
- result += "[";
- Int_t size = GetDynamicSize();
- for (Int_t k = 0; k < size; k ++) {
- result += GetDynBool(k);
- if (k + 1 < size) {
- result += ", ";
- }
- }
- result += "]";
- }
- break;
- case kDynByte: {
- result += "[";
- Int_t size = GetDynamicSize();
- for (Int_t k = 0; k < size; k ++) {
- result += GetDynByte(k);
- if (k + 1 < size) {
- result += ", ";
- }
- }
- result += "]";
- }
- break;
- case kDynInt: {
- result += "[";
- Int_t size = GetDynamicSize();
- for (Int_t k = 0; k < size; k ++) {
- result += GetDynInt(k);
- if (k + 1 < size) {
- result += ", ";
- }
- }
- result += "]";
- }
- break;
- case kDynUInt: {
- result += "[";
- Int_t size = GetDynamicSize();
- for (Int_t k = 0; k < size; k ++) {
- result += GetDynUInt(k);
- if (k + 1 < size) {
- result += ", ";
- }
- }
- result += "]";
- }
- break;
- case kDynFloat: {
- result += "[";
- Int_t size = GetDynamicSize();
- for (Int_t k = 0; k < size; k ++) {
- result += GetDynFloat(k);
- if (k + 1 < size) {
- result += ", ";
- }
- }
- result += "]";
- }
- break;
- default:
- result += "Unknown";
- }
-
- return result;
-}
-
-Bool_t AliSimpleValue::IsDynamic(AliSimpleValue::Type type) {
-
- switch (type) {
- case kDynBool:
- case kDynByte:
- case kDynInt:
- case kDynUInt:
- case kDynFloat:
- return kTRUE;
- default:
- return kFALSE;
- }
-}
-
-Int_t AliSimpleValue::GetSize() const {
- //
- // return the number of bytes used by this value.
- // In case of dynamic type it returns dynamic size multiplied
- // by the size of corresponding primitive type.
- //
-
- return IsDynamic(fType) ?
- GetDynamicSize() * AliSimpleValue::GetPrimitiveSize(fType):
- AliSimpleValue::GetPrimitiveSize(fType);
-}
-
-Int_t AliSimpleValue::GetPrimitiveSize(AliSimpleValue::Type type) {
- //
- // returns the number of bytes used by particular primitive type
- // or by the corresponding primitive type in case of dynamic type.
- //
-
-
- switch (type) {
-
- case kBool:
- case kDynBool: return sizeof(Bool_t);
- case kByte:
- case kDynByte: return sizeof(Char_t);
- case kInt:
- case kDynInt: return sizeof(Int_t);
- case kUInt:
- case kDynUInt: return sizeof(UInt_t);
- case kFloat:
- case kDynFloat: return sizeof(Float_t);
- default:
- return 0;
- }
-}
-
-const char* AliSimpleValue::GetTypeString(AliSimpleValue::Type type) {
-
- switch (type) {
- case kBool: return "Bool";
- case kByte: return "Byte";
- case kInt: return "Int";
- case kUInt: return "UInt";
- case kFloat: return "Float";
- case kDynBool: return "DynBool";
- case kDynByte: return "DynByte";
- case kDynInt: return "DynInt";
- case kDynUInt: return "DynUInt";
- case kDynFloat: return "DynFloat";
- default:
- return "Unknown";
- }
-}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff