]>
Commit | Line | Data |
---|---|---|
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 |