revision of AliDCSValue: Removed wrapper classes, reduced storage size per value...
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Jul 2006 14:59:57 +0000 (14:59 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Jul 2006 14:59:57 +0000 (14:59 +0000)
16 files changed:
SHUTTLE/AliDCSClient.cxx
SHUTTLE/AliDCSMessage.cxx
SHUTTLE/AliDCSMessage.h
SHUTTLE/AliShuttle.cxx
SHUTTLE/AliShuttleTrigger.cxx
SHUTTLE/TestShuttle/AliTestDataDCS.cxx
SHUTTLE/TestShuttle/TestCDB/DET/DCS/Data/Run0_0_v0_s0.root
SHUTTLE/TestShuttle/TestPreprocessor.C
SHUTTLE/test/AliTPCDataDCS.cxx
SHUTTLE/test/TestServer.cxx
STEER/AliDCSValue.cxx
STEER/AliDCSValue.h
STEER/AliSimpleValue.cxx [deleted file]
STEER/AliSimpleValue.h [deleted file]
STEER/CDBLinkDef.h
STEER/libCDB.pkg

index b814348..4ad1636 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2006/06/12 09:11:16  jgrosseo
+coding conventions (Alberto)
+
 Revision 1.2  2006/03/07 07:52:34  hristov
 New version (B.Yordanov)
 
@@ -379,7 +382,7 @@ Int_t AliDCSClient::GetValues(AliDCSMessage::RequestType reqType,
 }
        
 //______________________________________________________________________
-Int_t AliDCSClient::ReceiveValueSet(TObjArray& result) 
+Int_t AliDCSClient::ReceiveValueSet(TObjArray& result)
 {
 // receive set of values 
 
@@ -410,7 +413,7 @@ Int_t AliDCSClient::ReceiveValueSet(TObjArray& result)
 
        UInt_t receivedValues = 0;
 
-       AliSimpleValue::Type valueType = AliSimpleValue::kInvalid;
+       AliDCSValue::Type valueType = AliDCSValue::kInvalid;
 
        while (receivedValues < valueCount) {
 
@@ -424,10 +427,10 @@ Int_t AliDCSClient::ReceiveValueSet(TObjArray& result)
 
                 if (message.GetType() == AliDCSMessage::kResultSet) {
 
-                       if (valueType == AliSimpleValue::kInvalid) {
-                               valueType = message.GetSimpleValueType();
+                       if (valueType == AliDCSValue::kInvalid) {
+                               valueType = message.GetValueType();
                        } else {
-                               if (valueType != message.GetSimpleValueType()) {
+                               if (valueType != message.GetValueType()) {
                                        AliError("Unexpected value type!");
                                        return AliDCSClient::fgkBadMessage;
                                }
index 4a22171..c8c8701 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2006/06/12 09:11:16  jgrosseo
+coding conventions (Alberto)
+
 Revision 1.2  2006/03/07 07:52:34  hristov
 New version (B.Yordanov)
 
@@ -161,14 +164,14 @@ void AliDCSMessage::CreateCountMessage(UInt_t count)
 }
 
 //______________________________________________________________________
-void AliDCSMessage::CreateResultSetMessage(AliSimpleValue::Type type) 
+void AliDCSMessage::CreateResultSetMessage(AliDCSValue::Type type)
 {
-// Create result set message
+  // Create result set message
 
        DestroyMessage();
 
        fType = AliDCSMessage::kResultSet;
-       fSimpleValueType = type; 
+       fValueType = type;
 }
 
 //______________________________________________________________________
@@ -389,95 +392,90 @@ void AliDCSMessage::StoreCountMessage()
 }
 
 //______________________________________________________________________
-void AliDCSMessage::StoreResultSetMessage() 
+void AliDCSMessage::StoreResultSetMessage()
 {
 // store result set message
 
-       TIter iter(&fValues);
-       AliDCSValue* aValue;
-
-       UInt_t valueDataSize = 0;
-       while ((aValue = (AliDCSValue*) iter.Next())) {
-               if (AliSimpleValue::IsDynamic(fSimpleValueType)) {
-                       valueDataSize +=  1;
-               }       
-       
-               valueDataSize += aValue->GetSize();
-       }
-       
-       fMessageSize = VALUES_OFFSET + valueDataSize;
-       
-       fMessage = new char[fMessageSize];
-
-       StoreHeader();
-
-       SetUByte(fMessage + SVT_OFFSET, fSimpleValueType);
-       SetUInt(fMessage + VALUE_COUNT_OFFSET, GetValueCount());
-
-       UInt_t cursor = VALUES_OFFSET;
-       
-       iter.Reset();
-
-       if (fSimpleValueType == AliSimpleValue::kBool) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                       SetBool(fMessage + cursor, aValue->
-                               GetSimpleValue().GetBool());
-                       cursor += 1;
-                       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
-                       cursor += sizeof(UInt_t);
-               }
-       } else if (fSimpleValueType == AliSimpleValue::kByte) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                       SetByte(fMessage + cursor, aValue->
-                               GetSimpleValue().GetByte());
-                       cursor += sizeof(Char_t);
-                       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
-                       cursor += sizeof(UInt_t);
-               }
-       } else if (fSimpleValueType == AliSimpleValue::kInt) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                        SetInt(fMessage + cursor, aValue->
-                                GetSimpleValue().GetInt());
-                        cursor += sizeof(Int_t);
+  TIter iter(&fValues);
+  AliDCSValue* aValue;
+
+  UInt_t valueDataSize = 0;
+  while ((aValue = (AliDCSValue*) iter.Next())) {
+    if (AliDCSValue::IsDynamic(fValueType)) {
+      valueDataSize +=  1;
+    }  
+
+    valueDataSize += aValue->GetSize();
+  }
+
+  fMessageSize = VALUES_OFFSET + valueDataSize;
+
+  fMessage = new char[fMessageSize];
+
+  StoreHeader();
+
+  SetUByte(fMessage + SVT_OFFSET, fValueType);
+  SetUInt(fMessage + VALUE_COUNT_OFFSET, GetValueCount());
+
+  UInt_t cursor = VALUES_OFFSET;
+
+  iter.Reset();
+
+  if (fValueType == AliDCSValue::kBool) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      SetBool(fMessage + cursor, aValue->GetBool());
+      cursor += 1;
+      SetUInt(fMessage + cursor, aValue->GetTimeStamp());
+            cursor += sizeof(UInt_t);
+    }
+  } else if (fValueType == AliDCSValue::kChar) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      SetByte(fMessage + cursor, aValue->GetChar());
+      cursor += sizeof(Char_t);
+      SetUInt(fMessage + cursor, aValue->GetTimeStamp());
+      cursor += sizeof(UInt_t);
+    }
+  } else if (fValueType == AliDCSValue::kInt) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      SetInt(fMessage + cursor, aValue->GetInt());
+      cursor += sizeof(Int_t);
+      SetUInt(fMessage + cursor, aValue->GetTimeStamp());
+      cursor += sizeof(UInt_t);
+    }
+  } else if (fValueType == AliDCSValue::kUInt) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      SetUInt(fMessage + cursor, aValue->GetUInt());
+      cursor += sizeof(UInt_t);
+      SetUInt(fMessage + cursor, aValue->GetTimeStamp());
+      cursor += sizeof(UInt_t);
+    }
+  } else if (fValueType == AliDCSValue::kFloat) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      SetFloat(fMessage + cursor, aValue->GetFloat());
+      cursor += sizeof(Float_t);
+      SetUInt(fMessage + cursor, aValue->GetTimeStamp());
+      cursor += sizeof(UInt_t);
+    }
+/*     } else if (fValueType == AliSimpleValue::kDynBool) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
+      Int_t dynSize = aValue->GetSimpleValue().
+        GetDynamicSize();
+      SetUByte(fMessage + cursor, dynSize);
+      cursor += 1;
+      for (Int_t k = 0; k < dynSize; k ++) {
+                          SetBool(fMessage + cursor, aValue->
+                                  GetSimpleValue().GetDynBool(k));
+                          cursor += 1;
+      }
                         SetUInt(fMessage + cursor, aValue->GetTimeStamp());
                         cursor += sizeof(UInt_t);
                 }
-       } else if (fSimpleValueType == AliSimpleValue::kUInt) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                        SetUInt(fMessage + cursor, aValue->
-                                GetSimpleValue().GetUInt());
-                        cursor += sizeof(UInt_t);
-                        SetUInt(fMessage + cursor, aValue->GetTimeStamp());
-                        cursor += sizeof(UInt_t);
-                }
-       } else if (fSimpleValueType == AliSimpleValue::kFloat) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                        SetFloat(fMessage + cursor, aValue->
-                                GetSimpleValue().GetFloat());
-                        cursor += sizeof(Float_t);
-                        SetUInt(fMessage + cursor, aValue->GetTimeStamp());
-                        cursor += sizeof(UInt_t);
-                }
-/*     } else if (fSimpleValueType == AliSimpleValue::kDynBool) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
-                       Int_t dynSize = aValue->GetSimpleValue().
-                               GetDynamicSize();
-                       SetUByte(fMessage + cursor, dynSize);
-                       cursor += 1;
-                       for (Int_t k = 0; k < dynSize; k ++) {
-                               SetBool(fMessage + cursor, aValue->
-                                       GetSimpleValue().GetDynBool(k));
-                               cursor += 1;
-                       }
-                        SetUInt(fMessage + cursor, aValue->GetTimeStamp());
-                        cursor += sizeof(UInt_t);
-                }
-       } else if (fSimpleValueType == AliSimpleValue::kDynByte) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
+  } else if (fValueType == AliSimpleValue::kDynByte) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
                         Int_t dynSize = aValue->GetSimpleValue().
                                 GetDynamicSize();
                         SetUByte(fMessage + cursor, dynSize);
-                       cursor += 1;    
+      cursor += 1;     
                         for (Int_t k = 0; k < dynSize; k ++) {
                                 SetByte(fMessage + cursor, aValue->
                                         GetSimpleValue().GetDynByte(k));
@@ -486,8 +484,8 @@ void AliDCSMessage::StoreResultSetMessage()
                         SetUInt(fMessage + cursor, aValue->GetTimeStamp());
                         cursor += sizeof(UInt_t);
                 }
-       } else if (fSimpleValueType == AliSimpleValue::kDynInt) {
-                while ((aValue = (AliDCSValue*) iter.Next())) {
+  } else if (fValueType == AliSimpleValue::kDynInt) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
                         Int_t dynSize = aValue->GetSimpleValue().
                                 GetDynamicSize();
                         SetUByte(fMessage + cursor, dynSize);
@@ -500,8 +498,8 @@ void AliDCSMessage::StoreResultSetMessage()
                         SetUInt(fMessage + cursor, aValue->GetTimeStamp());
                         cursor += sizeof(UInt_t);
                 }
-       } else if (fSimpleValueType == AliSimpleValue::kDynUInt) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
+  } else if (fValueType == AliSimpleValue::kDynUInt) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
                         Int_t dynSize = aValue->GetSimpleValue().
                                 GetDynamicSize();
                         SetUByte(fMessage + cursor, dynSize);
@@ -514,8 +512,8 @@ void AliDCSMessage::StoreResultSetMessage()
                         SetUInt(fMessage + cursor, aValue->GetTimeStamp());
                         cursor += sizeof(UInt_t);
                 }
-       } else if (fSimpleValueType == AliSimpleValue::kDynFloat) {
-               while ((aValue = (AliDCSValue*) iter.Next())) {
+  } else if (fValueType == AliSimpleValue::kDynFloat) {
+    while ((aValue = (AliDCSValue*) iter.Next())) {
                         Int_t dynSize = aValue->GetSimpleValue().
                                 GetDynamicSize();
                         SetUByte(fMessage + cursor, dynSize);
@@ -528,10 +526,10 @@ void AliDCSMessage::StoreResultSetMessage()
                         SetUInt(fMessage + cursor, aValue->GetTimeStamp());
                         cursor += sizeof(UInt_t);
                 } */
