Implementing the possibility of loading the CDB as a snapshot in two ways:
[u/mrichter/AliRoot.git] / STEER / CDB / 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 #include <TSystem.h>
17
18 class AliCDBEntry;
19 class AliCDBId;
20 class AliCDBPath;
21 class AliCDBRunRange;
22 class AliCDBMetaData;
23 class AliCDBStorage;
24 class AliCDBStorageFactory;
25 class AliCDBParam;
26
27 class AliCDBManager: public TObject {
28
29  public:
30         enum DataType {kCondition=0, kReference, kPrivate};
31
32         void RegisterFactory(AliCDBStorageFactory* factory);
33
34         Bool_t HasStorage(const char* dbString) const;
35
36         AliCDBParam* CreateParameter(const char* dbString) const;
37         AliCDBParam* GetCondParam() const {return fCondParam;}
38         AliCDBParam* GetRefParam() const {return fRefParam;}
39         static const char* GetDataTypeName(DataType type);
40
41         AliCDBStorage* GetStorage(const char* dbString);
42         AliCDBStorage* GetStorage(const AliCDBParam* param);
43
44         TList* GetActiveStorages();
45
46         const TMap* GetStorageMap() const {return fStorageMap;}
47         const TList* GetRetrievedIds() const {return fIds;}
48
49         void SetDefaultStorage(const char* dbString);
50         void SetDefaultStorage(const AliCDBParam* param);
51         void SetDefaultStorage(AliCDBStorage *storage);
52         void SetDefaultStorage(const char* runType, const char* simType);
53         void SetDefaultStorageFromRun(Int_t run);
54
55         Bool_t IsDefaultStorageSet() const {return fDefaultStorage != 0;}
56         AliCDBStorage* GetDefaultStorage() const {return fDefaultStorage;}
57         void UnsetDefaultStorage();
58
59         void SetSpecificStorage(const char* calibType, const char* dbString);
60         void SetSpecificStorage(const char* calibType, const AliCDBParam* param);
61
62         AliCDBStorage* GetSpecificStorage(const char* calibType);
63
64         void SetDrain(const char* dbString);
65         void SetDrain(const AliCDBParam* param);
66         void SetDrain(AliCDBStorage *storage);
67
68         Bool_t IsDrainSet() const {return fDrainStorage != 0;}
69
70         Bool_t Drain(AliCDBEntry* entry);
71
72         void UnsetDrain(){fDrainStorage = 0x0;}
73
74         AliCDBEntry* Get(const AliCDBId& query);
75         AliCDBEntry* Get(const AliCDBPath& path, Int_t runNumber=-1,
76                                 Int_t version = -1, Int_t subVersion = -1);
77         AliCDBEntry* Get(const AliCDBPath& path, const AliCDBRunRange& runRange,
78                                  Int_t version = -1, Int_t subVersion = -1);
79
80         const char* GetURI(const char* path);                            
81                                  
82         AliCDBId* GetId(const AliCDBId& query);
83         AliCDBId* GetId(const AliCDBPath& path, Int_t runNumber=-1,
84                                 Int_t version = -1, Int_t subVersion = -1);
85         AliCDBId* GetId(const AliCDBPath& path, const AliCDBRunRange& runRange,
86                                  Int_t version = -1, Int_t subVersion = -1);
87
88         TList* GetAll(const AliCDBId& query);
89         TList* GetAll(const AliCDBPath& path, Int_t runNumber=-1,
90                                 Int_t version = -1, Int_t subVersion = -1);
91         TList* GetAll(const AliCDBPath& path, const AliCDBRunRange& runRange,
92                                  Int_t version = -1, Int_t subVersion = -1); 
93
94         Bool_t Put(TObject* object, const AliCDBId& id,
95                         AliCDBMetaData* metaData, const DataType type=kPrivate);
96         Bool_t Put(AliCDBEntry* entry, DataType type=kPrivate);
97
98         void SetCacheFlag(Bool_t cacheFlag) {fCache=cacheFlag;}
99         Bool_t GetCacheFlag() const {return fCache;}
100         
101         ULong_t SetLock(Bool_t lockFlag=kTRUE, ULong_t key=0);
102         Bool_t GetLock() const {return fLock;}
103
104         void SetRaw(Bool_t rawFlag){fRaw=rawFlag;}
105         Bool_t GetRaw() const {return fRaw;}
106
107         void SetRun(Int_t run);
108         Int_t GetRun() const {return fRun;}
109
110         void DestroyActiveStorages();
111         void DestroyActiveStorage(AliCDBStorage* storage);
112
113         void QueryCDB();
114
115         void Print(Option_t* option="") const;
116
117         static void Destroy();
118         ~AliCDBManager();
119
120         void ClearCache();
121         void UnloadFromCache(const char* path);
122         const TMap* GetEntryCache() const {return &fEntryCache;}
123
124         Bool_t IsShortLived(const char* path);
125
126         static AliCDBManager* Instance(TMap *entryCache = NULL, Int_t run = -1);
127
128         void Init();
129         void InitFromCache(TMap *entryCache, Int_t run);
130         Bool_t InitFromSnapshot(const char* snapshotFileName);
131   
132 protected:
133
134         static TString fgkCondUri;      // URI of the Conditions data base folder
135         static TString fgkRefUri;       // URI of the Reference data base folder
136         static TString fgkMCIdealStorage;       // URI of the MC-Ideal Conditions data base folder form MC data
137         static TString fgkMCFullStorage;        // URI of the MC-Full Conditions data base folder form MC data
138         static TString fgkMCResidualStorage;    // URI of the MC-Residual Conditions data base folder form MC data
139         static TString fgkOCDBFolderXMLfile;    // alien path of the XML file for OCDB folder <--> Run range correspondance
140
141         AliCDBManager() ; 
142         AliCDBManager(const AliCDBManager & source);
143         AliCDBManager & operator=(const AliCDBManager & source);
144
145         static AliCDBManager* fgInstance; // AliCDBManager instance
146         
147         AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
148         void PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage);
149
150         void CacheEntry(const char* path, AliCDBEntry* entry);
151
152         AliCDBParam* SelectSpecificStorage(const TString& path);
153         
154
155 //      void Init();
156         void InitShortLived();
157 //      void InitFromCache(TMap *entryCache, Int_t run);
158
159
160         TList fFactories;               //! list of registered storage factories
161         TMap fActiveStorages;           //! list of active storages
162         TMap fSpecificStorages;         //! list of detector-specific storages
163         TMap fEntryCache;               //! cache of the retrieved objects
164
165         TList* fIds;            //! List of the retrieved object Id's (to be streamed to file)
166         TMap* fStorageMap;      //! list of storages (to be streamed to file)
167         TList* fShortLived;     //! List of short lived objects
168
169         AliCDBStorage *fDefaultStorage; //! pointer to default storage
170         AliCDBStorage *fDrainStorage;   //! pointer to drain storage
171
172         AliCDBParam* fCondParam;        // Conditions data storage parameters
173         AliCDBParam* fRefParam;         // Reference data storage parameters
174
175         Int_t fRun;                     //! The run number
176         Bool_t fCache;                  //! The cache flag
177         Bool_t fLock;   //! Lock flag, if ON default storage and run number cannot be reset
178
179         Bool_t fRaw;   // flag to say whether we are in the raw case
180         Int_t fStartRunLHCPeriod; // 1st run of the LHC period set
181         Int_t fEndRunLHCPeriod;   // last run of the LHC period set
182         TString fLHCPeriod;       // LHC period alien folder
183
184 private:
185    ULong_t fKey;  //! Key for locking/unlocking
186
187
188         ClassDef(AliCDBManager, 0);
189 };
190
191
192 /////////////////////////////////////////////////////////////////////
193 //                                                                 //
194 //  class AliCDBStorageFactory                                     //
195 //                                                                 //
196 /////////////////////////////////////////////////////////////////////
197
198 class AliCDBParam;
199 class AliCDBStorageFactory: public TObject {
200         friend class AliCDBManager;
201         
202 public:
203         virtual ~AliCDBStorageFactory(){}
204         virtual Bool_t Validate(const char* dbString) = 0;
205         virtual AliCDBParam* CreateParameter(const char* dbString) = 0; 
206
207 protected:
208         virtual AliCDBStorage* Create(const AliCDBParam* param) = 0;
209
210         ClassDef(AliCDBStorageFactory, 0);
211 };
212
213 /////////////////////////////////////////////////////////////////////
214 //                                                                 //
215 //  class AliCDBParam                                              //
216 //                                                                 //
217 /////////////////////////////////////////////////////////////////////
218
219 class AliCDBParam: public TObject {
220
221 public:
222
223         AliCDBParam();
224         virtual ~AliCDBParam();
225
226         const TString& GetType() const {return fType;};
227         const TString& GetURI() const {return fURI;};
228
229         virtual AliCDBParam* CloneParam() const = 0;
230
231 protected:
232
233         void SetType(const char* type) {fType = type;};
234         void SetURI(const char* uri) {fURI = uri;};
235
236 private:
237
238         TString fType; //! CDB type
239         TString fURI;  //! CDB URI
240
241         ClassDef(AliCDBParam, 0);
242 };
243
244 #endif