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 \
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 \
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__%)
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__%)
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.2 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();
+}
+
+
--- /dev/null
+#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
--- /dev/null
+#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;
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.2 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);
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.2 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" };
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.2 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";
+ }
+}
--- /dev/null
+#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
--- /dev/null
+#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
#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+;
--- /dev/null
+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
+
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 \
-
+
ALIFAST/module.mk: ALIFAST/libALIFAST.pkg
ALIROOT/module.mk: ALIROOT/binaliroot.pkg
ANALYSIS/module.mk: ANALYSIS/libANALYSIS.pkg
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
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff