STEER/AliCDBDump.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /////////////////////////////////////////////////////////////////////
  17 //                                                                 //
  18 //  class AliCDBDump                                               //
  19 //  access class to a DataBase in a dump storage (single file)     //
  20 //                                                                 //
  21 /////////////////////////////////////////////////////////////////////
  22
  23 #include <TSystem.h>
  24 #include <TKey.h>
  25 #include <TFile.h>
  26 #include <TRegexp.h>
  27 #include <TObjString.h>
  28 #include <TList.h>
  29
  30 #include "AliCDBDump.h"
  31 #include "AliCDBEntry.h"
  32 #include "AliLog.h"
  33
  34 ClassImp(AliCDBDump)
  35
  36 //_____________________________________________________________________________
  37 AliCDBDump::AliCDBDump(const char* dbFile, Bool_t readOnly):
  38 fFile(NULL), fReadOnly(readOnly) {
  39 // constructor
  40
  41         // opening file
  42         fFile = TFile::Open(dbFile, fReadOnly ? "READ" : "UPDATE");
  43         if (!fFile) {
  44                 AliError(Form("Can't open file <%s>!" , dbFile));
  45         } else {
  46                 AliDebug(2,Form("File <%s> opened",dbFile));
  47                 if(fReadOnly) AliDebug(2,Form("in read-only mode"));
  48         }
  49 }
  50
  51 //_____________________________________________________________________________
  52 AliCDBDump::~AliCDBDump() {
  53 // destructor
  54
  55         if (fFile) {
  56                 fFile->Close();
  57                 delete fFile;
  58         }
  59 }
  60
  61
  62 //_____________________________________________________________________________
  63 Bool_t AliCDBDump::KeyNameToId(const char* keyname, AliCDBRunRange& runRange,
  64         Int_t& version, Int_t& subVersion) {
  65 // build AliCDBId from keyname numbers
  66
  67         Ssiz_t mSize;
  68
  69         // valid keyname: Run#firstRun_#lastRun_v#version_s#subVersion.root
  70         TRegexp keyPattern("^Run[0-9]+_[0-9]+_v[0-9]+_s[0-9]+$");
  71         keyPattern.Index(keyname, &mSize);
  72         if (!mSize) {
  73                 AliDebug(2,Form("Bad keyname <%s>.", keyname));
  74                 return kFALSE;
  75         }
  76
  77         TObjArray* strArray = (TObjArray*) TString(keyname).Tokenize("_");
  78
  79         TString firstRunString(((TObjString*) strArray->At(0))->GetString());
  80         runRange.SetFirstRun(atoi(firstRunString.Data() + 3));
  81         runRange.SetLastRun(atoi(((TObjString*) strArray->At(1))->GetString()));
  82
  83         TString verString(((TObjString*) strArray->At(2))->GetString());
  84         version = atoi(verString.Data() + 1);
  85
  86         TString subVerString(((TObjString*) strArray->At(3))->GetString());
  87         subVersion = atoi(subVerString.Data() + 1);
  88
  89         delete strArray;
  90
  91         return kTRUE;
  92 }
  93
  94 //_____________________________________________________________________________
  95 Bool_t AliCDBDump::IdToKeyName(const AliCDBRunRange& runRange, Int_t version,
  96         Int_t subVersion, TString& keyname) {
  97 // build key name from AliCDBId data (run range, version, subVersion)
  98
  99         if (!runRange.IsValid()) {
 100                 AliDebug(2,Form("Invalid run range <%d, %d>.",
 101                         runRange.GetFirstRun(), runRange.GetLastRun()));
 102                 return kFALSE;
 103         }
 104
 105         if (version < 0) {
 106                 AliDebug(2,Form("Invalid version <%d>.", version));
 107                 return kFALSE;
 108         }
 109
 110         if (subVersion < 0) {
 111                 AliDebug(2,Form("Invalid subversion <%s>.", subVersion));
 112                 return kFALSE;
 113         }
 114
 115         keyname += "Run";
 116         keyname += runRange.GetFirstRun();
 117         keyname += "_";
 118         keyname += runRange.GetLastRun();
 119         keyname += "_v";
 120         keyname += version;
 121         keyname += "_s";
 122         keyname += subVersion;
 123
 124         return kTRUE;
 125 }
 126
 127 //_____________________________________________________________________________
 128 Bool_t AliCDBDump::MkDir(const TString& path) {
 129 // descend into TDirectory, making TDirectories if they don't exist
 130         TObjArray* strArray = (TObjArray*) path.Tokenize("/");
 131
 132         TIter iter(strArray);
 133         TObjString* str;
 134
 135         while ((str = (TObjString*) iter.Next())) {
 136
 137                 TString dirName(str->GetString());
 138                 if (!dirName.Length()) {
 139                         continue;
 140                 }
 141
 142                 if (gDirectory->cd(dirName)) {
 143                         continue;
 144                 }
 145
 146                 TDirectory* aDir = gDirectory->mkdir(dirName, "");
 147                 if (!aDir) {
 148                         AliError(Form("Can't create directory <%s>!",
 149                                         dirName.Data()));
 150                         delete strArray;
 151
 152                         return kFALSE;
 153                 }
 154
 155                 aDir->cd();
 156         }
 157
 158         delete strArray;
 159
 160         return kTRUE;
 161 }
 162
 163 //_____________________________________________________________________________
 164 Bool_t AliCDBDump::PrepareId(AliCDBId& id) {
 165 // prepare id (version, subVersion) of the object that will be stored (called by PutEntry)
 166
 167         AliCDBRunRange aRunRange; // the runRange got from filename
 168         AliCDBRunRange lastRunRange(-1,-1); // highest runRange found
 169         Int_t aVersion, aSubVersion; // the version subVersion got from filename
 170         Int_t lastVersion = 0, lastSubVersion = -1; // highest version and subVersion found
 171
 172
 173         TIter iter(gDirectory->GetListOfKeys());
 174         TKey* key;
 175
 176         if (!id.HasVersion()) { // version not specified: look for highest version & subVersion
 177
 178                 while ((key = (TKey*) iter.Next())) { // loop on keys
 179
 180                         const char* keyName = key->GetName();
 181
 182                         if (!KeyNameToId(keyName, aRunRange, aVersion,
 183                            aSubVersion)) {
 184                                 AliDebug(2,Form(
 185                                         "Bad keyname <%s>!I'll skip it.", keyName));
 186                                 continue;
 187                         }
 188
 189                         if (!aRunRange.Overlaps(id.GetAliCDBRunRange())) continue;
 190                         if(aVersion < lastVersion) continue;
 191                         if(aVersion > lastVersion) lastSubVersion = -1;
 192                         if(aSubVersion < lastSubVersion) continue;
 193                         lastVersion = aVersion;
 194                         lastSubVersion = aSubVersion;
 195                         lastRunRange = aRunRange;
 196                 }
 197
 198                 id.SetVersion(lastVersion);
 199                 id.SetSubVersion(lastSubVersion + 1);
 200
 201         } else { // version specified, look for highest subVersion only
 202
 203                 while ((key = (TKey*) iter.Next())) { // loop on the keys
 204
 205                         const char* keyName = key->GetName();
 206
 207                         if (!KeyNameToId(keyName, aRunRange, aVersion,
 208                            aSubVersion)) {
 209                                 AliDebug(2,Form(
 210                                         "Bad keyname <%s>!I'll skip it.", keyName));
 211                                 continue;
 212                         }
 213
 214                         if (aRunRange.Overlaps(id.GetAliCDBRunRange())
 215                                 && aVersion == id.GetVersion()
 216                                 && aSubVersion > lastSubVersion) {
 217                                 lastSubVersion = aSubVersion;
 218                                 lastRunRange = aRunRange;
 219                         }
 220
 221                 }
 222
 223                 id.SetSubVersion(lastSubVersion + 1);
 224         }
 225
 226         TString lastStorage = id.GetLastStorage();
 227         if(lastStorage.Contains(TString("grid"), TString::kIgnoreCase) &&
 228            id.GetSubVersion() > 0 ){
 229                 AliError(Form("Grid to Dump Storage error! local object with version v%d_s%d found:",id.GetVersion(), id.GetSubVersion()-1));
 230                 AliError(Form("This object has been already transferred from Grid (check v%d_s0)!",id.GetVersion()));
 231                 return kFALSE;
 232         }
 233
 234         if(lastStorage.Contains(TString("new"), TString::kIgnoreCase) &&
 235            id.GetSubVersion() > 0 ){
 236                 AliWarning(Form("A NEW object is being stored with version v%d_s%d",
 237                                         id.GetVersion(),id.GetSubVersion()));
 238                 AliWarning(Form("and it will hide previously stored object with v%d_s%d!",
 239                                         id.GetVersion(),id.GetSubVersion()-1));
 240         }
 241
 242         if(!lastRunRange.IsAnyRange() && !(lastRunRange.IsEqual(& id.GetAliCDBRunRange())))
 243                 AliWarning(Form("Run range modified w.r.t. previous version (Run%d_%d_v%d_s%d)",
 244                         lastRunRange.GetFirstRun(), lastRunRange.GetLastRun(),
 245                         id.GetVersion(), id.GetSubVersion()-1));
 246
 247         return kTRUE;
 248
 249 }
 250
 251
 252 //_____________________________________________________________________________
 253 Bool_t AliCDBDump::GetId(const AliCDBId& query, AliCDBId& result) {
 254 // look for filename matching query (called by GetEntry)
 255
 256
 257         AliCDBRunRange aRunRange; // the runRange got from filename
 258         Int_t aVersion, aSubVersion; // the version and subVersion got from filename
 259
 260         TIter iter(gDirectory->GetListOfKeys());
 261         TKey* key;
 262
 263         if (!query.HasVersion()) { // neither version and subversion specified -> look for highest version and subVersion
 264
 265                 while ((key = (TKey*) iter.Next())) { // loop on the keys
 266
 267                         if (!KeyNameToId(key->GetName(), aRunRange, aVersion, aSubVersion)) continue;
 268                         // aRunRange, aVersion, aSubVersion filled from filename
 269
 270                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
 271                         // aRunRange contains requested run!
 272
 273                         if (result.GetVersion() < aVersion) {
 274                                 result.SetVersion(aVersion);
 275                                 result.SetSubVersion(aSubVersion);
 276
 277                                 result.SetFirstRun(
 278                                         aRunRange.GetFirstRun());
 279                                 result.SetLastRun(
 280                                         aRunRange.GetLastRun());
 281
 282                         } else if (result.GetVersion() == aVersion
 283                                 && result.GetSubVersion()
 284                                         < aSubVersion) {
 285
 286                                 result.SetSubVersion(aSubVersion);
 287
 288                                 result.SetFirstRun(
 289                                         aRunRange.GetFirstRun());
 290                                 result.SetLastRun(
 291                                         aRunRange.GetLastRun());
 292                         } else if (result.GetVersion() == aVersion
 293                                 && result.GetSubVersion() == aSubVersion){
 294                                 AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
 295                                         query.GetFirstRun(), aVersion, aSubVersion));
 296                                 result.SetRunRange(-1,-1); result.SetVersion(-1); result.SetSubVersion(-1);
 297                                 return kFALSE;
 298                                 }
 299                 }
 300
 301         } else if (!query.HasSubVersion()) { // version specified but not subversion -> look for highest subVersion
 302
 303                 result.SetVersion(query.GetVersion());
 304
 305                 while ((key = (TKey*) iter.Next())) { // loop on the keys
 306
 307                         if (!KeyNameToId(key->GetName(), aRunRange, aVersion, aSubVersion)) continue;
 308                         // aRunRange, aVersion, aSubVersion filled from filename
 309
 310                        if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
 311                         // aRunRange contains requested run!
 312
 313                         if(query.GetVersion() != aVersion) continue;
 314                         // aVersion is requested version!
 315
 316                         if(result.GetSubVersion() == aSubVersion){
 317                                 AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
 318                                         query.GetFirstRun(), aVersion, aSubVersion));
 319                                 result.SetRunRange(-1,-1); result.SetVersion(-1); result.SetSubVersion(-1);
 320                                 return kFALSE;
 321                         }
 322                         if( result.GetSubVersion() < aSubVersion) {
 323
 324                                 result.SetSubVersion(aSubVersion);
 325
 326                                 result.SetFirstRun(
 327                                         aRunRange.GetFirstRun());
 328                                 result.SetLastRun(
 329                                         aRunRange.GetLastRun());
 330                         }
 331                 }
 332
 333         } else { // both version and subversion specified
 334
 335                 while ((key = (TKey*) iter.Next())) { // loop on the keys
 336
 337                         if (!KeyNameToId(key->GetName(), aRunRange, aVersion, aSubVersion)) continue;
 338                         // aRunRange, aVersion, aSubVersion filled from filename
 339
 340                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
 341                         // aRunRange contains requested run!
 342
 343                         if(query.GetVersion() != aVersion || query.GetSubVersion() != aSubVersion) continue;
 344                         // aVersion and aSubVersion are requested version and subVersion!
 345
 346                         if(result.GetVersion() == aVersion && result.GetSubVersion() == aSubVersion){
 347                                 AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
 348                                         query.GetFirstRun(), aVersion, aSubVersion));
 349                                 result.SetRunRange(-1,-1); result.SetVersion(-1); result.SetSubVersion(-1);
 350                                 return kFALSE;
 351                         }
 352                         result.SetVersion(aVersion);
 353                         result.SetSubVersion(aSubVersion);
 354                         result.SetFirstRun(aRunRange.GetFirstRun());
 355                         result.SetLastRun(aRunRange.GetLastRun());
 356
 357                 }
 358         }
 359
 360         return kTRUE;
 361 }
 362
 363 //_____________________________________________________________________________
 364 AliCDBEntry* AliCDBDump::GetEntry(const AliCDBId& queryId) {
 365 // get AliCDBEntry from the database
 366
 367         TDirectory::TContext context(gDirectory, fFile);
 368
 369         if (!(fFile && fFile->IsOpen())) {
 370                 AliError("AliCDBDump storage is not initialized properly");
 371                 return NULL;
 372         }
 373
 374         if (!gDirectory->cd(queryId.GetPath())) {
 375                 return NULL;
 376         }
 377
 378         AliCDBId dataId(queryId.GetAliCDBPath(), -1, -1, -1, -1);
 379         Bool_t result;
 380
 381         // look for a filename matching query requests (path, runRange, version, subVersion)
 382         if (!queryId.HasVersion()) {
 383                 // if version is not specified, first check the selection criteria list
 384                 AliCDBId selectedId(queryId);
 385                 GetSelection(&selectedId);
 386                 result = GetId(selectedId, dataId);
 387         } else {
 388                 result = GetId(queryId, dataId);
 389         }
 390
 391         if (!result || !dataId.IsSpecified()) {
 392                 return NULL;
 393         }
 394
 395         TString keyname;
 396         if (!IdToKeyName(dataId.GetAliCDBRunRange(), dataId.GetVersion(),
 397                 dataId.GetSubVersion(), keyname)) {
 398                 AliDebug(2,Form("Bad ID encountered! Subnormal error!"));
 399                 return NULL;
 400         }
 401
 402         // get the only AliCDBEntry object from the file
 403         // the object in the file is an AliCDBEntry entry named keyname
 404         // keyName = Run#firstRun_#lastRun_v#version_s#subVersion
 405
 406         TObject* anObject = gDirectory->Get(keyname);
 407         if (!anObject) {
 408                 AliDebug(2,Form("Bad storage data: NULL entry object!"));
 409                 return NULL;
 410         }
 411
 412         if (AliCDBEntry::Class() != anObject->IsA()) {
 413                 AliDebug(2,Form("Bad storage data: Invalid entry object!"));
 414                 return NULL;
 415         }
 416
 417         ((AliCDBEntry*) anObject)->SetLastStorage("dump");
 418
 419         return (AliCDBEntry*) anObject;
 420 }
 421
 422 //_____________________________________________________________________________
 423 void AliCDBDump::GetEntriesForLevel0(const AliCDBId& queryId, TList* result) {
 424 // multiple request (AliCDBStorage::GetAll)
 425
 426         TDirectory* saveDir = gDirectory;
 427
 428         TIter iter(gDirectory->GetListOfKeys());
 429         TKey* key;
 430
 431         while ((key = (TKey*) iter.Next())) {
 432
 433                 TString keyNameStr(key->GetName());
 434                 if (queryId.GetAliCDBPath().Level1Comprises(keyNameStr)) {
 435                         gDirectory->cd(keyNameStr);
 436                         GetEntriesForLevel1(queryId, result);
 437
 438                         saveDir->cd();
 439                 }
 440         }
 441 }
 442
 443 //_____________________________________________________________________________
 444 void AliCDBDump::GetEntriesForLevel1(const AliCDBId& queryId, TList* result) {
 445 // multiple request (AliCDBStorage::GetAll)
 446
 447         TIter iter(gDirectory->GetListOfKeys());
 448         TKey* key;
 449
 450         TDirectory* level0Dir = (TDirectory*) gDirectory->GetMother();
 451
 452         while ((key = (TKey*) iter.Next())) {
 453
 454                 TString keyNameStr(key->GetName());
 455                 if (queryId.GetAliCDBPath().Level2Comprises(keyNameStr)) {
 456
 457                         AliCDBPath aPath(level0Dir->GetName(),
 458                                         gDirectory->GetName(), keyNameStr);
 459                         AliCDBId anId(aPath, queryId.GetAliCDBRunRange(),
 460                                         queryId.GetVersion(), -1);
 461
 462                         AliCDBEntry* anEntry = GetEntry(anId);
 463                         if (anEntry) {
 464                                 result->Add(anEntry);
 465                         }
 466
 467                 }
 468         }
 469
 470 }
 471
 472
 473 //_____________________________________________________________________________
 474 TList* AliCDBDump::GetEntries(const AliCDBId& queryId) {
 475 // multiple request (AliCDBStorage::GetAll)
 476
 477         TDirectory::TContext context(gDirectory, fFile);
 478
 479         if (!(fFile && fFile->IsOpen())) {
 480                 AliError("AliCDBDump storage is not initialized properly");
 481                 return NULL;
 482         }
 483
 484         TList* result = new TList();
 485         result->SetOwner();
 486
 487         TIter iter(gDirectory->GetListOfKeys());
 488         TKey* key;
 489
 490         while ((key = (TKey*) iter.Next())) {
 491
 492                 TString keyNameStr(key->GetName());
 493                 if (queryId.GetAliCDBPath().Level0Comprises(keyNameStr)) {
 494                         gDirectory->cd(keyNameStr);
 495                         GetEntriesForLevel0(queryId, result);
 496
 497                         fFile->cd();
 498                 }
 499         }
 500
 501         return result;
 502 }
 503
 504 //_____________________________________________________________________________
 505 Bool_t AliCDBDump::PutEntry(AliCDBEntry* entry) {
 506 // put an AliCDBEntry object into the database
 507
 508         TDirectory::TContext context(gDirectory, fFile);
 509
 510         if (!(fFile && fFile->IsOpen())) {
 511                 AliError("AliCDBDump storage is not initialized properly");
 512                 return kFALSE;
 513         }
 514
 515         if (fReadOnly) {
 516                 AliError("AliCDBDump storage is read only!");
 517                 return kFALSE;
 518         }
 519
 520         AliCDBId& id = entry->GetId();
 521
 522         if (!gDirectory->cd(id.GetPath())) {
 523                 if (!MkDir(id.GetPath())) {
 524                         AliError(Form("Can't open directory <%s>!",
 525                                         id.GetPath().Data()));
 526                         return kFALSE;
 527                 }
 528         }
 529
 530         // set version and subVersion for the entry to be stored
 531         if (!PrepareId(id)) {
 532                 return kFALSE;
 533         }
 534
 535         // build keyname from entry's id
 536         TString keyname;
 537         if (!IdToKeyName(id.GetAliCDBRunRange(), id.GetVersion(), id.GetSubVersion(), keyname)) {
 538                 AliError("Invalid ID encountered! Subnormal error!");
 539                 return kFALSE;
 540         }
 541
 542         // write object (key name: Run#firstRun_#lastRun_v#version_s#subVersion)
 543         Bool_t result = gDirectory->WriteTObject(entry, keyname);
 544         if (!result) {
 545                 AliError(Form("Can't write entry to file: %s",
 546                                 fFile->GetName()));
 547         }
 548
 549         if(result) {
 550                 AliInfo(Form("CDB object stored into file %s",fFile->GetName()));
 551                 AliInfo(Form("TDirectory/key name: %s/%s",id.GetPath().Data(),keyname.Data()));
 552         }
 553
 554         return result;
 555 }
 556 //_____________________________________________________________________________
 557 TList* AliCDBDump::GetIdListFromFile(const char* fileName){
 558
 559         TString turl(fileName);
 560         if (turl[0] != '/') {
 561                 turl.Prepend(TString(gSystem->WorkingDirectory()) + '/');
 562         }
 563         TFile *file = TFile::Open(turl);
 564         if (!file) {
 565                 AliError(Form("Can't open selection file <%s>!", turl.Data()));
 566                 return NULL;
 567         }
 568         file->cd();
 569
 570         TList *list = new TList();
 571         list->SetOwner();
 572         int i=0;
 573         TString keycycle;
 574
 575         AliCDBId *id;
 576         while(1){
 577                 i++;
 578                 keycycle = "AliCDBId;";
 579                 keycycle+=i;
 580
 581                 id = (AliCDBId*) file->Get(keycycle);
 582                 if(!id) break;
 583                 list->AddFirst(id);
 584         }
 585         file->Close(); delete file; file=0;
 586         return list;
 587 }
 588
 589 //_____________________________________________________________________________
 590 Bool_t AliCDBDump::Contains(const char* path) const{
 591 // check for path in storage
 592
 593         TDirectory::TContext context(gDirectory, fFile);
 594         if (!(fFile && fFile->IsOpen())) {
 595                 AliError("AliCDBDump storage is not initialized properly");
 596                 return kFALSE;
 597         }
 598
 599         return gDirectory->cd(path);
 600
 601 }
 602
 603 /////////////////////////////////////////////////////////////////////////////////////////////////
 604 //                                                                                             //
 605 // AliCDBDump factory                                                                          //
 606 //                                                                                             //
 607 /////////////////////////////////////////////////////////////////////////////////////////////////
 608
 609 ClassImp(AliCDBDumpFactory)
 610
 611 //_____________________________________________________________________________
 612 Bool_t AliCDBDumpFactory::Validate(const char* dbString) {
 613 // check if the string is valid dump URI
 614
 615         TRegexp dbPattern("^dump://.+$");
 616
 617         return TString(dbString).Contains(dbPattern);
 618 }
 619
 620 //_____________________________________________________________________________
 621 AliCDBParam* AliCDBDumpFactory::CreateParameter(const char* dbString) {
 622 // create AliCDBDumpParam class from the URI string
 623
 624         if (!Validate(dbString)) {
 625                 return NULL;
 626         }
 627
 628         TString pathname(dbString + sizeof("dump://") - 1);
 629
 630         Bool_t readOnly;
 631
 632         if (pathname.Contains(TRegexp(";ReadOnly$"))) {
 633                 pathname.Resize(pathname.Length() - sizeof(";ReadOnly") + 1);
 634                 readOnly = kTRUE;
 635         } else {
 636                 readOnly = kFALSE;
 637         }
 638
 639         gSystem->ExpandPathName(pathname);
 640
 641         if (pathname[0] != '/') {
 642                 pathname.Prepend(TString(gSystem->WorkingDirectory()) + '/');
 643         }
 644
 645         return new AliCDBDumpParam(pathname, readOnly);
 646 }
 647
 648 //_____________________________________________________________________________
 649 AliCDBStorage* AliCDBDumpFactory::Create(const AliCDBParam* param) {
 650 // create AliCDBDump storage instance from parameters
 651
 652         if (AliCDBDumpParam::Class() == param->IsA()) {
 653
 654                 const AliCDBDumpParam* dumpParam =
 655                         (const AliCDBDumpParam*) param;
 656
 657                 return new AliCDBDump(dumpParam->GetPath(),
 658                                 dumpParam->IsReadOnly());
 659         }
 660
 661         return NULL;
 662 }
 663
 664 /////////////////////////////////////////////////////////////////////////////////////////////////
 665 //                                                                                             //
 666 // AliCDBDump parameter class                                                                  //
 667 //                                                                                             //
 668 /////////////////////////////////////////////////////////////////////////////////////////////////
 669
 670 ClassImp(AliCDBDumpParam)
 671
 672 //_____________________________________________________________________________
 673 AliCDBDumpParam::AliCDBDumpParam() {
 674 // default constructor
 675
 676 }
 677
 678 //_____________________________________________________________________________
 679 AliCDBDumpParam::AliCDBDumpParam(const char* dbPath, Bool_t readOnly):
 680         fDBPath(dbPath), fReadOnly(readOnly)
 681 {
 682 // constructor
 683
 684         TString uri;
 685         uri += "dump://";
 686         uri += dbPath;
 687
 688         if (fReadOnly) {
 689                 uri += ";ReadOnly";
 690         }
 691
 692         SetURI(uri);
 693         SetType("dump");
 694 }
 695
 696 //_____________________________________________________________________________
 697 AliCDBDumpParam::~AliCDBDumpParam() {
 698 // destructor
 699
 700 }
 701
 702 //_____________________________________________________________________________
 703 AliCDBParam* AliCDBDumpParam::CloneParam() const {
 704 // clone parameter
 705
 706         return new AliCDBDumpParam(fDBPath, fReadOnly);
 707 }
 708
 709 //_____________________________________________________________________________
 710 ULong_t AliCDBDumpParam::Hash() const {
 711 // return Hash function
 712
 713         return fDBPath.Hash();
 714 }
 715
 716 //_____________________________________________________________________________
 717 Bool_t AliCDBDumpParam::IsEqual(const TObject* obj) const {
 718 // check if this object is equal to AliCDBParam obj
 719
 720         if (this == obj) {
 721                 return kTRUE;
 722         }
 723
 724         if (AliCDBDumpParam::Class() != obj->IsA()) {
 725                 return kFALSE;
 726         }
 727
 728         AliCDBDumpParam* other = (AliCDBDumpParam*) obj;
 729
 730         return fDBPath == other->fDBPath;
 731 }