-       } else {
-               AliError("Invalid or unknown SimpleValueType!");
-               return;
-       }       
+  } else {
+    AliError("Invalid or unknown ValueType!");
+    return;
+  }    
 
 }
 
@@ -680,98 +678,97 @@ void AliDCSMessage::LoadCountMessage()
 }
 
 //______________________________________________________________________
-void AliDCSMessage::LoadResultSetMessage() 
+void AliDCSMessage::LoadResultSetMessage()
 {
-// load result message
-
-       if (fMessageSize < VALUES_OFFSET) {
-               AliError("Body size is too small for result set message!");
-               return;
-       }       
-
-       fSimpleValueType = (AliSimpleValue::Type) GetUByte(
-                               fMessage + SVT_OFFSET);
-       UInt_t count = GetUInt(fMessage + VALUE_COUNT_OFFSET);
-
-       UInt_t cursor = VALUES_OFFSET;
-
-       if (fSimpleValueType == AliSimpleValue::kBool) {
-               if (VALUES_OFFSET + count + count * sizeof(UInt_t) > 
-                       fMessageSize) {
-                       AliError("Too many bool values for this buffer size!");
-                       return;
-               }       
-       
-               for (UInt_t k = 0; k < count; k ++) {
-                       Bool_t aBool = GetBool(fMessage + cursor);
-                       cursor += 1;
-                       UInt_t timeStamp = GetUInt(fMessage + cursor);
-                       cursor += sizeof(UInt_t);
-                       fValues.Add(new AliDCSValue(aBool, timeStamp));
-               }
-       } else if (fSimpleValueType == AliSimpleValue::kByte) {
-               if (VALUES_OFFSET + count + count * sizeof(UInt_t) > 
-                        fMessageSize) {
-                        AliError("Too many byte values for this buffer size!");
-                        return;
-                }       
-        
-                for (UInt_t k = 0; k < count; k ++) {
-                        Char_t aByte = GetByte(fMessage + cursor);
-                        cursor += sizeof(Char_t);
-                        UInt_t timeStamp = GetUInt(fMessage + cursor);
-                        cursor += sizeof(UInt_t);
-                        fValues.Add(new AliDCSValue(aByte, timeStamp));
-                }
-       } else if (fSimpleValueType == AliSimpleValue::kInt) {
-               if (VALUES_OFFSET + count * sizeof(Int_t) + 
-                       count * sizeof(UInt_t) > fMessageSize) {
-                        AliError("Too many int values for this buffer size!");
-                        return;
-                }
-
-                for (UInt_t k = 0; k < count; k ++) {
-                        Int_t aInt = GetInt(fMessage + cursor);
-                        cursor += sizeof(Int_t);
-                        UInt_t timeStamp = GetUInt(fMessage + cursor);
-                        cursor += sizeof(UInt_t);
-                        fValues.Add(new AliDCSValue(aInt, timeStamp));
-                }
-
-       } else if (fSimpleValueType == AliSimpleValue::kUInt) {
-               if (VALUES_OFFSET + count * sizeof(UInt_t) +  
-                        count * sizeof(UInt_t) > fMessageSize) {
-                        AliError("Too many uint values for this buffer size!");
-                        return;
-                }
-
-                for (UInt_t k = 0; k < count; k ++) {
-                        UInt_t aUInt = GetUInt(fMessage + cursor);
-                        cursor += sizeof(UInt_t);
-                        UInt_t timeStamp = GetUInt(fMessage + cursor);
-                        cursor += sizeof(UInt_t);
-                        fValues.Add(new AliDCSValue(aUInt, timeStamp));
-                }
-       } else if (fSimpleValueType == AliSimpleValue::kFloat) {
-               if (VALUES_OFFSET + count * sizeof(Float_t) +
-                        count * sizeof(UInt_t) > fMessageSize) {
-                        AliError("Too many float values for this buffer size!");
-                        return;
-                }
-
-                for (UInt_t k = 0; k < count; k ++) {
-                        Float_t aFloat = GetFloat(fMessage + cursor);
-                        cursor += sizeof(Float_t);
-                        UInt_t timeStamp = GetUInt(fMessage + cursor);
-                        cursor += sizeof(UInt_t);
-                        fValues.Add(new AliDCSValue(aFloat, timeStamp));
-                }
-
-       } else {
-               AliError("Unknown or invalid simple value type!");
-       }
-
-       fType = kResultSet;
+  // load result message
+
+  if (fMessageSize < VALUES_OFFSET) {
+    AliError("Body size is too small for result set message!");
+    return;
+  }
+
+  fValueType = (AliDCSValue::Type) GetUByte(fMessage + SVT_OFFSET);
+  UInt_t count = GetUInt(fMessage + VALUE_COUNT_OFFSET);
+
+  UInt_t cursor = VALUES_OFFSET;
+
+  if (fValueType == AliDCSValue::kBool) {
+    if (VALUES_OFFSET + count + count * sizeof(UInt_t) >
+      fMessageSize) {
+      AliError("Too many bool values for this buffer size!");
+      return;
+    }
+
+    for (UInt_t k = 0; k < count; k ++) {
+      Bool_t aBool = GetBool(fMessage + cursor);
+      cursor += 1;
+      UInt_t timeStamp = GetUInt(fMessage + cursor);
+      cursor += sizeof(UInt_t);
+      fValues.Add(new AliDCSValue(aBool, timeStamp));
+    }
+  } else if (fValueType == AliDCSValue::kChar) {
+    if (VALUES_OFFSET + count + count * sizeof(UInt_t) >
+      fMessageSize) {
+      AliError("Too many byte values for this buffer size!");
+      return;
+    }
+
+    for (UInt_t k = 0; k < count; k ++) {
+      Char_t aByte = GetByte(fMessage + cursor);
+      cursor += sizeof(Char_t);
+      UInt_t timeStamp = GetUInt(fMessage + cursor);
+      cursor += sizeof(UInt_t);
+      fValues.Add(new AliDCSValue(aByte, timeStamp));
+    }
+  } else if (fValueType == AliDCSValue::kInt) {
+    if (VALUES_OFFSET + count * sizeof(Int_t) +
+      count * sizeof(UInt_t) > fMessageSize) {
+            AliError("Too many int values for this buffer size!");
+            return;
+    }
+
+    for (UInt_t k = 0; k < count; k ++) {
+            Int_t aInt = GetInt(fMessage + cursor);
+            cursor += sizeof(Int_t);
+            UInt_t timeStamp = GetUInt(fMessage + cursor);
+            cursor += sizeof(UInt_t);
+            fValues.Add(new AliDCSValue(aInt, timeStamp));
+    }
+
+  } else if (fValueType == AliDCSValue::kUInt) {
+    if (VALUES_OFFSET + count * sizeof(UInt_t) +
+      count * sizeof(UInt_t) > fMessageSize) {
+      AliError("Too many uint values for this buffer size!");
+      return;
+    }
+
+    for (UInt_t k = 0; k < count; k ++) {
+      UInt_t aUInt = GetUInt(fMessage + cursor);
+      cursor += sizeof(UInt_t);
+      UInt_t timeStamp = GetUInt(fMessage + cursor);
+      cursor += sizeof(UInt_t);
+      fValues.Add(new AliDCSValue(aUInt, timeStamp));
+    }
+  } else if (fValueType == AliDCSValue::kFloat) {
+    if (VALUES_OFFSET + count * sizeof(Float_t) +
+      count * sizeof(UInt_t) > fMessageSize) {
+      AliError("Too many float values for this buffer size!");
+      return;
+    }
+
+    for (UInt_t k = 0; k < count; k ++) {
+      Float_t aFloat = GetFloat(fMessage + cursor);
+      cursor += sizeof(Float_t);
+      UInt_t timeStamp = GetUInt(fMessage + cursor);
+      cursor += sizeof(UInt_t);
+      fValues.Add(new AliDCSValue(aFloat, timeStamp));
+    }
+
+  } else {
+    AliError("Unknown or invalid value type!");
+  }
+
+  fType = kResultSet;
 }
 
 //______________________________________________________________________
