Logo ROOT  
Reference Guide
TFileMerger.cxx
Go to the documentation of this file.
1// @(#)root/io:$Id$
2// Author: Andreas Peters + Fons Rademakers + Rene Brun 26/5/2005
3
4/*************************************************************************
5 * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/**
13\class TFileMerger TFileMerger.cxx
14\ingroup IO
15
16This class provides file copy and merging services.
17
18It can be used to copy files (not only ROOT files), using TFile or
19any of its remote file access plugins. It is therefore useful in
20a Grid environment where the files might be accessible only remotely.
21The merging interface allows files containing histograms and trees
22to be merged, like the standalone hadd program.
23*/
24
25#include "TFileMerger.h"
26#include "TDirectory.h"
27#include "TError.h"
28#include "TUrl.h"
29#include "TFile.h"
30#include "TUUID.h"
31#include "TSystem.h"
32#include "TKey.h"
33#include "THashList.h"
34#include "TObjString.h"
35#include "TObjArray.h"
36#include "TClass.h"
37#include "Riostream.h"
38#include "TFileMergeInfo.h"
39#include "TClassRef.h"
40#include "TROOT.h"
41#include "TMemFile.h"
42#include "TVirtualMutex.h"
43
44#ifdef WIN32
45// For _getmaxstdio
46#include <stdio.h>
47#else
48// For getrlimit
49#include <sys/time.h>
50#include <sys/resource.h>
51#endif
52
53#include <cstring>
54
56
59
60static const Int_t kCpProgress = BIT(14);
61static const Int_t kCintFileNumber = 100;
62////////////////////////////////////////////////////////////////////////////////
63/// Return the maximum number of allowed opened files minus some wiggle room
64/// for CINT or at least of the standard library (stdio).
65
67{
68 int maxfiles;
69#ifdef WIN32
70 maxfiles = _getmaxstdio();
71#else
72 rlimit filelimit;
73 if (getrlimit(RLIMIT_NOFILE,&filelimit)==0) {
74 maxfiles = filelimit.rlim_cur;
75 } else {
76 // We could not get the value from getrlimit, let's return a reasonable default.
77 maxfiles = 512;
78 }
79#endif
80 if (maxfiles > kCintFileNumber) {
81 return maxfiles - kCintFileNumber;
82 } else if (maxfiles > 5) {
83 return maxfiles - 5;
84 } else {
85 return maxfiles;
86 }
87}
88
89////////////////////////////////////////////////////////////////////////////////
90/// Create file merger object.
91
93 : fMaxOpenedFiles( R__GetSystemMaxOpenedFiles() ),
94 fLocal(isLocal), fHistoOneGo(histoOneGo)
95{
98
100 gROOT->GetListOfCleanups()->Add(this);
101}
102
103////////////////////////////////////////////////////////////////////////////////
104/// Cleanup.
105
107{
108 {
110 gROOT->GetListOfCleanups()->Remove(this);
111 }
113}
114
115////////////////////////////////////////////////////////////////////////////////
116/// Reset merger file list.
117
119{
124}
125
126////////////////////////////////////////////////////////////////////////////////
127/// Add file to file merger.
128
129Bool_t TFileMerger::AddFile(const char *url, Bool_t cpProgress)
130{
131 if (fPrintLevel > 0) {
132 Printf("%s Source file %d: %s", fMsgPrefix.Data(), fFileList.GetEntries() + fExcessFiles.GetEntries() + 1, url);
133 }
134
135 TFile *newfile = 0;
136 TString localcopy;
137
138 if (fFileList.GetEntries() >= (fMaxOpenedFiles-1)) {
139
140 TObjString *urlObj = new TObjString(url);
141 fMergeList.Add(urlObj);
142
143 urlObj = new TObjString(url);
144 urlObj->SetBit(kCpProgress);
145 fExcessFiles.Add(urlObj);
146 return kTRUE;
147 }
148
149 // We want gDirectory untouched by anything going on here
151
152 if (fLocal) {
153 TUUID uuid;
154 localcopy.Form("file:%s/ROOTMERGE-%s.root", gSystem->TempDirectory(), uuid.AsString());
155 if (!TFile::Cp(url, localcopy, cpProgress)) {
156 Error("AddFile", "cannot get a local copy of file %s", url);
157 return kFALSE;
158 }
159 newfile = TFile::Open(localcopy, "READ");
160 } else {
161 newfile = TFile::Open(url, "READ");
162 }
163
164 // Zombie files should also be skipped
165 if (newfile && newfile->IsZombie()) {
166 delete newfile;
167 newfile = 0;
168 }
169
170 if (!newfile) {
171 if (fLocal)
172 Error("AddFile", "cannot open local copy %s of URL %s",
173 localcopy.Data(), url);
174 else
175 Error("AddFile", "cannot open file %s", url);
176 return kFALSE;
177 } else {
179
180 newfile->SetBit(kCanDelete);
181 fFileList.Add(newfile);
182
183 TObjString *urlObj = new TObjString(url);
184 fMergeList.Add(urlObj);
185
186 return kTRUE;
187 }
188}
189
190////////////////////////////////////////////////////////////////////////////////
191/// Add the TFile to this file merger and *do not* give ownership of the TFile to this
192/// object.
193///
194/// Return kTRUE if the addition was successful.
195
197{
198 return AddFile(source,kFALSE,cpProgress);
199}
200
201////////////////////////////////////////////////////////////////////////////////
202/// Add the TFile to this file merger and give ownership of the TFile to this
203/// object (unless kFALSE is returned).
204///
205/// Return kTRUE if the addition was successful.
206
208{
209 return AddFile(source,kTRUE,cpProgress);
210}
211
212////////////////////////////////////////////////////////////////////////////////
213/// Add the TFile to this file merger and give ownership of the TFile to this
214/// object (unless kFALSE is returned).
215///
216/// Return kTRUE if the addition was successful.
217
219{
220 if (source == 0 || source->IsZombie()) {
221 return kFALSE;
222 }
223
224 if (fPrintLevel > 0) {
225 Printf("%s Source file %d: %s",fMsgPrefix.Data(),fFileList.GetEntries()+1,source->GetName());
226 }
227
228 TFile *newfile = 0;
229 TString localcopy;
230
231 // We want gDirectory untouched by anything going on here
233 if (fLocal && !source->InheritsFrom(TMemFile::Class())) {
234 TUUID uuid;
235 localcopy.Form("file:%s/ROOTMERGE-%s.root", gSystem->TempDirectory(), uuid.AsString());
236 if (!source->Cp(localcopy, cpProgress)) {
237 Error("AddFile", "cannot get a local copy of file %s", source->GetName());
238 return kFALSE;
239 }
240 newfile = TFile::Open(localcopy, "READ");
241 // Zombie files should also be skipped
242 if (newfile && newfile->IsZombie()) {
243 delete newfile;
244 newfile = 0;
245 }
246 } else {
247 newfile = source;
248 }
249
250 if (!newfile) {
251 if (fLocal)
252 Error("AddFile", "cannot open local copy %s of URL %s",
253 localcopy.Data(), source->GetName());
254 else
255 Error("AddFile", "cannot open file %s", source->GetName());
256 return kFALSE;
257 } else {
259
260 if (own || newfile != source) {
261 newfile->SetBit(kCanDelete);
262 } else {
263 newfile->ResetBit(kCanDelete);
264 }
265 fFileList.Add(newfile);
266
267 TObjString *urlObj = new TObjString(source->GetName());
268 fMergeList.Add(urlObj);
269
270 if (newfile != source && own) {
271 delete source;
272 }
273 return kTRUE;
274 }
275}
276
277////////////////////////////////////////////////////////////////////////////////
278/// Open merger output file.
279
280Bool_t TFileMerger::OutputFile(const char *outputfile, Bool_t force, Int_t compressionLevel)
281{
282 return OutputFile(outputfile,(force?"RECREATE":"CREATE"),compressionLevel);
283}
284
285////////////////////////////////////////////////////////////////////////////////
286/// Open merger output file.
287
288Bool_t TFileMerger::OutputFile(const char *outputfile, Bool_t force)
289{
290 Bool_t res = OutputFile(outputfile,(force?"RECREATE":"CREATE"),1); // 1 is the same as the default from the TFile constructor.
292 return res;
293}
294
295////////////////////////////////////////////////////////////////////////////////
296/// Open merger output file.
297///
298/// The 'mode' parameter is passed to the TFile constructor as the option, it
299/// should be one of 'NEW','CREATE','RECREATE','UPDATE'
300/// 'UPDATE' is usually used in conjunction with IncrementalMerge.
301
302Bool_t TFileMerger::OutputFile(const char *outputfile, const char *mode, Int_t compressionLevel)
303{
304 // We want gDirectory untouched by anything going on here
306 if (TFile *outputFile = TFile::Open(outputfile, mode, "", compressionLevel))
307 return OutputFile(std::unique_ptr<TFile>(outputFile));
308
309 Error("OutputFile", "cannot open the MERGER output file %s", fOutputFilename.Data());
310 return kFALSE;
311}
312
313////////////////////////////////////////////////////////////////////////////////
314/// Set an output file opened externally by the users
315
316Bool_t TFileMerger::OutputFile(std::unique_ptr<TFile> outputfile)
317{
318 if (!outputfile || outputfile->IsZombie()) {
319 Error("OutputFile", "cannot open the MERGER output file %s", (outputfile) ? outputfile->GetName() : "");
320 return kFALSE;
321 }
322
323 if (!outputfile->IsWritable()) {
324 Error("OutputFile", "output file %s is not writable", outputfile->GetName());
325 return kFALSE;
326 }
327
329
330 TFile *oldfile = fOutputFile;
331 fOutputFile = 0; // This avoids the complaint from RecursiveRemove about the file being deleted which is here
332 // spurrious. (see RecursiveRemove).
333 SafeDelete(oldfile);
334
335 fOutputFilename = outputfile->GetName();
336 // We want gDirectory untouched by anything going on here
338 fOutputFile = outputfile.release(); // Transfer the ownership of the file.
339
340 return kTRUE;
341}
342
343////////////////////////////////////////////////////////////////////////////////
344/// Open merger output file. 'mode' is passed to the TFile constructor as the option, it should
345/// be one of 'NEW','CREATE','RECREATE','UPDATE'
346/// 'UPDATE' is usually used in conjunction with IncrementalMerge.
347
348Bool_t TFileMerger::OutputFile(const char *outputfile, const char *mode /* = "RECREATE" */)
349{
350 Bool_t res = OutputFile(outputfile,mode,1); // 1 is the same as the default from the TFile constructor.
352 return res;
353}
354
355////////////////////////////////////////////////////////////////////////////////
356/// Print list of files being merged.
357
359{
360 fFileList.Print(options);
361 fExcessFiles.Print(options);
362}
363
364////////////////////////////////////////////////////////////////////////////////
365/// Merge the files.
366///
367/// If no output file was specified it will write into
368/// the file "FileMerger.root" in the working directory. Returns true
369/// on success, false in case of error.
370
372{
373 return PartialMerge(kAll | kRegular);
374}
375
376namespace {
377
378Bool_t IsMergeable(TClass *cl)
379{
380 return (cl->GetMerge() || cl->InheritsFrom(TDirectory::Class()) ||
381 (cl->IsTObject() && !cl->IsLoaded() &&
382 /* If it has a dictionary and GetMerge() is nullptr then we already know the answer
383 to the next question is 'no, if we were to ask we would useless trigger
384 auto-parsing */
385 (cl->GetMethodWithPrototype("Merge", "TCollection*,TFileMergeInfo*") ||
386 cl->GetMethodWithPrototype("Merge", "TCollection*"))));
387};
388
389Bool_t WriteOneAndDelete(const TString &name, TClass *cl, TObject *obj, bool canBeMerged, Bool_t ownobj, TDirectory *target)
390{
391 Bool_t status = kTRUE;
392 if (cl->InheritsFrom(TCollection::Class())) {
393 // Don't overwrite, if the object were not merged.
394 if (obj->Write(name, canBeMerged ? TObject::kSingleKey | TObject::kOverwrite : TObject::kSingleKey) <= 0) {
395 status = kFALSE;
396 }
397 ((TCollection *)obj)->SetOwner();
398 if (ownobj)
399 delete obj;
400 } else {
401 // Don't overwrite, if the object were not merged.
402 // NOTE: this is probably wrong for emulated objects.
403 if (cl->IsTObject()) {
404 if (obj->Write(name, canBeMerged ? TObject::kOverwrite : 0) <= 0) {
405 status = kFALSE;
406 }
408 } else {
409 if (target->WriteObjectAny((void *)obj, cl, name, canBeMerged ? "OverWrite" : "") <= 0) {
410 status = kFALSE;
411 }
412 }
413 if (ownobj)
414 cl->Destructor(obj); // just in case the class is not loaded.
415 }
416 return status;
417}
418
419Bool_t WriteCycleInOrder(const TString &name, TIter &nextkey, TIter &peeknextkey, TDirectory *target)
420{
421 // Recurse until we find a different name or type appear.
422 TKey *key = (TKey*)peeknextkey();
423 if (!key || name != key->GetName()) {
424 return kTRUE;
425 }
427 if (IsMergeable(cl))
428 return kTRUE;
429 // Now we can advance the real iterator
430 (void)nextkey();
431 Bool_t result = WriteCycleInOrder(name, nextkey, peeknextkey, target);
432 TObject *obj = key->ReadObj();
433
434 return WriteOneAndDelete(name, cl, obj, kFALSE, kTRUE, target) && result;
435};
436
437} // anonymous namespace
438
440 TString &oldkeyname, THashList &allNames, Bool_t &status, Bool_t &onlyListed,
441 const TString &path, TDirectory *current_sourcedir, TFile *current_file, TKey *key,
442 TObject *obj, TIter &nextkey)
443{
444 const char *keyname = obj ? obj->GetName() : key->GetName();
445 const char *keyclassname = obj ? obj->IsA()->GetName() : key->GetClassName();
446 const char *keytitle = obj ? obj->GetTitle() : key->GetTitle();
447
448 // Keep only the highest cycle number for each key for mergeable objects. They are stored
449 // in the (hash) list consecutively and in decreasing order of cycles, so we can continue
450 // until the name changes. We flag the case here and we act consequently later.
451 Bool_t alreadyseen = (oldkeyname == keyname) ? kTRUE : kFALSE;
452 Bool_t ownobj = kFALSE;
453
454 // Read in but do not copy directly the processIds.
455 if (strcmp(keyclassname, "TProcessID") == 0 && key) {
456 key->ReadObj();
457 return kTRUE;
458 }
459
460 // If we have already seen this object [name], we already processed
461 // the whole list of files for this objects and we can just skip it
462 // and any related cycles.
463 if (allNames.FindObject(keyname)) {
464 oldkeyname = keyname;
465 return kTRUE;
466 }
467
468 TClass *cl = TClass::GetClass(keyclassname);
469 if (!cl) {
470 Info("MergeRecursive", "cannot indentify object type (%s), name: %s title: %s",
471 keyclassname, keyname, keytitle);
472 return kTRUE;
473 }
474 // For mergeable objects we add the names in a local hashlist handling them
475 // again (see above)
476 if (IsMergeable(cl))
477 allNames.Add(new TObjString(keyname));
478
480 // Skip the TTree objects and any related cycles.
481 oldkeyname = keyname;
482 return kTRUE;
483 }
484 // Check if only the listed objects are to be merged
485 if (type & kOnlyListed) {
486 onlyListed = kFALSE;
487 oldkeyname = keyname;
488 oldkeyname += " ";
489 onlyListed = fObjectNames.Contains(oldkeyname);
490 oldkeyname = keyname;
491 if ((!onlyListed) && (!cl->InheritsFrom(TDirectory::Class()))) return kTRUE;
492 }
493
494 if (!(type&kResetable && type&kNonResetable)) {
495 // If neither or both are requested at the same time, we merger both types.
496 if (!(type&kResetable)) {
497 if (cl->GetResetAfterMerge()) {
498 // Skip the object with a reset after merge routine (TTree and other incrementally mergeable objects)
499 oldkeyname = keyname;
500 return kTRUE;
501 }
502 }
503 if (!(type&kNonResetable)) {
504 if (!cl->GetResetAfterMerge()) {
505 // Skip the object without a reset after merge routine (Histograms and other non incrementally mergeable objects)
506 oldkeyname = keyname;
507 return kTRUE;
508 }
509 }
510 }
511 // read object from first source file
512 if (type & kIncremental) {
513 if (!obj)
514 obj = current_sourcedir->GetList()->FindObject(keyname);
515 if (!obj && key) {
516 obj = key->ReadObj();
517 ownobj = kTRUE;
518 } else if (obj && info.fIsFirst && current_sourcedir != target
519 && !cl->InheritsFrom( TDirectory::Class() )) {
520 R__ASSERT(cl->IsTObject());
521 TDirectory::TContext ctxt(current_sourcedir);
522 obj = obj->Clone();
523 ownobj = kTRUE;
524 }
525 } else if (key) {
526 obj = key->ReadObj();
527 ownobj = kTRUE;
528 }
529 if (!obj) {
530 Info("MergeRecursive", "could not read object for key {%s, %s}",
531 keyname, keytitle);
532 return kTRUE;
533 }
534 Bool_t canBeFound = (type & kIncremental) && (current_sourcedir->GetList()->FindObject(keyname) != nullptr);
535
536 // if (cl->IsTObject())
537 // obj->ResetBit(kMustCleanup);
538 if (cl->IsTObject() && cl != obj->IsA()) {
539 Error("MergeRecursive", "TKey and object retrieve disagree on type (%s vs %s). Continuing with %s.",
540 keyclassname, obj->IsA()->GetName(), obj->IsA()->GetName());
541 cl = obj->IsA();
542 }
543 Bool_t canBeMerged = kTRUE;
544
545 TList dirtodelete;
546 auto getDirectory = [&dirtodelete](TDirectory *parent, const char *name, const TString &pathname)
547 {
548 TDirectory *result = dynamic_cast<TDirectory*>(parent->GetList()->FindObject(name));
549 if (!result)
550 result = parent->GetDirectory(pathname);
551 else
552 dirtodelete.Add(result);
553
554 return result;
555 };
556
557 if ( cl->InheritsFrom( TDirectory::Class() ) ) {
558 // it's a subdirectory
559
560 target->cd();
561 TDirectory *newdir;
562
563 // For incremental or already seen we may have already a directory created
564 if (type & kIncremental || alreadyseen) {
565 newdir = target->GetDirectory(obj->GetName());
566 if (!newdir) {
567 newdir = target->mkdir( obj->GetName(), obj->GetTitle() );
568 // newdir->ResetBit(kMustCleanup);
569 }
570 } else {
571 newdir = target->mkdir( obj->GetName(), obj->GetTitle() );
572 // newdir->ResetBit(kMustCleanup);
573 }
574
575 // newdir is now the starting point of another round of merging
576 // newdir still knows its depth within the target file via
577 // GetPath(), so we can still figure out where we are in the recursion
578
579 // If this folder is a onlyListed object, merge everything inside.
580 if (onlyListed) type &= ~kOnlyListed;
581 status = MergeRecursive(newdir, sourcelist, type);
582 if (onlyListed) type |= kOnlyListed;
583 if (!status) return kFALSE;
584 } else if (!cl->IsTObject() && cl->GetMerge()) {
585 // merge objects that don't derive from TObject
586 TFile *nextsource = current_file ? (TFile*)sourcelist->After( current_file ) : (TFile*)sourcelist->First();
587 Error("MergeRecursive", "Merging objects that don't inherit from TObject is unimplemented (key: %s of type %s in file %s)",
588 keyname, keyclassname, nextsource->GetName());
589 canBeMerged = kFALSE;
590 } else if (cl->IsTObject() && cl->GetMerge()) {
591 // Check if already treated
592 if (alreadyseen) return kTRUE;
593
594 TList inputs;
595 TList todelete;
597
598 // Loop over all source files and merge same-name object
599 TFile *nextsource = current_file ? (TFile*)sourcelist->After( current_file ) : (TFile*)sourcelist->First();
600 if (nextsource == 0) {
601 // There is only one file in the list
602 ROOT::MergeFunc_t func = cl->GetMerge();
603 func(obj, &inputs, &info);
604 info.fIsFirst = kFALSE;
605 } else {
606 do {
607 // make sure we are at the correct directory level by cd'ing to path
608 TDirectory *ndir = getDirectory(nextsource, target->GetName(), path);
609 if (ndir) {
610 // For consistency (and persformance), we reset the MustCleanup be also for those
611 // 'key' retrieved indirectly.
612 // ndir->ResetBit(kMustCleanup);
613 ndir->cd();
614 TObject *hobj = ndir->GetList()->FindObject(keyname);
615 if (!hobj) {
616 TKey *key2 = (TKey*)ndir->GetListOfKeys()->FindObject(keyname);
617 if (key2) {
618 hobj = key2->ReadObj();
619 if (!hobj) {
620 Info("MergeRecursive", "could not read object for key {%s, %s}; skipping file %s",
621 keyname, keytitle, nextsource->GetName());
622 nextsource = (TFile*)sourcelist->After(nextsource);
623 return kTRUE;
624 }
625 todelete.Add(hobj);
626 }
627 }
628 if (hobj) {
629 // Set ownership for collections
630 if (hobj->InheritsFrom(TCollection::Class())) {
631 ((TCollection*)hobj)->SetOwner();
632 }
633 hobj->ResetBit(kMustCleanup);
634 inputs.Add(hobj);
635 if (!oneGo) {
636 ROOT::MergeFunc_t func = cl->GetMerge();
637 Long64_t result = func(obj, &inputs, &info);
638 info.fIsFirst = kFALSE;
639 if (result < 0) {
640 Error("MergeRecursive", "calling Merge() on '%s' with the corresponding object in '%s'",
641 keyname, nextsource->GetName());
642 }
643 inputs.Clear();
644 todelete.Delete();
645 }
646 }
647 }
648 nextsource = (TFile*)sourcelist->After( nextsource );
649 } while (nextsource);
650 // Merge the list, if still to be done
651 if (oneGo || info.fIsFirst) {
652 ROOT::MergeFunc_t func = cl->GetMerge();
653 func(obj, &inputs, &info);
654 info.fIsFirst = kFALSE;
655 inputs.Clear();
656 todelete.Delete();
657 }
658 }
659 } else if (cl->IsTObject()) {
660 // try synthesizing the Merge method call according to the TObject
661 TList listH;
662 TString listHargs;
663 if (cl->GetMethodWithPrototype("Merge", "TCollection*,TFileMergeInfo*")) {
664 listHargs.Form("(TCollection*)0x%lx,(TFileMergeInfo*)0x%lx",
665 (ULong_t)&listH, (ULong_t)&info);
666 } else if (cl->GetMethodWithPrototype("Merge", "TCollection*")) {
667 listHargs.Form("((TCollection*)0x%lx)", (ULong_t)&listH);
668 } else {
669 // pass unmergeable objects through to the output file
670 canBeMerged = kFALSE;
671 }
672 if (canBeMerged) {
673 if (alreadyseen) {
674 // skip already seen mergeable objects, don't skip unmergeable objects
675 return kTRUE;
676 }
677 // Loop over all source files and merge same-name object
678 TFile *nextsource = current_file ? (TFile*)sourcelist->After( current_file ) : (TFile*)sourcelist->First();
679 if (nextsource == 0) {
680 // There is only one file in the list
681 Int_t error = 0;
682 obj->Execute("Merge", listHargs.Data(), &error);
683 info.fIsFirst = kFALSE;
684 if (error) {
685 Error("MergeRecursive", "calling Merge() on '%s' with the corresponding object in '%s'",
686 obj->GetName(), keyname);
687 }
688 } else {
689 while (nextsource) {
690 // make sure we are at the correct directory level by cd'ing to path
691 TDirectory *ndir = getDirectory(nextsource, target->GetName(), path);
692 if (ndir) {
693 ndir->cd();
694 TKey *key2 = (TKey*)ndir->GetListOfKeys()->FindObject(keyname);
695 if (key2) {
696 TObject *hobj = key2->ReadObj();
697 if (!hobj) {
698 Info("MergeRecursive", "could not read object for key {%s, %s}; skipping file %s",
699 keyname, keytitle, nextsource->GetName());
700 nextsource = (TFile*)sourcelist->After(nextsource);
701 return kTRUE;
702 }
703 // Set ownership for collections
704 if (hobj->InheritsFrom(TCollection::Class())) {
705 ((TCollection*)hobj)->SetOwner();
706 }
707 hobj->ResetBit(kMustCleanup);
708 listH.Add(hobj);
709 Int_t error = 0;
710 obj->Execute("Merge", listHargs.Data(), &error);
711 info.fIsFirst = kFALSE;
712 if (error) {
713 Error("MergeRecursive", "calling Merge() on '%s' with the corresponding object in '%s'",
714 obj->GetName(), nextsource->GetName());
715 }
716 listH.Delete();
717 }
718 }
719 nextsource = (TFile*)sourcelist->After( nextsource );
720 }
721 // Merge the list, if still to be done
722 if (info.fIsFirst) {
723 Int_t error = 0;
724 obj->Execute("Merge", listHargs.Data(), &error);
725 info.fIsFirst = kFALSE;
726 listH.Delete();
727 }
728 }
729 }
730 } else {
731 // Object is of no type that we can merge
732 canBeMerged = kFALSE;
733 }
734
735 // now write the merged histogram (which is "in" obj) to the target file
736 // note that this will just store obj in the current directory level,
737 // which is not persistent until the complete directory itself is stored
738 // by "target->SaveSelf()" below
739 target->cd();
740
741 oldkeyname = keyname;
742 //!!if the object is a tree, it is stored in globChain...
743 if (cl->InheritsFrom(TDirectory::Class())) {
744 // printf("cas d'une directory\n");
745
746 auto dirobj = dynamic_cast<TDirectory *>(obj);
747 TString dirpath(dirobj->GetPath());
748 // coverity[unchecked_value] 'target' is from a file so GetPath always returns path starting with filename:
749 dirpath.Remove(0, std::strlen(dirobj->GetFile()->GetPath()));
750
751 // Do not delete the directory if it is part of the output
752 // and we are in incremental mode (because it will be reused
753 // and has not been written to disk (for performance reason).
754 // coverity[var_deref_model] the IsA()->InheritsFrom guarantees that the dynamic_cast will succeed.
755 if (ownobj && (!(type & kIncremental) || dirobj->GetFile() != target)) {
756 dirobj->ResetBit(kMustCleanup);
757 delete dirobj;
758 }
759 // Let's also delete the directory from the other source (thanks to the 'allNames'
760 // mechanism above we will not process the directories when tranversing the next
761 // files).
762 TIter deliter(&dirtodelete);
763 while(TObject *ndir = deliter()) {
764 // For consistency (and performance), we reset the MustCleanup be also for those
765 // 'key' retrieved indirectly.
766 ndir->ResetBit(kMustCleanup);
767 delete ndir;
768 }
769 } else if (!canBeFound) { // Don't write the partial result for TTree and TH1
770
771 if (!canBeMerged) {
772 TIter peeknextkey(nextkey);
773 status = WriteCycleInOrder(oldkeyname, nextkey, peeknextkey, target) && status;
774 status = WriteOneAndDelete(oldkeyname, cl, obj, kFALSE, ownobj, target) && status;
775 } else {
776 status = WriteOneAndDelete(oldkeyname, cl, obj, kTRUE, ownobj, target) && status;
777 }
778 }
779 info.Reset();
780
781 return kTRUE;
782}
783
784////////////////////////////////////////////////////////////////////////////////
785/// Merge all objects in a directory
786///
787/// The type is defined by the bit values in TFileMerger::EPartialMergeType.
788
789Bool_t TFileMerger::MergeRecursive(TDirectory *target, TList *sourcelist, Int_t type /* = kRegular | kAll */)
790{
791 Bool_t status = kTRUE;
792 Bool_t onlyListed = kFALSE;
793 if (fPrintLevel > 0) {
794 Printf("%s Target path: %s",fMsgPrefix.Data(),target->GetPath());
795 }
796
797 // Get the dir name
798 TString path(target->GetPath());
799 // coverity[unchecked_value] 'target' is from a file so GetPath always returns path starting with filename:
800 path.Remove(0, std::strlen(target->GetFile()->GetPath()));
801
802 Int_t nguess = sourcelist->GetSize()+1000;
803 THashList allNames(nguess);
804 allNames.SetOwner(kTRUE);
805 // If the mode is set to skipping list objects, add names to the allNames list
806 if (type & kSkipListed) {
807 TObjArray *arr = fObjectNames.Tokenize(" ");
808 arr->SetOwner(kFALSE);
809 for (Int_t iname=0; iname<arr->GetEntriesFast(); iname++)
810 allNames.Add(arr->At(iname));
811 delete arr;
812 }
813 ((THashList*)target->GetList())->Rehash(nguess);
814 ((THashList*)target->GetListOfKeys())->Rehash(nguess);
815
816 TFileMergeInfo info(target);
818 info.fOptions = fMergeOptions;
820 info.fOptions.Append(" fast");
821 }
822
823 TFile *current_file;
824 TDirectory *current_sourcedir;
825 if (type & kIncremental) {
826 current_file = 0;
827 current_sourcedir = target;
828 } else {
829 current_file = (TFile*)sourcelist->First();
830 current_sourcedir = current_file->GetDirectory(path);
831 }
832 while (current_file || current_sourcedir) {
833 // When current_sourcedir != 0 and current_file == 0 we are going over the target
834 // for an incremental merge.
835 if (current_sourcedir && (current_file == 0 || current_sourcedir != target)) {
836 TString oldkeyname;
837
838 // Loop over live objects
839 TIter nextobj( current_sourcedir->GetList() );
840 TObject *obj;
841 while ( (obj = (TKey*)nextobj())) {
842 auto result = MergeOne(target, sourcelist, type,
843 info, oldkeyname, allNames, status, onlyListed, path,
844 current_sourcedir, current_file,
845 nullptr, obj, nextobj);
846 if (!result)
847 return kFALSE; // Stop completely in case of error.
848 } // while ( (obj = (TKey*)nextobj()))
849
850 // loop over all keys in this directory
851 TIter nextkey( current_sourcedir->GetListOfKeys() );
852 TKey *key;
853
854 while ( (key = (TKey*)nextkey())) {
855 auto result = MergeOne(target, sourcelist, type,
856 info, oldkeyname, allNames, status, onlyListed, path,
857 current_sourcedir, current_file,
858 key, nullptr, nextkey);
859 if (!result)
860 return kFALSE; // Stop completely in case of error.
861 } // while ( ( TKey *key = (TKey*)nextkey() ) )
862 }
863 current_file = current_file ? (TFile*)sourcelist->After(current_file) : (TFile*)sourcelist->First();
864 if (current_file) {
865 current_sourcedir = current_file->GetDirectory(path);
866 } else {
867 current_sourcedir = 0;
868 }
869 }
870 // save modifications to the target directory.
871 if (!(type&kIncremental)) {
872 // In case of incremental build, we will call Write on the top directory/file, so we do not need
873 // to call SaveSelf explicilty.
874 target->SaveSelf(kTRUE);
875 }
876
877 return status;
878}
879
880////////////////////////////////////////////////////////////////////////////////
881/// Merge the files. If no output file was specified it will write into
882/// the file "FileMerger.root" in the working directory. Returns true
883/// on success, false in case of error.
884/// The type is defined by the bit values in EPartialMergeType:
885/// kRegular : normal merge, overwritting the output file
886/// kIncremental : merge the input file with the content of the output file (if already exising) (default)
887/// kAll : merge all type of objects (default)
888/// kResetable : merge only the objects with a MergeAfterReset member function.
889/// kNonResetable : merge only the objects without a MergeAfterReset member function.
890///
891/// If the type is set to kIncremental the output file is done deleted at the end of
892/// this operation. If the type is not set to kIncremental, the output file is closed.
893
895{
896 if (!fOutputFile) {
898 if (outf.IsNull()) {
899 outf.Form("file:%s/FileMerger.root", gSystem->TempDirectory());
900 Info("PartialMerge", "will merge the results to the file %s\n"
901 "since you didn't specify a merge filename",
902 TUrl(outf).GetFile());
903 }
904 if (!OutputFile(outf.Data())) {
905 return kFALSE;
906 }
907 }
908
909 // Special treament for the single file case ...
910 if ((fFileList.GetEntries() == 1) && !fExcessFiles.GetEntries() &&
914
915 TFile *file = (TFile *) fFileList.First();
916 if (!file || (file && file->IsZombie())) {
917 Error("PartialMerge", "one-file case: problem attaching to file");
918 return kFALSE;
919 }
920 Bool_t result = kTRUE;
921 if (!(result = file->Cp(fOutputFilename))) {
922 Error("PartialMerge", "one-file case: could not copy '%s' to '%s'",
923 file->GetPath(), fOutputFilename.Data());
924 return kFALSE;
925 }
926 if (file->TestBit(kCanDelete)) file->Close();
927
928 // Remove the temporary file
929 if (fLocal && !file->InheritsFrom(TMemFile::Class())) {
930 TUrl u(file->GetPath(), kTRUE);
931 if (gSystem->Unlink(u.GetFile()) != 0)
932 Warning("PartialMerge", "problems removing temporary local file '%s'", u.GetFile());
933 }
935 return result;
936 }
937
939
941
942 Bool_t result = kTRUE;
943 Int_t type = in_type;
944 while (result && fFileList.GetEntries()>0) {
946
947 // Remove local copies if there are any
948 TIter next(&fFileList);
949 TFile *file;
950 while ((file = (TFile*) next())) {
951 // close the files
952 if (file->TestBit(kCanDelete)) file->Close();
953 // remove the temporary files
954 if(fLocal && !file->InheritsFrom(TMemFile::Class())) {
955 TString p(file->GetPath());
956 // coverity[unchecked_value] Index is return a value with range or NPos to select the whole name.
957 p = p(0, p.Index(':',0));
958 gSystem->Unlink(p);
959 }
960 }
962 if (result && fExcessFiles.GetEntries() > 0) {
963 // We merge the first set of files in the output,
964 // we now need to open the next set and make
965 // sure we accumulate into the output, so we
966 // switch to incremental merging (if not already set)
968 result = OpenExcessFiles();
969 }
970 }
971 if (!result) {
972 Error("Merge", "error during merge of your ROOT files");
973 } else {
974 // Close or write is required so the file is complete.
975 if (in_type & kIncremental) {
976 // In the case of 'kDelayWrite' the caller want to avoid having to
977 // write the output objects once for every input file and instead
978 // write it only once at the end of the process.
979 if (!(in_type & kDelayWrite))
981 } else {
982 // If in_type is not incremental but type is incremental we are now in
983 // the case where the user "explicitly" request a non-incremental merge
984 // but we still have internally an incremental merge. Because the user
985 // did not request the incremental merge they also probably do not to a
986 // final Write of the file and thus not doing the write here would lead
987 // to data loss ...
988 if (type & kIncremental)
990 gROOT->GetListOfFiles()->Remove(fOutputFile);
992 }
993 }
994
995 // Cleanup
996 if (in_type & kIncremental) {
997 Clear();
998 } else {
1001 }
1002 return result;
1003}
1004
1005////////////////////////////////////////////////////////////////////////////////
1006/// Open up to fMaxOpenedFiles of the excess files.
1007
1009{
1010 if (fPrintLevel > 0) {
1011 Printf("%s Opening the next %d files", fMsgPrefix.Data(), TMath::Min(fExcessFiles.GetEntries(), fMaxOpenedFiles - 1));
1012 }
1013 Int_t nfiles = 0;
1014 TIter next(&fExcessFiles);
1015 TObjString *url = 0;
1016 TString localcopy;
1017 // We want gDirectory untouched by anything going on here
1019 while( nfiles < (fMaxOpenedFiles-1) && ( url = (TObjString*)next() ) ) {
1020 TFile *newfile = 0;
1021 if (fLocal) {
1022 TUUID uuid;
1023 localcopy.Form("file:%s/ROOTMERGE-%s.root", gSystem->TempDirectory(), uuid.AsString());
1024 if (!TFile::Cp(url->GetName(), localcopy, url->TestBit(kCpProgress))) {
1025 Error("OpenExcessFiles", "cannot get a local copy of file %s", url->GetName());
1026 return kFALSE;
1027 }
1028 newfile = TFile::Open(localcopy, "READ");
1029 } else {
1030 newfile = TFile::Open(url->GetName(), "READ");
1031 }
1032
1033 if (!newfile) {
1034 if (fLocal)
1035 Error("OpenExcessFiles", "cannot open local copy %s of URL %s",
1036 localcopy.Data(), url->GetName());
1037 else
1038 Error("OpenExcessFiles", "cannot open file %s", url->GetName());
1039 return kFALSE;
1040 } else {
1042
1043 newfile->SetBit(kCanDelete);
1044 fFileList.Add(newfile);
1045 ++nfiles;
1046 fExcessFiles.Remove(url);
1047 }
1048 }
1049 return kTRUE;
1050}
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// Intercept the case where the output TFile is deleted!
1054
1056{
1057 if (obj == fOutputFile) {
1058 Fatal("RecursiveRemove","Output file of the TFile Merger (targeting %s) has been deleted (likely due to a TTree larger than 100Gb)", fOutputFilename.Data());
1059 }
1060
1061}
1062
1063////////////////////////////////////////////////////////////////////////////////
1064/// Set a limit to the number of files that TFileMerger will open simultaneously.
1065///
1066/// If the request is higher than the system limit, we reset it to the system limit.
1067/// If the request is less than two, we reset it to 2 (one for the output file and one for the input file).
1068
1070{
1072 if (newmax < sysmax) {
1073 fMaxOpenedFiles = newmax;
1074 } else {
1075 fMaxOpenedFiles = sysmax;
1076 }
1077 if (fMaxOpenedFiles < 2) {
1078 fMaxOpenedFiles = 2;
1079 }
1080}
1081
1082////////////////////////////////////////////////////////////////////////////////
1083/// Set the prefix to be used when printing informational message.
1084
1085void TFileMerger::SetMsgPrefix(const char *prefix)
1086{
1087 fMsgPrefix = prefix;
1088}
1089
void Class()
Definition: Class.C:29
#define SafeDelete(p)
Definition: RConfig.hxx:543
int Int_t
Definition: RtypesCore.h:43
const Bool_t kFALSE
Definition: RtypesCore.h:90
unsigned long ULong_t
Definition: RtypesCore.h:53
bool Bool_t
Definition: RtypesCore.h:61
long long Long64_t
Definition: RtypesCore.h:71
const Bool_t kTRUE
Definition: RtypesCore.h:89
const char Option_t
Definition: RtypesCore.h:64
#define BIT(n)
Definition: Rtypes.h:83
#define ClassImp(name)
Definition: Rtypes.h:361
#define R__ASSERT(e)
Definition: TError.h:96
TClassRef R__TH1_Class("TH1")
static Int_t R__GetSystemMaxOpenedFiles()
Return the maximum number of allowed opened files minus some wiggle room for CINT or at least of the ...
Definition: TFileMerger.cxx:66
TClassRef R__TTree_Class("TTree")
static const Int_t kCpProgress
Definition: TFileMerger.cxx:60
static const Int_t kCintFileNumber
Definition: TFileMerger.cxx:61
char name[80]
Definition: TGX11.cxx:109
int type
Definition: TGX11.cxx:120
@ kMustCleanup
Definition: TObject.h:355
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:59
#define gROOT
Definition: TROOT.h:406
void Printf(const char *fmt,...)
typedef void((*Func_t)())
R__EXTERN TSystem * gSystem
Definition: TSystem.h:556
#define R__LOCKGUARD(mutex)
TClassRef is used to implement a permanent reference to a TClass object.
Definition: TClassRef.h:28
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TMethod * GetMethodWithPrototype(const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
Definition: TClass.cxx:4426
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition: TClass.cxx:5370
ROOT::ResetAfterMergeFunc_t GetResetAfterMerge() const
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition: TClass.cxx:5882
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition: TClass.cxx:5908
ROOT::MergeFunc_t GetMerge() const
Bool_t InheritsFrom(const char *cl) const
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4844
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2937
Collection abstract base class.
Definition: TCollection.h:63
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
virtual Int_t GetEntries() const
Definition: TCollection.h:177
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TDirectory * GetDirectory(const char *apath, Bool_t printError=false, const char *funcname="GetDirectory") override
Find a directory named "apath".
Small helper to keep current directory context.
Definition: TDirectory.h:47
Describe directory structure in memory.
Definition: TDirectory.h:40
virtual TList * GetList() const
Definition: TDirectory.h:165
virtual TDirectory * GetDirectory(const char *namecycle, Bool_t printError=false, const char *funcname="GetDirectory")
Find a directory using apath.
Definition: TDirectory.cxx:401
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:988
virtual Int_t WriteObjectAny(const void *, const char *, const char *, Option_t *="", Int_t=0)
Definition: TDirectory.h:216
virtual TFile * GetFile() const
Definition: TDirectory.h:163
virtual void SaveSelf(Bool_t=kFALSE)
Definition: TDirectory.h:197
virtual TDirectory * mkdir(const char *name, const char *title="", Bool_t returnExistingDirectory=kFALSE)
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
virtual TList * GetListOfKeys() const
Definition: TDirectory.h:166
virtual Bool_t cd(const char *path=nullptr)
Change current directory to "this" directory.
Definition: TDirectory.cxx:498
TIOFeatures * fIOFeatures
This class provides file copy and merging services.
Definition: TFileMerger.h:32
TString fObjectNames
List of object names to be either merged exclusively or skipped.
Definition: TFileMerger.h:56
virtual Bool_t OutputFile(const char *url, Bool_t force)
Open merger output file.
TList fMergeList
list of TObjString containing the name of the files need to be merged
Definition: TFileMerger.h:57
virtual Bool_t AddFile(TFile *source, Bool_t own, Bool_t cpProgress)
Add the TFile to this file merger and give ownership of the TFile to this object (unless kFALSE is re...
virtual void PrintFiles(Option_t *options)
Print list of files being merged.
Bool_t fHistoOneGo
Merger histos in one go (default is kTRUE)
Definition: TFileMerger.h:55
virtual Bool_t MergeRecursive(TDirectory *target, TList *sourcelist, Int_t type=kRegular|kAll)
Merge all objects in a directory.
TList fFileList
A list the file (TFile*) which shall be merged.
Definition: TFileMerger.h:41
virtual Bool_t Merge(Bool_t=kTRUE)
Merge the files.
virtual Bool_t MergeOne(TDirectory *target, TList *sourcelist, Int_t type, TFileMergeInfo &info, TString &oldkeyname, THashList &allNames, Bool_t &status, Bool_t &onlyListed, const TString &path, TDirectory *current_sourcedir, TFile *current_file, TKey *key, TObject *obj, TIter &nextkey)
TString fOutputFilename
The name of the outputfile for merging.
Definition: TFileMerger.h:43
virtual void RecursiveRemove(TObject *obj)
Intercept the case where the output TFile is deleted!
TString fMsgPrefix
Prefix to be used when printing informational message (default TFileMerger)
Definition: TFileMerger.h:51
TIOFeatures * fIOFeatures
IO features to use in the output file.
Definition: TFileMerger.h:50
TFileMerger(const TFileMerger &)=delete
void SetMsgPrefix(const char *prefix)
Set the prefix to be used when printing informational message.
Bool_t fNoTrees
True if Trees should not be merged (default is kFALSE)
Definition: TFileMerger.h:45
@ kAll
Merge all type of objects (default)
Definition: TFileMerger.h:78
@ kIncremental
Merge the input file with the content of the output file (if already exising).
Definition: TFileMerger.h:73
@ kKeepCompression
Keep compression level unchanged for each input files.
Definition: TFileMerger.h:83
@ kSkipListed
Skip objects specified in fObjectNames list.
Definition: TFileMerger.h:82
@ kNonResetable
Only the objects without a MergeAfterReset member function.
Definition: TFileMerger.h:75
@ kResetable
Only the objects with a MergeAfterReset member function.
Definition: TFileMerger.h:74
@ kOnlyListed
Only the objects specified in fObjectNames list.
Definition: TFileMerger.h:81
@ kRegular
Normal merge, overwritting the output file.
Definition: TFileMerger.h:72
@ kDelayWrite
Delay the TFile write (to reduce the number of write when reusing the file)
Definition: TFileMerger.h:76
Bool_t fExplicitCompLevel
True if the user explicitly requested a compressio level change (default kFALSE)
Definition: TFileMerger.h:46
Bool_t fCompressionChange
True if the output and input have different compression level (default kFALSE)
Definition: TFileMerger.h:47
virtual ~TFileMerger()
Cleanup.
Int_t fPrintLevel
How much information to print out at run time.
Definition: TFileMerger.h:48
void SetMaxOpenedFiles(Int_t newmax)
Set a limit to the number of files that TFileMerger will open simultaneously.
TString fMergeOptions
Options (in string format) to be passed down to the Merge functions.
Definition: TFileMerger.h:49
Bool_t OpenExcessFiles()
Open up to fMaxOpenedFiles of the excess files.
TList fExcessFiles
! List of TObjString containing the name of the files not yet added to fFileList due to user or syste...
Definition: TFileMerger.h:58
TFile * fOutputFile
The outputfile for merging.
Definition: TFileMerger.h:42
virtual Bool_t PartialMerge(Int_t type=kAll|kIncremental)
Merge the files.
Bool_t fLocal
Makes local copies of merging files if True (default is kTRUE)
Definition: TFileMerger.h:54
virtual void Reset()
Reset merger file list.
Int_t fMaxOpenedFiles
Maximum number of files opened at the same time by the TFileMerger.
Definition: TFileMerger.h:53
virtual Bool_t AddAdoptFile(TFile *source, Bool_t cpProgress=kTRUE)
Add the TFile to this file merger and give ownership of the TFile to this object (unless kFALSE is re...
Bool_t fFastMethod
True if using Fast merging algorithm (default)
Definition: TFileMerger.h:44
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:53
Int_t GetCompressionSettings() const
Definition: TFile.h:398
Int_t GetCompressionLevel() const
Definition: TFile.h:392
virtual Bool_t Cp(const char *dst, Bool_t progressbar=kTRUE, UInt_t buffersize=1000000)
Allows to copy this file to the dst URL.
Definition: TFile.cxx:4839
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition: TFile.cxx:3942
Int_t Write(const char *name=nullptr, Int_t opt=0, Int_t bufsiz=0) override
Write memory objects to this file.
Definition: TFile.cxx:2297
void Close(Option_t *option="") override
Close a file.
Definition: TFile.cxx:873
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:34
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition: TKey.h:28
virtual const char * GetClassName() const
Definition: TKey.h:76
virtual const char * GetTitle() const
Returns title (title can contain 32x32 xpm thumbnail/icon).
Definition: TKey.cxx:1520
virtual TObject * ReadObj()
To read a TObject* from the file.
Definition: TKey.cxx:738
A doubly linked list.
Definition: TList.h:44
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObject * After(const TObject *obj) const
Returns the object after object obj.
Definition: TList.cxx:329
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:821
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:577
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:469
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:658
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:401
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
An array of TObjects.
Definition: TObjArray.h:37
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Collectable string class.
Definition: TObjString.h:28
const char * GetName() const
Returns name of object.
Definition: TObjString.h:38
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void Clear(Option_t *="")
Definition: TObject.h:115
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition: TObject.cxx:796
@ kOverwrite
overwrite existing object with same name
Definition: TObject.h:88
@ kSingleKey
write collection with single key
Definition: TObject.h:87
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:357
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TObject.cxx:144
virtual void Execute(const char *method, const char *params, Int_t *error=0)
Execute method on this object with the given parameter string, e.g.
Definition: TObject.cxx:277
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:877
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition: TObject.h:149
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:443
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:891
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:919
virtual const char * GetTitle() const
Returns title of object.
Definition: TObject.cxx:401
void ResetBit(UInt_t f)
Definition: TObject.h:186
@ kCanDelete
if object in a list can be deleted
Definition: TObject.h:58
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition: TObject.h:60
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:865
Basic string class.
Definition: TString.h:131
void Clear()
Clear string without changing its capacity.
Definition: TString.cxx:1176
const char * Data() const
Definition: TString.h:364
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition: TString.cxx:2197
Bool_t IsNull() const
Definition: TString.h:402
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
TString & Append(const char *cs)
Definition: TString.h:559
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:634
virtual int Unlink(const char *name)
Unlink, i.e.
Definition: TSystem.cxx:1376
virtual const char * TempDirectory() const
Return a user configured or systemwide directory to create temporary files in.
Definition: TSystem.cxx:1477
This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDent...
Definition: TUUID.h:42
const char * AsString() const
Return UUID as string. Copy string immediately since it will be reused.
Definition: TUUID.cxx:562
This class represents a WWW compatible URL.
Definition: TUrl.h:35
const char * GetFile() const
Definition: TUrl.h:71
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:112
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180
Definition: file.py:1