Separate library for CDB (Jan)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jun 2006 14:14:36 +0000 (14:14 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jun 2006 14:14:36 +0000 (14:14 +0000)
19 files changed:
ALIROOT/binaliroot.pkg
EVE/binalieve.pkg
RAW/binalimdc.pkg
RAW/bindateStream.pkg
STEER/AliDCSValue.cxx [new file with mode: 0644]
STEER/AliDCSValue.h [new file with mode: 0644]
STEER/AliDefaultPreprocessor.cxx [new file with mode: 0644]
STEER/AliDefaultPreprocessor.h [new file with mode: 0644]
STEER/AliPreprocessor.cxx [new file with mode: 0644]
STEER/AliPreprocessor.h [new file with mode: 0644]
STEER/AliShuttleInterface.cxx [new file with mode: 0644]
STEER/AliShuttleInterface.h [new file with mode: 0644]
STEER/AliSimpleValue.cxx [new file with mode: 0644]
STEER/AliSimpleValue.h [new file with mode: 0644]
STEER/CDBLinkDef.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libCDB.pkg [new file with mode: 0644]
STEER/libSTEER.pkg
build/module.dep

index 1a99119..9979851 100644 (file)
@@ -13,7 +13,7 @@ ELIBS:= MUONgeometry MUONrec MUONsim MUONbase MUONraw MUONmapping \
         RICHbase RICHrec RICHsim \
         ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec \
         EMCALbase EMCALsim EMCALrec EMCALjet \
-        STRUCT STARTbase STARTsim STARTrec EVGEN ESD STEER \
+        STRUCT STARTbase STARTsim STARTrec EVGEN ESD CDB STEER \
         pythia6 AliPythia6 pdf THijing \
         hijing TMEVSIM mevsim THbtp HBTP TEPEMGEN EPEMGEN \
         FASTSIM microcern RAWData AliL3Src AliL3Comp AliL3Misc AliL3MUON \
index d64ea8c..4e9f48f 100644 (file)
@@ -12,7 +12,7 @@ ELIBS    := Reve Alieve \
   RICHbase RICHrec RICHsim \
   ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec \
   EMCALbase EMCALsim EMCALrec EMCALjet \
-  STRUCT STARTbase STARTsim STARTrec EVGEN ESD STEER \
+  STRUCT STARTbase STARTsim STARTrec EVGEN ESD CDB STEER \
   pythia6 AliPythia6 pdf THijing \
   hijing TMEVSIM mevsim THbtp HBTP TEPEMGEN EPEMGEN \
   FASTSIM microcern RAWData AliL3Src AliL3Comp AliL3Misc AliL3MUON \
index e96b217..efc0df7 100644 (file)
@@ -14,7 +14,7 @@ EINCLUDE+= TPC ITS RAW HLT/src HLT/hough HLT/comp HLT/ITS
 
 PACKBLIBS := $(ROOTCLIBS) $(SYSLIBS)
 
-ELIBS:=ESD RAWData MDC MDCFilter STEER TPCbase TPCsim TPCrec AliL3Src AliL3Misc AliL3Hough AliL3Comp AliL3ITS AliL3MUON ITSbase ITSsim ITSrec MUONsim MUONrec MUONbase MUONgeometry MUONraw MUONmapping
+ELIBS:=ESD RAWData MDC MDCFilter CDB STEER TPCbase TPCsim TPCrec AliL3Src AliL3Misc AliL3Hough AliL3Comp AliL3ITS AliL3MUON ITSbase ITSsim ITSrec MUONsim MUONrec MUONbase MUONgeometry MUONraw MUONmapping
 
 ifneq (,$(findstring macosx,$(ALICE_TARGET)))
 PACKLDFLAGS:=$(LDFLAGS) $(@PACKAGE@LIBSINIT:%=-Wl,-u,_G__cpp_setupG__%)
index f849227..ebdc87e 100644 (file)
@@ -13,7 +13,7 @@ EINCLUDE+= TPC ITS RAW HLT/src HLT/hough HLT/comp HLT/ITS
 
 PACKBLIBS := $(ROOTCLIBS) $(SYSLIBS)
 
-ELIBS:=ESD RAWData MDC MDCFilter STEER TPCbase TPCsim TPCrec AliL3Src AliL3Misc AliL3Hough AliL3Comp AliL3ITS AliL3MUON ITSbase ITSsim ITSrec MUONsim MUONrec MUONbase MUONgeometry MUONraw MUONmapping
+ELIBS:=ESD RAWData MDC MDCFilter CDB STEER TPCbase TPCsim TPCrec AliL3Src AliL3Misc AliL3Hough AliL3Comp AliL3ITS AliL3MUON ITSbase ITSsim ITSrec MUONsim MUONrec MUONbase MUONgeometry MUONraw MUONmapping
 
 ifneq (,$(findstring macosx,$(ALICE_TARGET)))
 PACKLDFLAGS:=$(LDFLAGS) $(@PACKAGE@LIBSINIT:%=-Wl,-u,_G__cpp_setupG__%)
diff --git a/STEER/AliDCSValue.cxx b/STEER/AliDCSValue.cxx
new file mode 100644 (file)
index 0000000..8590ff3
--- /dev/null
@@ -0,0 +1,68 @@
+/**************************************************************************
+ * 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/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 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.
+// 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
+//
+
+#include "AliDCSValue.h"
+
+#include "TTimeStamp.h"
+
+ClassImp(AliDCSValue)
+
+AliDCSValue::AliDCSValue() {
+
+}
+
+AliDCSValue::AliDCSValue(const AliSimpleValue& value, UInt_t timeStamp):
+       fValue(value), fTimeStamp(timeStamp)
+{
+
+}
+
+
+TString AliDCSValue::ToString() const {
+
+       return fValue.ToString() + ", Timestmap: " +
+                TTimeStamp(fTimeStamp).AsString();
+}
+
+
diff --git a/STEER/AliDCSValue.h b/STEER/AliDCSValue.h
new file mode 100644 (file)
index 0000000..016647d
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef ALI_DCS_VALUE_H
+#define ALI_DCS_VALUE_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//
+// This class represents the main value structure
+// which forms so called 'historical data' in any SCADA system.
+//
+
+#include "AliSimpleValue.h"
+
+class AliDCSValue: public TObject {
+public:
+
+       AliDCSValue();
+       AliDCSValue(const AliSimpleValue& value, UInt_t timeStamp);
+
+       AliSimpleValue& GetSimpleValue() {return fValue;};
+       const AliSimpleValue& GetSimpleValue() const {return fValue;};  
+       void SetSimpleValue(const AliSimpleValue& value) {fValue = value;};
+
+       UInt_t GetTimeStamp() const {return fTimeStamp;};
+       void SetTimeStamp(UInt_t timeStamp) {fTimeStamp = timeStamp;};
+
+       Int_t GetSize() const {return fValue.GetSize() + sizeof(UInt_t);};
+
+       TString ToString() const;
+
+private:
+
+        AliSimpleValue fValue;
+
+        UInt_t fTimeStamp;
+
+
+       ClassDef(AliDCSValue, 1);
+};
+
+#endif
diff --git a/STEER/AliDefaultPreprocessor.cxx b/STEER/AliDefaultPreprocessor.cxx
new file mode 100644 (file)
index 0000000..7bf097e
--- /dev/null
@@ -0,0 +1,39 @@
+#include <AliDefaultPreprocessor.h>
+
+#include <TMap.h>
+
+#include "AliCDBMetaData.h"
+#include "AliSimpleValue.h"
+
+//
+// This class is used for all subdectectors that dont have an own
+// preprocessor.
+// The DCS data is written into CDB, no files are processed.
+//
+
+ClassImp(AliDefaultPreprocessor)
+
+AliDefaultPreprocessor::AliDefaultPreprocessor(const char* detector, AliShuttleInterface* shuttle) :
+AliPreprocessor(detector, shuttle)
+{
+}
+
+AliDefaultPreprocessor::~AliDefaultPreprocessor()
+{
+}
+
+Int_t AliDefaultPreprocessor::Process(TMap* dcsAliasMap)
+{
+  // store to default CDB object
+
+  AliCDBMetaData metaData;
+  metaData.SetProperty("StartTime",
+      new AliSimpleValue(fStartTime));
+  metaData.SetProperty("EndTime",
+      new AliSimpleValue(fEndTime));
+  metaData.SetComment("Automatically stored by AliDefaultPreprocessor!");
+
+  Store(dcsAliasMap, &metaData);
+
+  return 0;
+}
diff --git a/STEER/AliDefaultPreprocessor.h b/STEER/AliDefaultPreprocessor.h
new file mode 100644 (file)
index 0000000..6b3cd13
--- /dev/null
@@ -0,0 +1,27 @@
+#ifndef ALI_DEFAULT_PREPROCESSOR_H
+#define ALI_DEFAULT_PREPROCESSOR_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//
+// Default preprocessor that writes the retrieved DCS values to CDB
+//
+
+#include <AliPreprocessor.h>
+
+class AliDefaultPreprocessor: public AliPreprocessor {
+
+public:
+       AliDefaultPreprocessor(const char* detector, AliShuttleInterface* shuttle);
+       virtual ~AliDefaultPreprocessor();
+
+       virtual Int_t Process(TMap* dcsAliasMap);
+
+private:
+  ClassDef(AliDefaultPreprocessor, 0);
+};
+
+#endif
diff --git a/STEER/AliPreprocessor.cxx b/STEER/AliPreprocessor.cxx
new file mode 100644 (file)
index 0000000..b70dc3a
--- /dev/null
@@ -0,0 +1,136 @@
+/**************************************************************************
+ * 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/03/07 07:52:34  hristov
+New version (B.Yordanov)
+
+Revision 1.3  2005/11/17 17:47:34  byordano
+TList changed to TObjArray
+
+Revision 1.2  2005/11/17 14:43:22  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/29 21:15:47  byordano
+some docs added
+
+*/
+
+// Description:
+// This class is the CDBPreProcessor interface,
+// supposed to be implemented by any detector
+// interested in immediate processing of data 
+// which is retrieved from DCS.
+// For every particular run set of aliases and
+// their corespoding value sets are returned.
+// Usage schema:
+//     1) virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime) 
+//     This method is called at the begining of data retrieval.
+//     run: run number
+//     startTime: when the run started
+//     endTime: when the run finished  
+//
+//     2) virtual void Process()
+//
+//     This method is called and passed a list of retrieved values from DCS
+//
+//
+
+
+#include "AliPreprocessor.h"
+
+#include <TString.h>
+#include <TList.h>
+#include <TMap.h>
+
+#include "AliLog.h"
+#include "AliCDBMetaData.h"
+#include "AliCDBStorage.h"
+#include "AliCDBId.h"
+#include "AliCDBPath.h"
+#include "AliShuttleInterface.h"
+
+ClassImp(AliPreprocessor)
+
+AliPreprocessor::AliPreprocessor(const char* detector, AliShuttleInterface* shuttle) :
+  TNamed(detector, ""),
+  fShuttle(shuttle)
+{
+       SetTitle(Form("AliPreprocessor for %s subdetector.", detector));
+
+  if (!fShuttle)
+    AliFatal("Initialized without Shuttle instance.");
+}
+
+AliPreprocessor::~AliPreprocessor()
+{
+}
+
+void AliPreprocessor::Initialize(Int_t run, UInt_t startTime,  UInt_t endTime)
+{
+  // Sets the information of the run which is currently processed
+  // can be overriden for special behaviour, make sure that you call base class
+  // function
+
+  fRun = run;
+  fStartTime = startTime;
+  fEndTime = endTime;
+}
+
+Int_t AliPreprocessor::Store(TObject* object, AliCDBMetaData* metaData)
+{
+  // Stores the CDB object
+  // This function should be called at the end of the preprocessor cycle
+  //
+  // The call is delegated to AliShuttleInterface
+
+  return fShuttle->Store(GetName(), object, metaData);
+}
+
+const char* AliPreprocessor::GetFile(Int_t system, const char* id, const char* source)
+{
+  // This function retrieves a file from the given system (kDAQ, kDCS, kHLT) with the given file id
+  // and from the given source in the system.
+  // The function returnes the path to the local file.
+  //
+  // The call is delegated to AliShuttleInterface
+
+  return fShuttle->GetFile(system, GetName(), id, source);
+}
+
+TList* AliPreprocessor::GetFileSources(Int_t system, const char* id)
+{
+  // Returns a list of sources in a given system that saved a file with the given id
+  //
+  // The call is delegated to AliShuttleInterface
+
+  return fShuttle->GetFileSources(system, GetName(), id);
+}
+
+void AliPreprocessor::Log(const char* message)
+{
+  // Adds a log message to the Shuttle log of this preprocessor
+  //
+  // The call is delegated to AliShuttleInterface
+
+  fShuttle->Log(GetName(), message);
+}
diff --git a/STEER/AliPreprocessor.h b/STEER/AliPreprocessor.h
new file mode 100644 (file)
index 0000000..3fa70a4
--- /dev/null
@@ -0,0 +1,51 @@
+#ifndef ALI_PREPROCESSOR_H
+#define ALI_PREPROCESSOR_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//
+// This class is the CDBPreProcessor interface,
+// supposed to be implemented by any detector
+// interested in immediate processing of data 
+// which is retrieved from DCS, DAQ or HLT.
+//
+
+#include <TNamed.h>
+
+class TList;
+class TMap;
+
+class AliCDBMetaData;
+class AliShuttleInterface;
+
+class AliPreprocessor : public TNamed
+{
+  public:
+    enum { kDAQ, kDCS, kHLT };
+
+    AliPreprocessor(const char* detector, AliShuttleInterface* shuttle);
+    virtual ~AliPreprocessor();
+
+    virtual void Initialize(Int_t run, UInt_t startTime,       UInt_t endTime);
+    virtual Int_t Process(TMap* dcsAliasMap) = 0;
+
+  protected:
+    Int_t Store(TObject* object, AliCDBMetaData* metaData);
+    const char* GetFile(Int_t system, const char* id, const char* source);
+    TList* GetFileSources(Int_t system, const char* id);
+    void Log(const char* message);
+
+    Int_t fRun;         // current run
+    UInt_t fStartTime;  // starttime of current run
+    UInt_t fEndTime;    // endtime of current run
+
+  private:
+    AliShuttleInterface* fShuttle;   // link to Shuttle
+
+    ClassDef(AliPreprocessor, 0);
+};
+
+#endif
diff --git a/STEER/AliShuttleInterface.cxx b/STEER/AliShuttleInterface.cxx
new file mode 100644 (file)
index 0000000..6af1b0b
--- /dev/null
@@ -0,0 +1,48 @@
+/**************************************************************************
+ * 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/03/07 07:52:34  hristov
+New version (B.Yordanov)
+
+Revision 1.3  2005/11/17 17:47:34  byordano
+TList changed to TObjArray
+
+Revision 1.2  2005/11/17 14:43:22  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/29 21:15:47  byordano
+some docs added
+
+*/
+
+//
+// abstract interface class to AliShuttle
+// This class is implemented by AliTestShuttle for testing and
+// by AliShuttle for the full setup
+//
+
+#include "AliShuttleInterface.h"
+
+ClassImp(AliShuttleInterface)
+
+const char* AliShuttleInterface::fkSystemNames[3] = { "DAQ", "DCS", "HLT" };
diff --git a/STEER/AliShuttleInterface.h b/STEER/AliShuttleInterface.h
new file mode 100644 (file)
index 0000000..50e2410
--- /dev/null
@@ -0,0 +1,33 @@
+#ifndef ALI_SHUTTLE_INTERFACE_H
+#define ALI_SHUTTLE_INTERFACE_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//
+// abstract interface class to AliShuttle
+//
+
+#include <TObject.h>
+
+class TList;
+class AliCDBMetaData;
+
+class AliShuttleInterface : public TObject
+{
+  public:
+    enum { kDAQ = 0, kDCS, kHLT };
+    static const char* fkSystemNames[3];  // names of the systems providing data to the shuttle
+
+    virtual Int_t Store(const char* detector, TObject* object, AliCDBMetaData* metaData) = 0;
+    virtual const char* GetFile(Int_t system, const char* detector, const char* id, const char* source) = 0;
+    virtual TList* GetFileSources(Int_t system, const char* detector, const char* id) = 0;
+    virtual void Log(const char* detector, const char* message) = 0;
+
+  private:
+    ClassDef(AliShuttleInterface, 0);
+};
+
+#endif
diff --git a/STEER/AliSimpleValue.cxx b/STEER/AliSimpleValue.cxx
new file mode 100644 (file)
index 0000000..1dbcd82
--- /dev/null
@@ -0,0 +1,832 @@
+/**************************************************************************
+ * 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/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.
+//
+
+
+#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";
+       }
+}
diff --git a/STEER/AliSimpleValue.h b/STEER/AliSimpleValue.h
new file mode 100644 (file)
index 0000000..4aa35b6
--- /dev/null
@@ -0,0 +1,332 @@
+#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.
+//
+
+#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 BoolHolder: public TObject {
+       public:
+               Bool_t fValue;
+
+               BoolHolder() {}
+
+               BoolHolder(Bool_t val):fValue(val) {}
+               
+               virtual TObject* Clone(const char* name) const; 
+       
+               virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(BoolHolder, 1);
+       };
+
+       class ByteHolder: public TObject {
+       public:
+               Char_t fValue;
+
+               ByteHolder() {};
+
+               ByteHolder(Char_t val):fValue(val) {}
+               
+               virtual TObject* Clone(const char* name) const;
+
+               virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(ByteHolder, 1);
+       };
+
+       class IntHolder: public TObject {
+       public:
+               Int_t fValue;
+
+               IntHolder() {}
+
+               IntHolder(Int_t val):fValue(val) {}
+               
+               virtual TObject* Clone(const char* name) const; 
+
+               virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(IntHolder, 1);
+       };
+
+       class UIntHolder: public TObject {
+       public:
+               UInt_t fValue;
+
+               UIntHolder() {}
+
+               UIntHolder(UInt_t val):fValue(val) {}
+               
+               virtual TObject* Clone(const char* name) const;
+
+               virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(UIntHolder, 1);
+       };
+
+       class FloatHolder: public TObject {
+       public:
+               Float_t fValue;
+
+               FloatHolder() {}
+       
+               FloatHolder(Float_t val):fValue(val) {}
+               
+               virtual TObject* Clone(const char* name) const;
+
+               virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(FloatHolder, 1);
+       };
+
+       class DynHolder: public TObject {
+       public:
+               Int_t fSize;
+
+               DynHolder(): fSize(0) {}
+               DynHolder(Int_t size): fSize(size){}
+
+               ClassDef(DynHolder, 0);
+       };
+
+       class DynBoolHolder: public DynHolder {
+       public:
+               Bool_t* fValues; //[fSize]
+
+               DynBoolHolder(): fValues(NULL) {}
+
+               DynBoolHolder(Int_t size, const Bool_t* buf = NULL):
+                       DynHolder(size) {
+                       fValues = new Bool_t[size];
+                       if (buf) memcpy(fValues, buf, size * sizeof(Bool_t));
+               }
+
+               virtual ~DynBoolHolder() {if (fValues) delete[] fValues;}
+
+               virtual TObject* Clone(const char* name) const;
+
+                virtual Bool_t IsEqual(const TObject* object) const; 
+
+               ClassDef(DynBoolHolder, 1);
+       };
+
+       class DynByteHolder: public DynHolder {
+       public:
+               Char_t* fValues; //[fSize]
+       
+               DynByteHolder(): fValues(NULL) {}
+
+               DynByteHolder(Int_t size, const Char_t* buf = NULL):
+                       DynHolder(size) {
+                       fValues = new Char_t[size];
+                       if (buf) memcpy(fValues, buf, size * sizeof(Char_t));
+               }
+
+               virtual ~DynByteHolder() {if (fValues) delete[] fValues;}
+
+               virtual TObject* Clone(const char* name) const;
+
+                virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(DynByteHolder, 1);
+       };
+
+       class DynIntHolder: public DynHolder {
+       public:
+               Int_t* fValues; //[fSize]
+
+               DynIntHolder(): fValues(NULL) {}
+
+               DynIntHolder(Int_t size, const Int_t* buf = NULL):
+                       DynHolder(size) {
+                       fValues = new Int_t[size];
+                       if (buf) memcpy(fValues, buf, size * sizeof(Int_t));
+               }
+
+               virtual ~DynIntHolder() {if (fValues) delete[] fValues;}
+
+               virtual TObject* Clone(const char* name) const;
+
+                virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(DynIntHolder, 1);
+       };
+
+       class DynUIntHolder: public DynHolder {
+       public:
+               UInt_t* fValues; //[fSize]
+
+               DynUIntHolder(): fValues(NULL) {}
+
+               DynUIntHolder(Int_t size, const UInt_t* buf = NULL):
+                       DynHolder(size) {
+                       fValues = new UInt_t[size];
+                       if (buf) memcpy(fValues, buf, size * sizeof(UInt_t));   
+               } 
+
+               virtual ~DynUIntHolder() {if (fValues) delete[] fValues;}
+
+               virtual TObject* Clone(const char* name) const;
+
+                virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(DynUIntHolder, 1);
+       };
+
+       class DynFloatHolder: public DynHolder {
+       public:
+               Float_t* fValues; //[fSize]
+
+               DynFloatHolder(): fValues(NULL) {}
+
+               DynFloatHolder(Int_t size, const Float_t* buf = NULL):
+                       DynHolder(size) {
+                       fValues = new Float_t[size];
+                       if (buf) memcpy(fValues, buf, size * sizeof(Float_t));
+               }
+
+               virtual ~DynFloatHolder() {if (fValues) delete[] fValues;}
+
+               virtual TObject* Clone(const char* name) const;
+
+                virtual Bool_t IsEqual(const TObject* object) const;
+
+               ClassDef(DynFloatHolder, 1);
+       };
+
+
+       TObject* fHolder;
+
+       Type fType;
+
+
+       Bool_t TypeOk(Type type) const;
+
+       Bool_t BoundsOk(Int_t n) const;
+
+
+       ClassDef(AliSimpleValue, 1);
+};
+
+#endif
diff --git a/STEER/CDBLinkDef.h b/STEER/CDBLinkDef.h
new file mode 100644 (file)
index 0000000..8750ea8
--- /dev/null
@@ -0,0 +1,49 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+#pragma link C++ class AliCDBPath;
+#pragma link C++ class AliCDBRunRange;
+#pragma link C++ class AliCDBId;
+#pragma link C++ class AliCDBMetaData;
+#pragma link C++ class AliCDBEntry;
+#pragma link C++ class AliCDBStorage;
+#pragma link C++ class AliCDBStorageFactory;
+#pragma link C++ class AliCDBManager;
+#pragma link C++ class AliCDBParam;
+#pragma link C++ class AliCDBLocal;
+#pragma link C++ class AliCDBLocalFactory;
+#pragma link C++ class AliCDBLocalParam;
+#pragma link C++ class AliCDBDump;
+#pragma link C++ class AliCDBDumpFactory;
+#pragma link C++ class AliCDBDumpParam; 
+#pragma link C++ class AliCDBGrid;
+#pragma link C++ class AliCDBGridFactory;
+#pragma link C++ class AliCDBGridParam;
+
+#pragma link C++ class AliSimpleValue;
+#pragma link C++ class AliSimpleValue::BoolHolder;
+#pragma link C++ class AliSimpleValue::ByteHolder;
+#pragma link C++ class AliSimpleValue::IntHolder;
+#pragma link C++ class AliSimpleValue::UIntHolder;
+#pragma link C++ class AliSimpleValue::FloatHolder;
+#pragma link C++ class AliSimpleValue::DynHolder;
+#pragma link C++ class AliSimpleValue::DynBoolHolder;
+#pragma link C++ class AliSimpleValue::DynByteHolder;
+#pragma link C++ class AliSimpleValue::DynIntHolder;
+#pragma link C++ class AliSimpleValue::DynUIntHolder;
+#pragma link C++ class AliSimpleValue::DynFloatHolder;
+#pragma link C++ class AliDCSValue;
+
+#pragma link C++ class AliPreprocessor;
+#pragma link C++ class AliDefaultPreprocessor;
+
+#pragma link C++ class AliShuttleInterface;
+
+#endif
index 8eabe83..777b041 100644 (file)
 #pragma link C++ class  AliV0vertexer+;
 #pragma link C++ class  AliCascadeVertexer+;
 
-#pragma link C++ class AliCDBPath;
-#pragma link C++ class AliCDBRunRange;
-#pragma link C++ class AliCDBId;
-#pragma link C++ class AliCDBMetaData;
-#pragma link C++ class AliCDBEntry;
-#pragma link C++ class AliCDBStorage;
-#pragma link C++ class AliCDBStorageFactory;
-#pragma link C++ class AliCDBManager;
-#pragma link C++ class AliCDBParam;
-#pragma link C++ class AliCDBLocal;
-#pragma link C++ class AliCDBLocalFactory;
-#pragma link C++ class AliCDBLocalParam;
-#pragma link C++ class AliCDBDump;
-#pragma link C++ class AliCDBDumpFactory;
-#pragma link C++ class AliCDBDumpParam; 
-#pragma link C++ class AliCDBGrid;
-#pragma link C++ class AliCDBGridFactory;
-#pragma link C++ class AliCDBGridParam;
-
 #pragma link C++ class AliExpression+;
 #pragma link C++ class AliVariableExpression+;
 #pragma link C++ class AliTriggerInput+;
diff --git a/STEER/libCDB.pkg b/STEER/libCDB.pkg
new file mode 100644 (file)
index 0000000..df4d669
--- /dev/null
@@ -0,0 +1,18 @@
+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 \
+AliPreprocessor.cxx AliDefaultPreprocessor.cxx \
+AliShuttleInterface.cxx 
+
+HDRS:= $(SRCS:.cxx=.h)
+
+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 \
+AliPreprocessor.h AliDefaultPreprocessor.h \
+AliShuttleInterface.h 
+
index 6ff3fb0..4330c83 100644 (file)
@@ -19,9 +19,6 @@ AliMemoryWatcher.cxx \
 AliVertexer.cxx  AliVertexerTracks.cxx AliStrLine.cxx \
 AliV0vertexer.cxx AliCascadeVertexer.cxx\
 AliMC.cxx AliSimulation.cxx AliReconstruction.cxx AliVertexGenFile.cxx \
-AliCDBEntry.cxx AliCDBId.cxx AliCDBMetaData.cxx \
-AliCDBPath.cxx AliCDBRunRange.cxx AliCDBManager.cxx\
-AliCDBStorage.cxx AliCDBLocal.cxx AliCDBDump.cxx AliCDBGrid.cxx\
 AliReconstructor.cxx AliDetectorEventHeader.cxx TTreeStream.cxx\
 AliAlignObj.cxx AliAlignObjAngles.cxx AliAlignObjMatrix.cxx \
 AliTriggerInput.cxx \
index cb4b3a0..e3fd6ef 100644 (file)
@@ -1,4 +1,4 @@
+
 ALIFAST/module.mk:      ALIFAST/libALIFAST.pkg
 ALIROOT/module.mk:      ALIROOT/binaliroot.pkg 
 ANALYSIS/module.mk:     ANALYSIS/libANALYSIS.pkg 
@@ -31,7 +31,7 @@ RAW/module.mk:           RAW/libRAWData.pkg RAW/binalimdc.pkg RAW/bindateStream.
 RICH/module.mk:                 RICH/libRICHbase.pkg RICH/libRICHrec.pkg RICH/libRICHsim.pkg
 SHUTTLE/module.mk:      SHUTTLE/libSHUTTLE.pkg
 START/module.mk:        START/libSTARTbase.pkg START/libSTARTsim.pkg START/libSTARTrec.pkg
-STEER/module.mk:        STEER/libESD.pkg STEER/libSTEER.pkg
+STEER/module.mk:        STEER/libESD.pkg STEER/libCDB.pkg STEER/libSTEER.pkg
 STRUCT/module.mk:       STRUCT/libSTRUCT.pkg
 TEPEMGEN/module.mk:      TEPEMGEN/libTEPEMGEN.pkg
 TFluka/module.mk:        TFluka/libTFluka.pkg