@@ -1072,43 +1069,43 @@ UInt_t AliDCSMessage::GetCount() const
 }
 
 //______________________________________________________________________
-AliSimpleValue::Type AliDCSMessage::GetSimpleValueType() const 
+AliDCSValue::Type AliDCSMessage::GetValueType() const
 {
-        // ResultSet.
-        // Returns simple value type (see AliSimpleValue) for the values
-       // in this ResultSet.
+  // ResultSet.
+  // Returns simple value type (see AliDCSValue) for the values
+  // in this ResultSet.
 
-        if (fType != kResultSet) {
-                AliError("Invalid AliDCSMessage type!");
-                return AliSimpleValue::kInvalid;
-        }
+  if (fType != kResultSet) {
+          AliError("Invalid AliDCSMessage type!");
+          return AliDCSValue::kInvalid;
+  }
 
-       return fSimpleValueType;
+  return fValueType;
 }
 
 //______________________________________________________________________
 UInt_t AliDCSMessage::GetValueCount() const 
 {
-        // ResultSet.
-        // Returns the count of values in this ResultSet.
+  // ResultSet.
+  // Returns the count of values in this ResultSet.
 
 
-        if (fType != kResultSet) {
-                AliError("Invalid AliDCSMessage type!");
-                return 0;
-        }
+  if (fType != kResultSet) {
+          AliError("Invalid AliDCSMessage type!");
+          return 0;
+  }
 
-       return fValues.GetEntriesFast();
+  return fValues.GetEntriesFast();
 }
 
 //______________________________________________________________________
