Replace QADataMakerSteer by QAManager deriving from CDBManager
[u/mrichter/AliRoot.git] / 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         const TMap* GetStorageMap() const {return fStorageMap;}
46         const TList* GetRetrievedIds() const {return fIds;}
47
48         void SetDefaultStorage(const char* dbString);
49         void SetDefaultStorage(const AliCDBParam* param);
50         void SetDefaultStorage(AliCDBStorage *storage);
51
52         Bool_t IsDefaultStorageSet() const {return fDefaultStorage != 0;}
53         AliCDBStorage* GetDefaultStorage() const {return fDefaultStorage;}
54         void UnsetDefaultStorage();
55
56         void SetSpecificStorage(const char* calibType, const char* dbString);
57         void SetSpecificStorage(const char* calibType, AliCDBParam* param);
58
59         AliCDBStorage* GetSpecificStorage(const char* calibType);
60
61         void SetDrain(const char* dbString);
62         void SetDrain(const AliCDBParam* param);
63         void SetDrain(AliCDBStorage *storage);
64
65         Bool_t IsDrainSet() const {return fDrainStorage != 0;}
66
67         Bool_t Drain(AliCDBEntry* entry);
68
69         void UnsetDrain(){fDrainStorage = 0x0;}
70
71         AliCDBEntry* Get(const AliCDBId& query);
72         AliCDBEntry* Get(const AliCDBPath& path, Int_t runNumber=-1,
73                                 Int_t version = -1, Int_t subVersion = -1);
74         AliCDBEntry* Get(const AliCDBPath& path, const AliCDBRunRange& runRange,
75                                  Int_t version = -1, Int_t subVersion = -1);
76
77         const char* GetURI(const char* path);                            
78                                  
79         AliCDBId* GetId(const AliCDBId& query);
80         AliCDBId* GetId(const AliCDBPath& path, Int_t runNumber=-1,
81                                 Int_t version = -1, Int_t subVersion = -1);
82         AliCDBId* GetId(const AliCDBPath& path, const AliCDBRunRange& runRange,
83                                  Int_t version = -1, Int_t subVersion = -1);
84
85         TList* GetAll(const AliCDBId& query);
86         TList* GetAll(const AliCDBPath& path, Int_t runNumber=-1,
87                                 Int_t version = -1, Int_t subVersion = -1);
88         TList* GetAll(const AliCDBPath& path, const AliCDBRunRange& runRange,
89                                  Int_t version = -1, Int_t subVersion = -1); 
90
91         Bool_t Put(TObject* object, AliCDBId& id,
92                         AliCDBMetaData* metaData, DataType type=kPrivate);
93         Bool_t Put(AliCDBEntry* entry, DataType type=kPrivate);
94
95         void SetCacheFlag(Bool_t cacheFlag) {fCache=cacheFlag;}
96         Bool_t GetCacheFlag() const {return fCache;}
97         
98         void SetLock(Bool_t lockFlag=kTRUE);
99         Bool_t GetLock() const {return fLock;}
100
101         void SetRun(Int_t run);
102         Int_t GetRun() const {return fRun;}
103
104         void DestroyActiveStorages();
105         void DestroyActiveStorage(AliCDBStorage* storage);
106
107         void QueryCDB();
108
109         void Print(Option_t* option="") const;
110
111         static void Destroy();
112         ~AliCDBManager();
113
114         void ClearCache();
115         void UnloadFromCache(const char* path);
116         const TMap* GetEntryCache() const {return &fEntryCache;}
117
118         Bool_t IsShortLived(const char* path);
119
120         static AliCDBManager* Instance(TMap *entryCache = NULL, Int_t run = -1);
121
122         void Init();
123         void InitFromCache(TMap *entryCache, Int_t run);
124   
125 protected:
126
127         static TString fgkCondUri;      // URI of the Conditions data base folder
128         static TString fgkRefUri;       // URI of the Reference data base folder
129
130         AliCDBManager() ; 
131         AliCDBManager(const AliCDBManager & source);
132         AliCDBManager & operator=(const AliCDBManager & source);
133
134         static AliCDBManager* fgInstance; // AliCDBManager instance
135         
136         AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
137         void PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage);
138
139         void CacheEntry(const char* path, AliCDBEntry* entry);
140
141         AliCDBParam* SelectSpecificStorage(const TString& path);
142         
143
144 //      void Init();
145         void InitShortLived();
146 //      void InitFromCache(TMap *entryCache, Int_t run);
147
148
149         TList fFactories;               //! list of registered storage factories
150         TMap fActiveStorages;           //! list of active storages
151         TMap fSpecificStorages;         //! list of detector-specific storages
152         TMap fEntryCache;               //! cache of the retrieved objects
153
154         TList* fIds;            //! List of the retrieved object Id's (to be streamed to file)
155         TMap* fStorageMap;      //! list of storages (to be streamed to file)
156         TList* fShortLived;     //! List of short lived objects
157
158         AliCDBStorage *fDefaultStorage; //! pointer to default storage
159         AliCDBStorage *fDrainStorage;   //! pointer to drain storage
160
161         AliCDBParam* fCondParam;        // Conditions data storage parameters
162         AliCDBParam* fRefParam;         // Reference data storage parameters
163
164         Int_t fRun;                     //! The run number
165         Bool_t fCache;                  //! The cache flag
166         Bool_t fLock;   //! Lock flag, if ON default storage and run number cannot be reset
167
168
169         ClassDef(AliCDBManager, 0);
170 };
171
172
173 /////////////////////////////////////////////////////////////////////
174 //                                                                 //
175 //  class AliCDBStorageFactory                                     //
176 //                                                                 //
177 /////////////////////////////////////////////////////////////////////
178
179 class AliCDBParam;
180 class AliCDBStorageFactory: public TObject {
181         friend class AliCDBManager;
182         
183 public:
184         virtual ~AliCDBStorageFactory(){}
185         virtual Bool_t Validate(const char* dbString) = 0;
186         virtual AliCDBParam* CreateParameter(const char* dbString) = 0; 
187
188 protected:
189         virtual AliCDBStorage* Create(const AliCDBParam* param) = 0;
190
191         ClassDef(AliCDBStorageFactory, 0);
192 };
193
194 /////////////////////////////////////////////////////////////////////
195 //                                                                 //
196 //  class AliCDBParam                                              //
197 //                                                                 //
198 /////////////////////////////////////////////////////////////////////
199
200 class AliCDBParam: public TObject {
201
202 public:
203
204         AliCDBParam();
205         virtual ~AliCDBParam();
206
207         const TString& GetType() const {return fType;};
208         const TString& GetURI() const {return fURI;};
209
210         virtual AliCDBParam* CloneParam() const = 0;
211
212 protected:
213
214         void SetType(const char* type) {fType = type;};
215         void SetURI(const char* uri) {fURI = uri;};
216
217 private:
218
219         TString fType; //! CDB type
220         TString fURI;  //! CDB URI
221
222         ClassDef(AliCDBParam, 0);
223 };
224
225 #endif