STEER/AliCDBManager.h

   1 #ifndef ALI_CDB_MANAGER_H
   2 #define ALI_CDB_MANAGER_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /////////////////////////////////////////////////////////////////////
   8 //                                                                 //
   9 //  class AliCDBManager                                            //
  10 //                                                                 //
  11 /////////////////////////////////////////////////////////////////////
  12
  13 #include <TObject.h>
  14 #include <TList.h>
  15 #include <TMap.h>
  16
  17 class AliCDBEntry;
  18 class AliCDBId;
  19 class AliCDBPath;
  20 class AliCDBRunRange;
  21 class AliCDBMetaData;
  22 class AliCDBStorage;
  23 class AliCDBStorageFactory;
  24 class AliCDBParam;
  25
  26 class AliCDBManager: public TObject {
  27
  28  public:
  29         enum DataType {kCondition=0, kReference, kPrivate};
  30
  31         void RegisterFactory(AliCDBStorageFactory* factory);
  32
  33         Bool_t HasStorage(const char* dbString) const;
  34
  35         AliCDBParam* CreateParameter(const char* dbString) const;
  36         AliCDBParam* GetCondParam() const {return fCondParam;}
  37         AliCDBParam* GetRefParam() const {return fRefParam;}
  38         static const char* GetDataTypeName(DataType type);
  39
  40         AliCDBStorage* GetStorage(const char* dbString);
  41         AliCDBStorage* GetStorage(const AliCDBParam* param);
  42
  43         TList* GetActiveStorages();
  44
  45         void SetDefaultStorage(const char* dbString);
  46         void SetDefaultStorage(const AliCDBParam* param);
  47         void SetDefaultStorage(AliCDBStorage *storage);
  48
  49         Bool_t IsDefaultStorageSet() const {return fDefaultStorage != 0;}
  50         AliCDBStorage* GetDefaultStorage() const {return fDefaultStorage;}
  51         void UnsetDefaultStorage() {fDefaultStorage = 0x0;}
  52
  53         void SetSpecificStorage(const char* calibType, const char* dbString);
  54         void SetSpecificStorage(const char* calibType, AliCDBParam* param);
  55
  56         AliCDBStorage* GetSpecificStorage(const char* calibType);
  57
  58         void SetDrain(const char* dbString);
  59         void SetDrain(const AliCDBParam* param);
  60         void SetDrain(AliCDBStorage *storage);
  61
  62         Bool_t IsDrainSet() const {return fDrainStorage != 0;}
  63
  64         Bool_t Drain(AliCDBEntry* entry);
  65
  66         void UnsetDrain(){fDrainStorage = 0x0;}
  67
  68         AliCDBEntry* Get(const AliCDBId& query);
  69         AliCDBEntry* Get(const AliCDBPath& path, Int_t runNumber=-1,
  70                                 Int_t version = -1, Int_t subVersion = -1);
  71         AliCDBEntry* Get(const AliCDBPath& path, const AliCDBRunRange& runRange,
  72                                  Int_t version = -1, Int_t subVersion = -1);
  73
  74         TList* GetAll(const AliCDBId& query);
  75         TList* GetAll(const AliCDBPath& path, Int_t runNumber=-1,
  76                                 Int_t version = -1, Int_t subVersion = -1);
  77         TList* GetAll(const AliCDBPath& path, const AliCDBRunRange& runRange,
  78                                  Int_t version = -1, Int_t subVersion = -1);
  79
  80         Bool_t Put(TObject* object, AliCDBId& id,
  81                         AliCDBMetaData* metaData, DataType type=kPrivate);
  82         Bool_t Put(AliCDBEntry* entry, DataType type=kPrivate);
  83
  84         void SetCacheFlag(Bool_t cacheFlag) {fCache=cacheFlag;}
  85         Bool_t GetCacheFlag() const {return fCache;}
  86
  87         void SetRun(Int_t run);
  88         Int_t GetRun() const {return fRun;}
  89
  90         // AliCDBEntry* Get(const char* path);
  91
  92         void DestroyActiveStorages();
  93         void DestroyActiveStorage(AliCDBStorage* storage);
  94
  95         void QueryCDB();
  96
  97         void Print(Option_t* option="") const;
  98
  99         static void Destroy();
 100         ~AliCDBManager();
 101
 102         void ClearCache();
 103         void UnloadFromCache(const char* path);
 104
 105         static AliCDBManager* Instance();
 106
 107  private:
 108
 109         static TString fgkCondUri;      // URI of the Conditions data base folder
 110         static TString fgkRefUri;       // URI of the Reference data base folder
 111         AliCDBParam* fCondParam;        // Conditions data storage parameters
 112         AliCDBParam* fRefParam;         // Reference data storage parameters
 113
 114         AliCDBManager();
 115         AliCDBManager(const AliCDBManager & source);
 116         AliCDBManager & operator=(const AliCDBManager & source);
 117
 118         static AliCDBManager* fgInstance; // AliCDBManager instance
 119
 120         AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
 121         void PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage);
 122
 123         void CacheEntry(const char* path, AliCDBEntry* entry);
 124
 125         AliCDBParam* SelectSpecificStorage(const TString& path);
 126
 127
 128         void Init();
 129
 130         TList fFactories;               //! list of registered storage factories
 131         TMap fActiveStorages;           //! list of active storages
 132         TMap fSpecificStorages;         //! list of detector-specific storages
 133
 134         AliCDBStorage *fDefaultStorage; //! pointer to default storage
 135         AliCDBStorage *fDrainStorage;   //! pointer to drain storage
 136
 137         TMap fEntryCache;       //! cache of the retrieved objects
 138
 139         Bool_t fCache;                  //! The cache flag
 140         Int_t fRun;                     //! The run number
 141
 142         ClassDef(AliCDBManager, 0);
 143 };
 144
 145
 146 /////////////////////////////////////////////////////////////////////
 147 //                                                                 //
 148 //  class AliCDBStorageFactory                                     //
 149 //                                                                 //
 150 /////////////////////////////////////////////////////////////////////
 151
 152 class AliCDBParam;
 153 class AliCDBStorageFactory: public TObject {
 154         friend class AliCDBManager;
 155
 156 public:
 157         virtual ~AliCDBStorageFactory(){}
 158         virtual Bool_t Validate(const char* dbString) = 0;
 159         virtual AliCDBParam* CreateParameter(const char* dbString) = 0;
 160
 161 protected:
 162         virtual AliCDBStorage* Create(const AliCDBParam* param) = 0;
 163
 164         ClassDef(AliCDBStorageFactory, 0);
 165 };
 166
 167 /////////////////////////////////////////////////////////////////////
 168 //                                                                 //
 169 //  class AliCDBParam                                              //
 170 //                                                                 //
 171 /////////////////////////////////////////////////////////////////////
 172
 173 class AliCDBParam: public TObject {
 174
 175 public:
 176
 177         AliCDBParam();
 178         virtual ~AliCDBParam();
 179
 180         const TString& GetType() const {return fType;};
 181         const TString& GetURI() const {return fURI;};
 182
 183         virtual AliCDBParam* CloneParam() const = 0;
 184
 185 protected:
 186
 187         void SetType(const char* type) {fType = type;};
 188         void SetURI(const char* uri) {fURI = uri;};
 189
 190 private:
 191
 192         TString fType; //! CDB type
 193         TString fURI;  //! CDB URI
 194
 195         ClassDef(AliCDBParam, 0);
 196 };
 197
 198 #endif