-UInt_t AliDCSMessage::GetValues(TObjArray& result) const 
+UInt_t AliDCSMessage::GetValues(TObjArray& result) const
 {
-        // ResultSet.
-        // Returns the number of values got from the message.
-       // result: used to return the values. Collection of AliDCSValue.
+  // ResultSet.
+  // Returns the number of values got from the message.
+  // result: used to return the values. Collection of AliDCSValue.
 
+  // TODO do not copy
 
        if (fType != kResultSet) {
                 AliError("Invalid AliDCSMessage type!");
@@ -1128,26 +1125,23 @@ UInt_t AliDCSMessage::GetValues(TObjArray& result) const
 //______________________________________________________________________
 Bool_t AliDCSMessage::AddValue(const AliDCSValue& value) 
 {
-       // ResultSet.
-        // Adds value to the ResultSet value list.
-       // Returns kFALSE in case of error.
-       // Otherwise returns kTRUE;
+  // Adds value to the ResultSet value list.
+  // Returns kFALSE in case of error.
+  // Otherwise returns kTRUE;
 
-       if (fType != kResultSet) {
-                AliError("Invalid AliDCSMessage type!");
-                return kFALSE;
-        }
-       
-       if (value.GetSimpleValue().GetType() != fSimpleValueType) {
-               AliError(Form("Can't add value with type %s to this message!",
-                       AliSimpleValue::GetTypeString(
-                               value.GetSimpleValue().GetType())));
-               return kFALSE;
-       }
+  if (fType != kResultSet) {
+    AliError("Invalid AliDCSMessage type!");
+    return kFALSE;
+  }
 
-       fValues.Add(new AliDCSValue(value));
+  if (value.GetType() != fValueType) {
+    AliError(Form("Can't add value with type %d to this message!", value.GetType()));
+    return kFALSE;
+  }
 
-       return kTRUE;
+  fValues.Add(new AliDCSValue(value));
+
+  return kTRUE;
 }
 
 //______________________________________________________________________
@@ -1244,8 +1238,7 @@ void AliDCSMessage::Print(Option_t* /*option*/) const
                case kResultSet: {
                        printString += "ResultSet\n";
                        printString += " SimpleValueType: ";
-                       printString += AliSimpleValue::GetTypeString(
-                               fSimpleValueType);
+                       printString += fValueType;
                        printString += '\n';
                        printString += " ValueCount: ";
                        printString += GetValueCount();
index 2dc7298..6830890 100644 (file)
@@ -15,7 +15,6 @@
 #include <TString.h>
 #include <TObjArray.h>
 #include "AliDCSValue.h"
-#include "AliSimpleValue.h"
 
 #define HEADER_SIZE 8
 #define ID_OFFSET 0
@@ -85,7 +84,7 @@ public:
 
         void CreateCountMessage(UInt_t count);
 
-        void CreateResultSetMessage(AliSimpleValue::Type type); 
+        void CreateResultSetMessage(AliDCSValue::Type type);
 
         void CreateErrorMessage(ErrorCode code, const char* errorString);
        
@@ -135,7 +134,7 @@ public:
         UInt_t GetCount() const;
 
         // ResultSetType Message getters ans setters       
-        AliSimpleValue::Type GetSimpleValueType() const;
+        AliDCSValue::Type GetValueType() const;
 
         UInt_t GetValueCount() const;
 
@@ -181,7 +180,7 @@ private:
        UInt_t fCount;                  // count counter
 
        //ResultSet message fields
-       AliSimpleValue::Type fSimpleValueType; // Simple value type
+       AliDCSValue::Type fValueType; // Simple value type
 
        TObjArray fValues;              // array of received values
        
index 3743e60..f2ebf09 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.4  2006/06/12 09:11:16  jgrosseo
+coding conventions (Alberto)
+
 Revision 1.3  2006/06/06 14:26:40  jgrosseo
 o) removed files that were moved to STEER
 o) shuttle updated to follow the new interface (Alberto)
@@ -97,8 +100,8 @@ AliShuttle::AliShuttle(const AliShuttleConfig* config,
        // retries: the number of retries in case of connection error.
        //
 
-       RegisterPreprocessor(new AliDefaultPreprocessor("DEFAULT", 0));
-
+       /*AliDefaultPreprocessor* pp = *///new AliDefaultPreprocessor("DEFAULT", this);
+  // TODO
 }
 
 //______________________________________________________________________
@@ -261,13 +264,18 @@ Bool_t AliShuttle::Process(Int_t run, UInt_t startTime, UInt_t endTime,
 
        AliPreprocessor* aPreprocessor =
                dynamic_cast<AliPreprocessor*> (fPreprocessorMap.GetValue(detector));
-       if(!aPreprocessor){
+       if(!aPreprocessor) {
                AliInfo(Form("No Preprocessor for %s: Using default Preprocessor!",detector));
                aPreprocessor = dynamic_cast<AliPreprocessor*> (fPreprocessorMap.GetValue("DEFAULT"));
        }
 
-       aPreprocessor->Initialize(run, startTime, endTime);
-       hasError = (Bool_t) !(aPreprocessor->Process(&aliasMap));
+  if (aPreprocessor)
+  {
+    aPreprocessor->Initialize(run, startTime, endTime);
+    hasError = (aPreprocessor->Process(&aliasMap) != 0);
+  }
+  else
+    AliWarning(Form("No preprocessor for %s available", detector));
 
   aliasMap.Delete();
 
index 9c406e7..28a644c 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
  $Log$
+ Revision 1.3  2006/06/12 09:11:16  jgrosseo
+ coding conventions (Alberto)
+
  Revision 1.2  2006/06/06 14:26:40  jgrosseo
  o) removed files that were moved to STEER
  o) shuttle updated to follow the new interface (Alberto)
@@ -52,7 +55,7 @@
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 
-#include "AliSimpleValue.h"
+#include "AliDCSValue.h"
 #include "AliShuttleConfig.h"
 #include "AliShuttle.h"
 #include "DATENotifier.h"
@@ -299,7 +302,7 @@ Bool_t AliShuttleTrigger::RetrieveDATEEntries(const char* whereClause,
 }
 
 //______________________________________________________________________________________________
-Bool_t AliShuttleTrigger::RetrieveConditionsData(const TObjArray& dateEntries) 
+Bool_t AliShuttleTrigger::RetrieveConditionsData(const TObjArray& dateEntries)
 {
 // Retrieve conditions data for all runs that aren't processed yet
 
@@ -363,6 +366,8 @@ Bool_t AliShuttleTrigger::CollectNew()
        // Collects conditions data for all new run written to DAQ LogBook.
        //
 
+  // TODO revise this! last run number is ONLY allowed to be written when run was processed successfully!!!
+
        AliInfo("Collecting conditions data for new runs ...");
 
        Int_t lastRun;
@@ -372,16 +377,16 @@ Bool_t AliShuttleTrigger::CollectNew()
        if (cdbEntry) {
                TObject* anObject = cdbEntry->GetObject();
                if (anObject == NULL ||
-                       anObject->IsA() != AliSimpleValue::Class()) {
+                       anObject->IsA() != AliDCSValue::Class()) {
                        AliError("Invalid last run object stored to CDB!");
                        return kFALSE;
                }
-               AliSimpleValue* simpleValue = (AliSimpleValue*) anObject;
+               AliDCSValue* simpleValue = (AliDCSValue*) anObject;
                lastRun = simpleValue->GetInt();
                delete cdbEntry;
        } else {
                AliWarning("There isn't last run stored! Starting from run 21200");
-               lastRun = 21200;
+               lastRun = 21200; // TODO maybe exit here
        }
 
        AliInfo(Form("Last run number <%d>", lastRun));
@@ -397,7 +402,7 @@ Bool_t AliShuttleTrigger::CollectNew()
        }
 
        if (newLastRun > lastRun) {
-               AliSimpleValue lastRunObj(newLastRun);
+               AliDCSValue lastRunObj(newLastRun, 0);
                AliCDBMetaData metaData;
                AliCDBId cdbID(AliCDBPath("SHUTTLE", "SYSTEM", "LASTRUN"), 0, 0);
 
index 4ba74a2..b48d31f 100644 (file)
@@ -83,7 +83,7 @@ void AliTestDataDCS::ProcessData(TMap& aliasMap){
                UInt_t ne=0;
                while ((aValue = (AliDCSValue*) iterarray.Next())) {
 
-               val[ne] = aValue->GetSimpleValue().GetFloat();
+               val[ne] = aValue->GetFloat();
                time[ne] = (Double_t) (aValue->GetTimeStamp());
                // fill histos (alias 0-2)
                if(j < 3) fHv[j]->Fill(val[ne]);
index 125b4a2..3acc199 100644 (file)
Binary files a/SHUTTLE/TestShuttle/TestCDB/DET/DCS/Data/Run0_0_v0_s0.root and b/SHUTTLE/TestShuttle/TestCDB/DET/DCS/Data/Run0_0_v0_s0.root differ
index adba4ba..d1213ce 100644 (file)
@@ -111,8 +111,7 @@ TMap* CreateDCSAliasMap()
 
     for (int timeStamp=0;timeStamp<1000;timeStamp+=10)
     {
-      AliSimpleValue* simVal = new AliSimpleValue((Float_t) (random.Gaus()+5*nAlias));
-      AliDCSValue* dcsVal = new AliDCSValue(*simVal, timeStamp);
+      AliDCSValue* dcsVal = new AliDCSValue((Float_t) (random.Gaus()+5*nAlias), timeStamp);
       //printf("%s\n",dcsVal->ToString().Data());
       valueSet->Add(dcsVal);
     }
index 89d12d2..5727900 100644 (file)
@@ -113,7 +113,7 @@ void AliTPCDataDCS::ProcessData(TMap& aliasMap)
 
                UInt_t ne=0;
                while ((aValue = (AliDCSValue*) iterarray.Next())) {
-               val[ne] = aValue->GetSimpleValue().GetFloat();
+               val[ne] = aValue->GetFloat();
                time[ne] = (Double_t) (aValue->GetTimeStamp());
                // fill histos (alias 0-2)
                if(j < 3) fHv[j]->Fill(val[ne]);
index 3e76a14..ba2702d 100644 (file)
@@ -202,7 +202,7 @@ void TestServer::Run(Int_t count, Int_t rsSize) {
 
                        TTimeStamp currentTime;
                        AliDCSMessage rsMessage;
-                       rsMessage.CreateResultSetMessage(AliSimpleValue::kInt);
+                       rsMessage.CreateResultSetMessage(AliDCSValue::kInt);
                                
                        for (Int_t k = 0; k < pSize; k ++) {
                                AliDCSValue aValue(k, currentTime.GetSec() + k);
index 8590ff3..225d722 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)
 
@@ -33,10 +36,11 @@ some more descriptions added
 */
 
 //
-// This class represents the main value structure
-// which forms so called 'historical data' in any SCADA system.
-// When a value (which represent a parameter of some real world object)
-// is measured in the time, a value serie (called value set) is formed.
+// This class represents the value(s) of
+// a DCS data point at a given timestamp.
+// It stores different data types, the current implementation has a member for all of them.
+// This is definitly not efficient, but the only way to use the automatic streamers generated by ROOT.
+//
 // Each element of this value series has two fields:
 // fValue - primitive value which represents the real measured value
 // fTimestamp - timestamp when the measurement was made
@@ -45,24 +49,334 @@ some more descriptions added
 #include "AliDCSValue.h"
 
 #include "TTimeStamp.h"
+#include <TString.h>
 
 ClassImp(AliDCSValue)
 
-AliDCSValue::AliDCSValue() {
+AliDCSValue::AliDCSValue() : TObject()
+{
+  // default constructor
+
+  Init();
+}
+
+AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kBool;
+  fBool = value;
+}
+
+AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kChar;
+  fChar = value;
+}
+
+AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kInt;
+  fInt = value;
+}
+
+AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kUInt;
+  fUInt = value;
+}
+
+AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kFloat;
+  fFloat = value;
+}
+
+AliDCSValue::AliDCSValue(Int_t size, Bool_t* vals, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kDynBool;
+  fBoolPtr = vals;
+  fLength = size;
+}
+
+AliDCSValue::AliDCSValue(Int_t size, Char_t* vals, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kDynChar;
+  fCharPtr = vals;
+  fLength = size;
+}
+
+AliDCSValue::AliDCSValue(Int_t size, Int_t* vals, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kDynInt;
+  fIntPtr = vals;
+  fLength = size;
+}
+
+AliDCSValue::AliDCSValue(Int_t size, UInt_t* vals, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kDynUInt;
+  fUIntPtr = vals;
+  fLength = size;
+}
+
+AliDCSValue::AliDCSValue(Int_t size, Float_t* vals, UInt_t timeStamp) : TObject()
+{
+  // constructor
+
+  Init();
+
+  fTimeStamp = timeStamp;
+
+  fType = kDynFloat;
+  fFloatPtr = vals;
+  fLength = size;
+}
+
+AliDCSValue::AliDCSValue(const AliDCSValue& c) : TObject(c)
+{
+  // copy constructor
+
+  ((AliDCSValue &)c).Copy(*this);
+}
+
+void AliDCSValue::Init()
+{
+  // init helper, that initializes everything to 0
+
+  fType = kInvalid;
+
+  fBool = kFALSE;
+  fChar = 0;
+  fInt = 0;
+  fUInt = 0;
+  fFloat = 0;
+
+  fLength = 0;
+
+  fBoolPtr = 0;
+  fCharPtr = 0;
+  fIntPtr = 0;
+  fUIntPtr = 0;
+  fFloatPtr = 0;
+
+  fTimeStamp = 0;
+}
+
+AliDCSValue::~AliDCSValue()
+{
+  // destructor
+
+  if (fBoolPtr)
+  {
+    delete[] fBoolPtr;
+    fBoolPtr = 0;
+  }
+
+  if (fCharPtr)
+  {
+    delete[] fCharPtr;
+    fCharPtr = 0;
+  }
 
+  if (fIntPtr)
+  {
+    delete[] fIntPtr;
+    fIntPtr = 0;
+  }
+
+  if (fUIntPtr)
+  {
+    delete[] fUIntPtr;
+    fUIntPtr = 0;
+  }
+
+  if (fFloatPtr)
+  {
+    delete[] fFloatPtr;
+    fFloatPtr = 0;
+  }
 }
 
-AliDCSValue::AliDCSValue(const AliSimpleValue& value, UInt_t timeStamp):
-       fValue(value), fTimeStamp(timeStamp)
+AliDCSValue &AliDCSValue::operator=(const AliDCSValue &c)
 {
+  // assigment operator
 
+  if (this != &c) 
+    ((AliDCSValue &) c).Copy(*this);
+
+  return *this;
 }
 
+void AliDCSValue::Copy(TObject& c) const
+{
+  // copy function
+
+  AliDCSValue& target = (AliDCSValue &) c;
+
+  target.Init();
+
+  target.fType = fType;
 
-TString AliDCSValue::ToString() const {
+  target.fBool = fBool;
+  target.fChar = fChar;
+  target.fInt = fInt;
+  target.fUInt = fUInt;
+  target.fFloat = fFloat;
 
-       return fValue.ToString() + ", Timestmap: " +
-                TTimeStamp(fTimeStamp).AsString();
+  target.fLength = fLength;
+
+  if (fLength > 0)
+  {
+    if (fBoolPtr)
+    {
+      target.fBoolPtr = new Bool_t[fLength];
+      for (UInt_t i=0; i<fLength; ++i)
+        target.fBoolPtr[i] = fBoolPtr[i];
+    }
+    if (fCharPtr)
+    {
+      target.fCharPtr = new Char_t[fLength];
+      for (UInt_t i=0; i<fLength; ++i)
+        target.fCharPtr[i] = fCharPtr[i];
+    }
+    if (fIntPtr)
+    {
+      target.fIntPtr = new Int_t[fLength];
+      for (UInt_t i=0; i<fLength; ++i)
+        target.fIntPtr[i] = fIntPtr[i];
+    }
+    if (fUIntPtr)
+    {
+      target.fUIntPtr = new UInt_t[fLength];
+      for (UInt_t i=0; i<fLength; ++i)
+        target.fUIntPtr[i] = fUIntPtr[i];
+    }
+    if (fFloatPtr)
+    {
+      target.fFloatPtr = new Float_t[fLength];
+      for (UInt_t i=0; i<fLength; ++i)
+        target.fFloatPtr[i] = fFloatPtr[i];
+    }
+  }
+
+  target.fTimeStamp = fTimeStamp;
 }
 
+Int_t AliDCSValue::GetSize() const
+{
+  // returns size in bytes of stored structure
+
+  Int_t size = sizeof(fTimeStamp);
+
+  switch (fType)
+  {
+    case kBool:  size += sizeof(Bool_t);  break;
+    case kChar:  size += sizeof(Char_t);  break;
+    case kInt:   size += sizeof(Int_t);   break;
+    case kUInt:  size += sizeof(UInt_t);  break;
+    case kFloat: size += sizeof(Float_t); break;
+
+    case kDynBool:  size += fLength * sizeof(Bool_t);   break;
+    case kDynChar:  size += fLength * sizeof(Char_t);   break;
+    case kDynInt:   size += fLength * sizeof(Int_t);    break;
+    case kDynUInt:  size += fLength * sizeof(UInt_t);   break;
+    case kDynFloat: size += fLength * sizeof(Float_t);  break;
+
+    case kInvalid: break;
+  }
 
+  return size;
+}
+
+Bool_t AliDCSValue::IsDynamic(Type type)
+{
+  // return if the given type is dynamic
+
+  switch (type)
+  {
+    case kDynBool:
+    case kDynChar:
+    case kDynInt:
+    case kDynUInt:
+    case kDynFloat: return kTRUE; break;
+
+    default: return kFALSE; break;
+  }
+}
+
+const Char_t* AliDCSValue::ToString() const
+{
+  TString str;
+
+  switch (fType)
+  {
+    case kBool:  str.Form("%d", fBool);  break;
+    case kChar:  str.Form("%d", fChar);  break;
+    case kInt:   str.Form("%d", fInt);  break;
+    case kUInt:  str.Form("%d", fUInt);  break;
+    case kFloat: str.Form("%f", fFloat);  break;
+
+    case kDynBool:  for (UInt_t i=0; i<fLength; ++i) str += Form("%d ", fBoolPtr[i]); break;
+    case kDynChar:  for (UInt_t i=0; i<fLength; ++i) str += Form("%d ", fCharPtr[i]); break;
+    case kDynInt:   for (UInt_t i=0; i<fLength; ++i) str += Form("%d ", fIntPtr[i]); break;
+    case kDynUInt:  for (UInt_t i=0; i<fLength; ++i) str += Form("%d ", fUIntPtr[i]); break;
+    case kDynFloat: for (UInt_t i=0; i<fLength; ++i) str += Form("%f ", fFloatPtr[i]); break;
+
+    case kInvalid: break;
+  }
+
+  return Form("%s Timestamp: %s", str.Data(), TTimeStamp(fTimeStamp).AsString());
+}
index 016647d..7df7b3d 100644 (file)
@@ -7,37 +7,94 @@
 /* $Id$ */
 
 //
-// This class represents the main value structure
-// which forms so called 'historical data' in any SCADA system.
+// This class represents the value(s) of a DCS data point at a given timestamp
 //
 
-#include "AliSimpleValue.h"
+#include <TObject.h>
 
-class AliDCSValue: public TObject {
+class AliDCSValue : public TObject {
 public:
+  enum Type {
+    kInvalid = 0,
 
-       AliDCSValue();
-       AliDCSValue(const AliSimpleValue& value, UInt_t timeStamp);
+    kBool = 1,
+    kChar = 2,
+    kInt = 3,
+    kUInt = 4,
+    kFloat = 5,
 
-       AliSimpleValue& GetSimpleValue() {return fValue;};
-       const AliSimpleValue& GetSimpleValue() const {return fValue;};  
-       void SetSimpleValue(const AliSimpleValue& value) {fValue = value;};
+    kDynBool = 11,
+    kDynChar = 12,
+    kDynInt = 13,
+    kDynUInt = 14,
+    kDynFloat = 15
+  };
 
-       UInt_t GetTimeStamp() const {return fTimeStamp;};
-       void SetTimeStamp(UInt_t timeStamp) {fTimeStamp = timeStamp;};
+  AliDCSValue();
+  AliDCSValue(const AliDCSValue& c);
 
-       Int_t GetSize() const {return fValue.GetSize() + sizeof(UInt_t);};
+  ~AliDCSValue();
 
-       TString ToString() const;
+  AliDCSValue& operator=(const AliDCSValue& c);
+  virtual void Copy(TObject& c) const;
 
-private:
+  AliDCSValue(Bool_t value, UInt_t timeStamp);
+  AliDCSValue(Char_t value, UInt_t timeStamp);
+  AliDCSValue(Int_t value, UInt_t timeStamp);
+  AliDCSValue(UInt_t value, UInt_t timeStamp);
+  AliDCSValue(Float_t value, UInt_t timeStamp);
 
-        AliSimpleValue fValue;
+  AliDCSValue(Int_t size, Bool_t* vals, UInt_t timeStamp);
+  AliDCSValue(Int_t size, Char_t* vals, UInt_t timeStamp);
+  AliDCSValue(Int_t size, Int_t* vals, UInt_t timeStamp);
+  AliDCSValue(Int_t size, UInt_t* vals, UInt_t timeStamp);
+  AliDCSValue(Int_t size, Float_t* vals, UInt_t timeStamp);
 
-        UInt_t fTimeStamp;
+  Bool_t GetBool() const { return fBool; }
+  Char_t GetChar() const { return fChar; }
+  Int_t GetInt() const { return fInt; }
+  UInt_t GetUInt() const { return fUInt; }
+  Float_t GetFloat() const { return fFloat; }
 
+  Bool_t GetDynBool(Int_t n) const { return fBoolPtr[n]; }
+  Char_t GetDynChar(Int_t n) const { return fCharPtr[n]; }
+  Int_t GetDynInt(Int_t n) const { return fIntPtr[n]; }
+  UInt_t GetDynUInt(Int_t n) const { return fUIntPtr[n]; }
+  Float_t GetDynFloat(Int_t n) const { return fFloatPtr[n]; }
 
-       ClassDef(AliDCSValue, 1);
+  Type GetType() const { return fType; }
+  Int_t GetDynamicSize() const { return fLength; }
+
+  UInt_t GetTimeStamp() const { return fTimeStamp; }
+  void SetTimeStamp(UInt_t timeStamp) { fTimeStamp = timeStamp; }
+
+  Int_t GetSize() const;
+  static Bool_t IsDynamic(Type type);
+
+  const Char_t* ToString() const;
+
+protected:
+  void Init();
+
+  Type fType;           // type of the value stored
+
+  Bool_t fBool;         // bool value
+  Char_t fChar;         // char value
+  Int_t fInt;           // int value
+  UInt_t fUInt;         // uint value
+  Float_t fFloat;       // float value
+
+  UInt_t fLength;       // length of the following arrays, the ones that are != 0 are expected to contain fLength entries
+
+  Bool_t* fBoolPtr;     //[fLength] bool array
+  Char_t* fCharPtr;     //[fLength] char array
+  Int_t* fIntPtr;       //[fLength] int array
+  UInt_t* fUIntPtr;     //[fLength] uint array
+  Float_t* fFloatPtr;   //[fLength] float array
+
+  UInt_t fTimeStamp;    // timestamp of this value
+
+       ClassDef(AliDCSValue, 2);
 };
 
 #endif
diff --git a/STEER/AliSimpleValue.cxx b/STEER/AliSimpleValue.cxx
deleted file mode 100644 (file)
index d032067..0000000
+++ /dev/null
@@ -1,1940 +0,0 @@
-/**************************************************************************
-
- * 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  2006/06/13 11:19:48  hristov
-
-Coding conventions (Alberto)
-
-
-
-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)
-
-
-
-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.
-
-// Usage examples: AliSimpleValue sim(20) -> Int type
-
-// simfl.SetFloat(3.5) -> Float type
-
-// Char_t chararr[4] = {'c','i','a','o'};
-
-// AliSimpleValue simchar(4,chararr); -> DynChar type
-
-//
-
-
-
-
-
-#include "AliSimpleValue.h"
-
-
-
-#include "AliLog.h"
-
-#include <TClass.h>
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliBoolHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-
-
-       return new AliBoolHolder(fValue);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliBoolHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-       
-
-       if (this == obj) {
-
-               return kTRUE;
-
-       }
-
-
-
-       if (AliBoolHolder::Class() != obj->IsA()) {
-
-               return kFALSE;
-
-       }
-
-
-
-       return fValue == ((const AliBoolHolder*) obj)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliByteHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-
-
-        return new AliByteHolder(fValue);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliByteHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliByteHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return fValue == ((const AliByteHolder*) obj)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliIntHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-       return new AliIntHolder(fValue);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliIntHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliIntHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return fValue == ((const AliIntHolder*) obj)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliUIntHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-        return new AliUIntHolder(fValue);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliUIntHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliUIntHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return fValue == ((const AliUIntHolder*) obj)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliFloatHolder::Clone(const char* /*name*/) const {
-
- // Clone a value
-
-       return new AliFloatHolder(fValue);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliFloatHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliFloatHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return fValue == ((const AliFloatHolder*) obj)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliDynBoolHolder::Clone(const char* /*name*/) const {
-
- // Clone a value
-
-       return new AliDynBoolHolder(fSize, fValues);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliDynBoolHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliDynBoolHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-       const AliDynBoolHolder* other = ((const AliDynBoolHolder*) obj);
-
-       
-
-       if (fSize != other->GetSize()) {
-
-               return kFALSE;
-
-       }
-
-
-
-        return !memcmp(fValues, other->GetValues(), fSize * sizeof(Bool_t));
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliDynByteHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-        return new AliDynByteHolder(fSize, fValues);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliDynByteHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliDynByteHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        const AliDynByteHolder* other = ((const AliDynByteHolder*) obj);
-
-
-
-        if (fSize != other->GetSize()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return !memcmp(fValues, other->GetValues(), fSize * sizeof(Char_t));
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliDynIntHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-        return new AliDynIntHolder(fSize, fValues);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliDynIntHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-       if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliDynIntHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        const AliDynIntHolder* other = ((const AliDynIntHolder*) obj);
-
-
-
-        if (fSize != other->GetSize()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return !memcmp(fValues, other->GetValues(), fSize * sizeof(Int_t));
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliDynUIntHolder::Clone(const char* /*name*/) const {
-
-// Clone a value
-
-        return new AliDynUIntHolder(fSize, fValues);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliDynUIntHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliDynUIntHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        const AliDynUIntHolder* other = ((const AliDynUIntHolder*) obj);
-
-
-
-        if (fSize != other->GetSize()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return !memcmp(fValues, other->GetValues(), fSize * sizeof(UInt_t));
-
-}
-
-
-
-//______________________________________________________________________
-
-TObject* AliSimpleValue::AliDynFloatHolder::Clone(const char* /*name*/) const {
-
-        return new AliDynFloatHolder(fSize, fValues);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::AliDynFloatHolder::IsEqual(const TObject* obj) const {
-
-// check whether this is equal to obj
-
-
-
-        if (this == obj) {
-
-                return kTRUE;
-
-        }
-
-
-
-        if (AliDynFloatHolder::Class() != obj->IsA()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        const AliDynFloatHolder* other = ((const AliDynFloatHolder*) obj);
-
-
-
-        if (fSize != other->GetSize()) {
-
-                return kFALSE;
-
-        }
-
-
-
-        return !memcmp(fValues, other->GetValues(), 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 AliBoolHolder();
-
-                       break;
-
-               case kByte:
-
-                       fHolder = new AliByteHolder();
-
-                       break;
-
-               case kInt:
-
-                       fHolder = new AliIntHolder();
-
-                       break;
-
-               case kUInt:
-
-                       fHolder = new AliUIntHolder();
-
-                       break;
-
-               case kFloat:
-
-                       fHolder = new AliFloatHolder();
-
-                       break;
-
-               case kDynBool:
-
-                       fHolder = new AliDynBoolHolder(size);
-
-                       break;
-
-               case kDynByte:
-
-                       fHolder = new AliDynByteHolder(size);
-
-                       break;
-
-               case kDynInt:
-
-                       fHolder = new AliDynIntHolder(size);
-
-                       break;
-
-               case kDynUInt:
-
-                       fHolder = new AliDynUIntHolder(size);
-
-                       break;
-
-               case kDynFloat:
-
-                       fHolder = new AliDynFloatHolder(size);
-
-                       break;
-
-               default:        
-
-                       break;
-
-       }
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Bool_t val) {
-
-// contructor
-
-
-
-       fType = kBool;
-
-       fHolder = new AliBoolHolder(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Char_t val) {
-
-// contructor
-
-       
-
-       fType = kByte;
-
-       fHolder = new AliByteHolder(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t val) {
-
-// contructor
-
-       
-
-       fType = kInt;
-
-       fHolder = new AliIntHolder(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(UInt_t val) {
-
-// contructor
-
-       
-
-       fType = kUInt;
-
-       fHolder = new AliUIntHolder(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Float_t val) {
-
-// contructor
-
-
-
-       fType = kFloat;
-
-       fHolder = new AliFloatHolder(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Bool_t* buf) {
-
-// contructor
-
-       
-
-       fType = kDynBool;
-
-       fHolder = new AliDynBoolHolder(size, buf);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Char_t* buf) {
-
-// contructor
-
-
-
-        fType = kDynByte;
-
-        fHolder = new AliDynByteHolder(size, buf);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Int_t* buf) {
-
-// contructor
-
-
-
-        fType = kDynInt;
-
-        fHolder = new AliDynIntHolder(size, buf);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t size, const UInt_t* buf) {
-
-// contructor
-
-
-
-        fType = kDynUInt;
-
-        fHolder = new AliDynUIntHolder(size, buf);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::AliSimpleValue(Int_t size, const Float_t* buf) {
-
-// contructor
-
-
-
-        fType = kDynFloat;
-
-        fHolder = new AliDynFloatHolder(size, buf);
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue::~AliSimpleValue() {
-
-// destructor
-
-       
-
-       if (fHolder) {
-
-               delete fHolder;
-
-       }
-
-}
-
-
-
-//______________________________________________________________________
-
-AliSimpleValue& AliSimpleValue::operator=(const AliSimpleValue& other) {
-
-// assignment op
-
-
-
-       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 {
-
-// equality op
-
-
-
-       if (fType != other.fType) {
-
-               return kFALSE;
-
-       }
-
-
-
-       if (!(fHolder && other.fHolder)) {
-
-               return kFALSE;
-
-       }
-
-
-
-       return fHolder->IsEqual(other.fHolder);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetBool(Bool_t val) {
-
-// set value
-
-
-
-       if (!TypeOk(kBool)) {
-
-               return;
-
-       }
-
-
-
-       ((AliBoolHolder*) fHolder)->SetValue(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetByte(Char_t val) {
-
-// set value
-
-
-
-       if (!TypeOk(kByte)) {
-
-               return;
-
-       }
-
-
-
-       ((AliByteHolder*) fHolder)->SetValue(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetInt(Int_t val) {
-
-// set value
-
-
-
-       if (!TypeOk(kInt)) {
-
-               return;
-
-       }
-
-
-
-       ((AliIntHolder*) fHolder)->SetValue(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetUInt(UInt_t val) {
-
-// set value
-
-
-
-       if (!TypeOk(kUInt)) {
-
-               return;
-
-       }
-
-       
-
-       ((AliUIntHolder*) fHolder)->SetValue(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetFloat(Float_t val) {
-
-// set value
-
-
-
-       if (!TypeOk(kFloat)) {
-
-               return;
-
-       }
-
-
-
-       ((AliFloatHolder*) fHolder)->SetValue(val);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::GetBool() const {
-
-// get value
-
-
-
-       if (!TypeOk(kBool)) {
-
-               return kFALSE;
-
-       }       
-
-
-
-       return ((AliBoolHolder*) fHolder)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-Char_t AliSimpleValue::GetByte() const {
-
-// get value
-
-
-
-       if (!TypeOk(kByte)) {
-
-               return 0;
-
-       }
-
-       
-
-        return ((AliByteHolder*) fHolder)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-Int_t AliSimpleValue::GetInt() const {
-
-// get value
-
-
-
-       if (!TypeOk(kInt)) {
-
-               return 0;
-
-       }
-
-        return ((AliIntHolder*) fHolder)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-UInt_t AliSimpleValue::GetUInt() const {
-
-// get value
-
-
-
-       if (!TypeOk(kUInt)) {
-
-               return 0;
-
-        }
-
-
-
-        return ((AliUIntHolder*) fHolder)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-Float_t AliSimpleValue::GetFloat() const {
-
-// get value
-
-
-
-       if (!TypeOk(kFloat)) {
-
-               return 0;
-
-       }
-
-
-
-        return ((AliFloatHolder*) fHolder)->GetValue();
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetDynBool(Int_t n, Bool_t val) {
-
-// set dyn value
-
-       
-
-       if (!TypeOk(kDynBool)) {
-
-               return;
-
-       }
-
-
-
-       if (!BoundsOk(n)) {
-
-               return;
-
-       }
-
-
-
-       ((AliDynBoolHolder*) fHolder)->SetValue(n,val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetDynByte(Int_t n, Char_t val) {
-
-// set dyn value
-
-
-
-       if (!TypeOk(kDynByte)) {
-
-                return;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return;
-
-        }
-
-
-
-        ((AliDynByteHolder*) fHolder)->SetValue(n,val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetDynInt(Int_t n, Int_t val) {
-
-// set dyn value
-
-
-
-        if (!TypeOk(kDynInt)) {
-
-                return;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return;
-
-        }
-
-
-
-        ((AliDynIntHolder*) fHolder)->SetValue(n,val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetDynUInt(Int_t n, UInt_t val) {
-
-// set dyn value
-
-
-
-        if (!TypeOk(kDynUInt)) {
-
-                return;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return;
-
-        }
-
-
-
-        ((AliDynUIntHolder*) fHolder)->SetValue(n,val);
-
-}
-
-
-
-//______________________________________________________________________
-
-void AliSimpleValue::SetDynFloat(Int_t n, Float_t val) {
-
-// set dyn value
-
-
-
-        if (!TypeOk(kDynFloat)) {
-
-                return;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return;
-
-        }
-
-
-
-        ((AliDynFloatHolder*) fHolder)->SetValue(n,val);
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::GetDynBool(Int_t n) const {
-
-// get dyn value
-
-
-
-       if (!TypeOk(kDynBool)) {
-
-                return kFALSE;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return kFALSE;
-
-        }
-
-
-
-       return ((AliDynBoolHolder*) fHolder)->GetValue(n);
-
-}
-
-
-
-//______________________________________________________________________
-
-Char_t AliSimpleValue::GetDynByte(Int_t n) const {
-
-// get dyn value
-
-
-
-        if (!TypeOk(kDynByte)) {
-
-                return 0;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return 0;
-
-        }
-
-
-
-        return ((AliDynByteHolder*) fHolder)->GetValue(n);
-
-}
-
-
-
-//______________________________________________________________________
-
-Int_t AliSimpleValue::GetDynInt(Int_t n) const {
-
-// get dyn value
-
-
-
-        if (!TypeOk(kDynInt)) {
-
-                return 0;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return 0;
-
-        }
-
-
-
-        return ((AliDynIntHolder*) fHolder)->GetValue(n);
-
-}
-
-
-
-//______________________________________________________________________
-
-UInt_t AliSimpleValue::GetDynUInt(Int_t n) const {
-
-// get dyn value
-
-
-
-        if (!TypeOk(kDynUInt)) {
-
-                return 0;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return 0;
-
-        }
-
-
-
-        return ((AliDynUIntHolder*) fHolder)->GetValue(n);
-
-}
-
-
-
-//______________________________________________________________________
-
-Float_t AliSimpleValue::GetDynFloat(Int_t n) const {
-
-// get dyn value
-
-
-
-        if (!TypeOk(kDynFloat)) {
-
-                return 0;
-
-        }
-
-
-
-        if (!BoundsOk(n)) {
-
-                return 0;
-
-        }
-
-
-
-        return ((AliDynFloatHolder*) fHolder)->GetValue(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!", 
-
-                       GetTypeString(type)));
-
-               return kFALSE;
-
-       }
-
-
-
-       return kTRUE;
-
-}
-
-
-
-//______________________________________________________________________
-
-Bool_t AliSimpleValue::BoundsOk(Int_t n) const {
-
-// Check that n is within bounds of dyn value
-
-
-
-       switch (fType) {
-
-               case kDynBool:
-
-               case kDynByte:
-
-               case kDynInt:
-
-               case kDynUInt:
-
-               case kDynFloat: {
-
-                       Int_t size = ((AliDynHolder*) fHolder)->GetSize();
-
-                       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(AliDynHolder::Class())) {
-
-               return 0;
-
-       }
-
-
-
-       return ((AliDynHolder*) fHolder)->GetSize();
-
-}
-
-
-
-//______________________________________________________________________
-
-TString AliSimpleValue::ToString() const {
-
-// Print value
-
-       
-
-       TString result;
-
-       
-
-       result += "Type: ";
-
-       result += GetTypeString(fType);
-
-       
-
-       result += ", Value: ";
-
-       switch (fType) {
-
-               case kBool:
-
-                       result += GetBool();
-
-                       break;
-
-               case kByte:
-
-                       result += 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) {
-
-// check that type is dynamic
-
-
-
-        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) {
-
-// return type name correspondyng to 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";
-
-       }
-
-}
-
diff --git a/STEER/AliSimpleValue.h b/STEER/AliSimpleValue.h
deleted file mode 100644 (file)
index a52bf1a..0000000
+++ /dev/null
@@ -1,852 +0,0 @@
-#ifndef ALI_SIMPLE_VALUE_H
-
-#define ALI_SIMPLE_VALUE_H
-
-
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-
- * See cxx source for full Copyright notice                               */
-
-
-
-/* $Id$ */
-
-
-
-//
-
-// 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>
-
-#include <TString.h>
-
-
-
-class AliSimpleValue: public TObject {
-
-public:
-
-       enum Type {
-
-               kInvalid = 0,
-
-               kBool = 1,
-
-               kByte = 2,
-
-               kInt = 3,
-
-               kUInt = 4,
-
-               kFloat = 5,
-
-               kDynBool = 11,
-
-               kDynByte = 12,
-
-               kDynInt = 13,
-
-               kDynUInt = 14,
-
-               kDynFloat = 15
-
-       };      
-
-
-
-
-
-       AliSimpleValue();
-
-
-
-        AliSimpleValue(const AliSimpleValue& other);
-
-
-
-        AliSimpleValue(Type type, Int_t size = 0);
-
-
-
-        AliSimpleValue(Bool_t val);
-
-
-
-        AliSimpleValue(Char_t val);
-
-
-
-        AliSimpleValue(Int_t val);
-
-
-
-        AliSimpleValue(UInt_t val);
-
-
-
-        AliSimpleValue(Float_t val);
-
-
-
-        AliSimpleValue(Int_t size, const Bool_t* vals);
-
-
-
-        AliSimpleValue(Int_t size, const Char_t* vals);
-
-
-
-        AliSimpleValue(Int_t size, const Int_t* vals);
-
-
-
-        AliSimpleValue(Int_t size, const UInt_t* vals);
-
-
-
-        AliSimpleValue(Int_t size, const Float_t* vals);
-
-
-
-        ~AliSimpleValue();
-
-
-
-
-
-        AliSimpleValue& operator=(const AliSimpleValue& other);
-
-
-
-        Bool_t operator==(const AliSimpleValue& other) const;
-
-
-
-        void SetBool(Bool_t val);
-
-
-
-        void SetByte(Char_t val);
-
-
-
-        void SetInt(Int_t val);
-
-
-
-        void SetUInt(UInt_t val);
-
-
-
-        void SetFloat(Float_t val);
-
-
-
-
-
-        Bool_t GetBool() const;
-
-
-
-        Char_t GetByte() const;
-
-
-
-        Int_t GetInt() const;
-
-
-
-        UInt_t GetUInt() const;
-
-
-
-        Float_t GetFloat() const;
-
-
-
-
-
-       void SetDynBool(Int_t n, Bool_t val);
-
-
-
-        void SetDynByte(Int_t n, Char_t val);
-
-
-
-        void SetDynInt(Int_t n, Int_t val);
-
-
-
-        void SetDynUInt(Int_t n, UInt_t val);
-
-
-
-        void SetDynFloat(Int_t n, Float_t val);
-
-
-
-
-
-        Bool_t GetDynBool(Int_t n) const;
-
-
-
-        Char_t GetDynByte(Int_t n) const;
-
-
-
-        Int_t GetDynInt(Int_t n) const;
-
-
-
-        UInt_t GetDynUInt(Int_t n) const;
-
-
-
-        Float_t GetDynFloat(Int_t n) const;
-
-
-
-
-
-        Type GetType() const {return fType;};
-
-
-
-        Int_t GetSize() const;
-
-
-
-        Int_t GetDynamicSize() const;
-
-
-
-        TString ToString() const;
-
-
-
-
-
-        static Bool_t IsDynamic(Type type);
-
-
-
-        static Int_t GetPrimitiveSize(Type type);
-
-
-
-        static const char* GetTypeString(Type type);
-
-
-
-private:
-
-
-
-       class AliBoolHolder: public TObject {
-
-       
-
-       public:
-
-               AliBoolHolder() {}
-
-               virtual ~AliBoolHolder() {}
-
-
-
-               AliBoolHolder(Bool_t val):fValue(val) {}
-
-               
-
-               Bool_t GetValue() const {return fValue;}
-
-               void SetValue(const Bool_t val) {fValue = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const; 
-
-       
-
-               virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-       private:
-
-               Bool_t fValue;          // The value
-
-
-
-               ClassDef(AliBoolHolder, 1);
-
-       };
-
-
-
-       class AliByteHolder: public TObject {
-
-       
-
-       public:
-
-
-
-               AliByteHolder() {};
-
-               virtual ~AliByteHolder() {}
-
-
-
-               AliByteHolder(Char_t val):fValue(val) {}
-
-               
-
-               Char_t GetValue() const {return fValue;}
-
-               void SetValue(const Char_t val) {fValue = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-               virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-       private:
-
-               Char_t fValue;          // The value
-
-
-
-               ClassDef(AliByteHolder, 1);
-
-       };
-
-
-
-       class AliIntHolder: public TObject {
-
-       
-
-       public:
-
-
-
-               AliIntHolder() {}
-
-               virtual ~AliIntHolder() {}
-
-
-
-               AliIntHolder(Int_t val):fValue(val) {}
-
-               
-
-               Int_t GetValue() const {return fValue;}
-
-               void SetValue(const Int_t val) {fValue = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const; 
-
-
-
-               virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               Int_t fValue;           // The value
-
-
-
-               ClassDef(AliIntHolder, 1);
-
-       };
-
-
-
-       class AliUIntHolder: public TObject {
-
-       
-
-       public:
-
-
-
-               AliUIntHolder() {}
-
-               virtual ~AliUIntHolder() {}
-
-
-
-               AliUIntHolder(UInt_t val):fValue(val) {}
-
-               
-
-               UInt_t GetValue() const {return fValue;}
-
-               void SetValue(const UInt_t val) {fValue = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-               virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               UInt_t fValue;          // The value
-
-
-
-               ClassDef(AliUIntHolder, 1);
-
-       };
-
-
-
-       class AliFloatHolder: public TObject {
-
-       
-
-       public:
-
-
-
-               AliFloatHolder() {}
-
-               virtual ~AliFloatHolder() {}
-
-       
-
-               AliFloatHolder(Float_t val):fValue(val) {}
-
-               
-
-               Float_t GetValue() const {return fValue;}
-
-               void SetValue(const Float_t val) {fValue = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-               virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-       private:
-
-               Float_t fValue;         // The value
-
-
-
-               ClassDef(AliFloatHolder, 1);
-
-       };
-
-
-
-       class AliDynHolder: public TObject {
-
-       
-
-       public:
-
-
-
-               AliDynHolder(): fSize(0) {}
-
-               AliDynHolder(Int_t size): fSize(size){}
-
-               
-
-               Int_t GetSize() const {return fSize;}
-
-               void  SetSize(const Int_t n) {fSize = n;}
-
-               
-
-       protected:
-
-               Int_t fSize;            // The size
-
-
-
-               ClassDef(AliDynHolder, 0);
-
-       };
-
-
-
-       class AliDynBoolHolder: public AliDynHolder {
-
-       
-
-       public:
-
-
-
-               AliDynBoolHolder(): fValues(NULL) {}
-
-
-
-               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 ~AliDynBoolHolder() {if (fValues) delete[] fValues;}
-
-               
-
-               Bool_t GetValue(Int_t n) const {return fValues[n];}
-
-               Bool_t* GetValues() const {return fValues;}
-
-               void SetValue(const Int_t pos, const Bool_t val) {fValues[pos] = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-                virtual Bool_t IsEqual(const TObject* object) const; 
-
-
-
-
-
-       private:
-
-               AliDynBoolHolder(const AliDynBoolHolder& /*other*/): AliDynHolder() { }
-
-               AliDynBoolHolder& operator= (const AliDynBoolHolder& /*other*/) {return *this;}
-
-               Bool_t* fValues; //[fSize]       The value
-
-
-
-               ClassDef(AliDynBoolHolder, 1);
-
-       };
-
-
-
-       class AliDynByteHolder: public AliDynHolder {
-
-       
-
-       public:
-
-       
-
-               AliDynByteHolder(): fValues(NULL) {}
-
-
-
-               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 ~AliDynByteHolder() {if (fValues) delete[] fValues;}
-
-               
-
-               Char_t GetValue(Int_t n) const {return fValues[n];}
-
-               Char_t* GetValues() const {return fValues;}
-
-               void SetValue(const Int_t pos, const Char_t val) {fValues[pos] = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-                virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               AliDynByteHolder(const AliDynByteHolder& /*other*/): AliDynHolder() { }
-
-               AliDynByteHolder& operator= (const AliDynByteHolder& /*other*/) {return *this;}
-
-               Char_t* fValues; //[fSize]       The value
-
-
-
-               ClassDef(AliDynByteHolder, 1);
-
-       };
-
-
-
-       class AliDynIntHolder: public AliDynHolder {
-
-       
-
-       public:
-
-
-
-               AliDynIntHolder(): fValues(NULL) {}
-
-
-
-               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 ~AliDynIntHolder() {if (fValues) delete[] fValues;}
-
-               
-
-               Int_t GetValue(Int_t n) const {return fValues[n];}
-
-               Int_t* GetValues() const {return fValues;}
-
-               void SetValue(const Int_t pos, const Int_t val) {fValues[pos] = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-                virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               AliDynIntHolder(const AliDynIntHolder& /*other*/): AliDynHolder() { }
-
-               AliDynIntHolder& operator= (const AliDynIntHolder& /*other*/) {return *this;}
-
-               Int_t* fValues; //[fSize]        The value
-
-
-
-               ClassDef(AliDynIntHolder, 1);
-
-       };
-
-
-
-       class AliDynUIntHolder: public AliDynHolder {
-
-       
-
-       public:
-
-
-
-               AliDynUIntHolder(): fValues(NULL) {}
-
-
-
-               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 ~AliDynUIntHolder() {if (fValues) delete[] fValues;}
-
-               
-
-               UInt_t GetValue(Int_t n) const {return fValues[n];}
-
-               UInt_t* GetValues() const {return fValues;}
-
-               void SetValue(const Int_t pos, const UInt_t val) {fValues[pos] = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-                virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               AliDynUIntHolder(const AliDynUIntHolder& /*other*/): AliDynHolder() { }
-
-               AliDynUIntHolder& operator= (const AliDynUIntHolder& /*other*/) {return *this;}
-
-               UInt_t* fValues; //[fSize]       The value
-
-
-
-               ClassDef(AliDynUIntHolder, 1);
-
-       };
-
-
-
-       class AliDynFloatHolder: public AliDynHolder {
-
-       
-
-       public:
-
-
-
-               AliDynFloatHolder(): fValues(NULL) {}
-
-
-
-               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 ~AliDynFloatHolder() {if (fValues) delete[] fValues;}
-
-               
-
-               Float_t GetValue(Int_t n) const {return fValues[n];}
-
-               Float_t* GetValues() const {return fValues;}
-
-               void SetValue(const Int_t pos, const Float_t val) {fValues[pos] = val;}
-
-               
-
-               virtual TObject* Clone(const char* name) const;
-
-
-
-                virtual Bool_t IsEqual(const TObject* object) const;
-
-
-
-
-
-       private:
-
-               AliDynFloatHolder(const AliDynFloatHolder& /*other*/): AliDynHolder() { }
-
-               AliDynFloatHolder& operator= (const AliDynFloatHolder& /*other*/) {return *this;}
-
-               Float_t* fValues; //[fSize]      The value
-
-
-
-               ClassDef(AliDynFloatHolder, 1);
-
-       };
-
-
-
-
-
-       TObject* fHolder;       // Holder of the basic type value
-
-
-
-       Type fType;     // Type of the basic type value
-
-
-
-
-
-       Bool_t TypeOk(Type type) const;
-
-
-
-       Bool_t BoundsOk(Int_t n) const;
-
-
-
-
-
-       ClassDef(AliSimpleValue, 1);
-
-};
-
-
-
-#endif
-
index 3b7f2de..bbc99d9 100644 (file)
 #pragma link C++ class AliCDBGridFactory;
 #pragma link C++ class AliCDBGridParam;
 
-#pragma link C++ class AliSimpleValue;
-#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;
index df4d669..8a36070 100644 (file)
@@ -1,7 +1,7 @@
 SRCS          = AliCDBEntry.cxx AliCDBId.cxx AliCDBMetaData.cxx \
 AliCDBPath.cxx AliCDBRunRange.cxx AliCDBManager.cxx \
 AliCDBStorage.cxx AliCDBLocal.cxx AliCDBDump.cxx AliCDBGrid.cxx \
-AliSimpleValue.cxx AliDCSValue.cxx \
+AliDCSValue.cxx \
 AliPreprocessor.cxx AliDefaultPreprocessor.cxx \
 AliShuttleInterface.cxx 
 
@@ -12,7 +12,7 @@ DHDR= CDBLinkDef.h
 EXPORT:= AliCDBEntry.h AliCDBId.h AliCDBMetaData.h \
 AliCDBPath.h AliCDBRunRange.h AliCDBManager.h \
 AliCDBStorage.h AliCDBLocal.h AliCDBDump.h AliCDBGrid.h \
-AliSimpleValue.h AliDCSValue.h \
+AliDCSValue.h \
 AliPreprocessor.h AliDefaultPreprocessor.h \
 AliShuttleInterface.h