Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TDirectoryFile.cxx
Go to the documentation of this file.
1// @(#)root/io:$Id$
2// Author: Rene Brun 22/01/2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, 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 TDirectoryFile
14 \ingroup IO
15
16 A ROOT file is structured in Directories (like a file system).
17 Each Directory has a list of Keys (see TKeys) and a list of objects
18 in memory. A Key is a small object that describes the type and location
19 of a persistent object in a file. The persistent object may be a directory.
20Begin_Macro
21../../../tutorials/io/fildir.C
22End_Macro
23 The structure of a file is shown in TFile::TFile
24*/
25
26#include <iostream>
27#include "Strlen.h"
28#include "strlcpy.h"
29#include "TDirectoryFile.h"
30#include "TFile.h"
31#include "TBufferFile.h"
32#include "TBufferJSON.h"
33#include "TMapFile.h"
34#include "TClassTable.h"
35#include "TInterpreter.h"
36#include "THashList.h"
37#include "TBrowser.h"
38#include "TFree.h"
39#include "TKey.h"
40#include "TStreamerInfo.h"
41#include "TROOT.h"
42#include "TError.h"
43#include "Bytes.h"
44#include "TClass.h"
45#include "TRegexp.h"
46#include "TSystem.h"
47#include "TStreamerElement.h"
48#include "TProcessUUID.h"
49#include "TVirtualMutex.h"
52const UInt_t kIsBigFile = BIT(16);
53const Int_t kMaxLen = 2048;
54
56
57
58////////////////////////////////////////////////////////////////////////////////
59/// Default TDirectoryFile constructor
62{
63 /// Intentionally placed here
64 /// when TDirectoryFile() = default; used, mac1014/cxx17 fails on some tests
65 /// Problem with TObject::IsOnHeap() failing
66}
67
68
69////////////////////////////////////////////////////////////////////////////////
70/// Create a new TDirectoryFile
71///
72/// A new directory with a name and a title is created in the current directory.
73/// The directory header information is immediately saved on the file
74/// A new key is added in the parent directory.
75/// When this constructor is called from a class directly derived
76/// from TDirectoryFile, the third argument, classname, MUST be specified.
77/// In this case, classname must be the name of the derived class.
78///
79/// Note that the directory name cannot contain slashes.
81TDirectoryFile::TDirectoryFile(const char *name, const char *title, Option_t *classname, TDirectory* initMotherDir)
82{
83 // We must not publish this objects to the list of RecursiveRemove (indirectly done
84 // by 'Appending' this object to it's mother) before the object is completely
85 // initialized.
86 // However a better option would be to delay the publishing until the very end,
87 // but it is currently done in the middle of the initialization (by Build which
88 // is a public interface) ....
90
91 fName = name;
92 fTitle = title;
93
95
96 if (strchr(name,'/')) {
97 ::Error("TDirectoryFile","directory name (%s) cannot contain a slash", name);
98 gDirectory = nullptr;
99 return;
100 }
101 if (strlen(GetName()) == 0) {
102 ::Error("TDirectoryFile","directory name cannot be \"\"");
103 gDirectory = nullptr;
104 return;
105 }
106
108
111
112 if (!motherdir || !f) return;
113 if (!f->IsWritable()) return; //*-* in case of a directory in memory
114 if (motherdir->GetKey(name)) {
115 Error("TDirectoryFile","An object with name %s exists already", name);
116 return;
117 }
118 TClass *cl = nullptr;
119 if (classname[0]) {
120 cl = TClass::GetClass(classname);
121 if (!cl) {
122 Error("TDirectoryFile","Invalid class name: %s",classname);
123 return;
124 }
125 } else {
126 cl = TDirectoryFile::IsA();
127 }
128
129 fBufferSize = 0;
131
133
135
136 // Temporarily redundant, see comment on lock early in the function.
137 // R__LOCKGUARD(gROOTMutex);
138 gROOT->GetUUIDs()->AddUUID(fUUID,this);
139 // We should really be doing this now rather than in Build, see
140 // comment at the start of the function.
141 // if (initMotherDir && strlen(GetName()) != 0) initMotherDir->Append(this);
142}
143
144////////////////////////////////////////////////////////////////////////////////
145/// Initialize the key associated with this directory (and the related
146/// data members.
149{
150 TFile* f = GetFile(); // NOLINT: silence clang-tidy warnings
151 if (f->IsBinary()) {
152 if (!cl) {
153 cl = IsA(); // NOLINT: silence clang-tidy warnings
154 }
156 fSeekParent = f->GetSeekDir();
158 TKey *key = new TKey(fName,fTitle,cl,nbytes,motherdir);
159 fNbytesName = key->GetKeylen();
160 fSeekDir = key->GetSeekKey();
161 if (fSeekDir == 0) return;
162 char *buffer = key->GetBuffer();
164 Int_t cycle = motherdir ? motherdir->AppendKey(key) : 0;
165 key->WriteFile(cycle);
166 } else {
167 fSeekParent = 0;
168 fNbytesName = 0;
169 fSeekDir = f->DirCreateEntry(this);
170 if (fSeekDir == 0) return;
171 }
172
173}
174
175////////////////////////////////////////////////////////////////////////////////
176/// Destructor.
179{
180 if (fKeys) {
181 fKeys->Delete("slow");
183 }
184
186
187 // Delete our content before we become somewhat invalid
188 // since some those objects (TTree for example) needs information
189 // from this object. Note that on some platform after the end
190 // of the body (i.e. thus during ~TDirectory which is also
191 // contains this code) the execution of 'this->GetFile()' fails
192 // to return the 'proper' value (because it uses the wrong
193 // virtual function).
194 if (fList) {
195 fList->Delete("slow");
197 }
198
199 if (gDebug) {
200 Info("~TDirectoryFile", "dtor called for %s", GetName());
201 }
202}
203
204////////////////////////////////////////////////////////////////////////////////
205/// Append object to this directory.
206///
207/// If replace is true:
208/// remove any existing objects with the same same (if the name is not ""
210void TDirectoryFile::Append(TObject *obj, Bool_t replace /* = kFALSE */)
211{
212 if (!obj || !fList) return;
213
214 TDirectory::Append(obj,replace);
215
216 if (!fMother) return;
217 if (fMother->IsA() == TMapFile::Class()) {
219 mfile->Add(obj);
220 }
221}
222
223////////////////////////////////////////////////////////////////////////////////
224/// Insert key in the linked list of keys of this directory.
227{
228 if (!fKeys) {
229 Error("AppendKey","TDirectoryFile not initialized yet.");
230 return 0;
231 }
232
234
235 key->SetMotherDir(this);
236
237 // This is a fast hash lookup in case the key does not already exist
238 TKey *oldkey = (TKey*)fKeys->FindObject(key->GetName());
239 if (!oldkey) {
240 fKeys->Add(key);
241 return 1;
242 }
243
244 // If the key name already exists we have to make a scan for it
245 // and insert the new key ahead of the current one
247 while (lnk) {
248 oldkey = (TKey*)lnk->GetObject();
249 if (!strcmp(oldkey->GetName(), key->GetName()))
250 break;
251 lnk = lnk->Next();
252 }
253
254 fKeys->AddBefore(lnk, key);
255 return oldkey->GetCycle() + 1;
256}
257
258////////////////////////////////////////////////////////////////////////////////
259/// Browse the content of the directory.
262{
264
265 if (b) {
266 TObject *obj = nullptr;
268 TKey *key = nullptr, *keyo = nullptr;
269 TIter next(fKeys);
270
271 cd();
272
273 //Add objects that are only in memory
274 while ((obj = nextin())) {
275 if (fKeys->FindObject(obj->GetName())) continue;
276 b->Add(obj, obj->GetName());
277 }
278
279 //Add keys
280 while ((key = (TKey *) next())) {
281 int skip = 0;
282 if (!keyo || (keyo && strcmp(keyo->GetName(), key->GetName()))) {
283 skip = 0;
284 obj = fList->FindObject(key->GetName());
285
286 if (obj) {
287 b->Add(obj, obj->GetName());
288 if (obj->IsFolder() && !obj->InheritsFrom("TTree"))
289 skip = 1;
290 }
291 }
292
293 if (!skip) {
294 name.Form("%s;%d", key->GetName(), key->GetCycle());
295 b->Add(key, name);
296 }
297
298 keyo = key;
299 }
300 }
301}
302
303////////////////////////////////////////////////////////////////////////////////
304/// Initialise directory to defaults.
307{
308 // If directory is created via default ctor (when dir is read from file)
309 // don't add it here to the directory since its name is not yet known.
310 // It will be added to the directory in TKey::ReadObj().
311
312 if (motherDir && strlen(GetName()) != 0) motherDir->Append(this);
313
316 fDatimeC.Set();
317 fDatimeM.Set();
318 fNbytesKeys = 0;
319 fSeekDir = 0;
320 fSeekParent = 0;
321 fSeekKeys = 0;
322 fList = new THashList(100,50);
323 fKeys = new THashList(100,50);
324 fList->UseRWLock();
328}
329
330////////////////////////////////////////////////////////////////////////////////
331/// Change current directory to "this" directory.
332///
333/// Returns kTRUE in case of success.
336{
337 Bool_t ok = TDirectory::cd();
338 if (ok)
340 return ok;
341}
342
343////////////////////////////////////////////////////////////////////////////////
344/// Change current directory the directory described by the path if given one.
345/// change the current directory to "path". The absolute path syntax is:
346///
347/// file.root:/dir1/dir2
348///
349/// where file.root is the file and /dir1/dir2 the desired subdirectory
350/// in the file. Relative syntax is relative to "this" directory. E.g:
351/// ../aa. Returns kTRUE in case of success.
353Bool_t TDirectoryFile::cd(const char *path)
354{
355 Bool_t ok = TDirectory::cd(path);
356 if (ok)
358 return ok;
359}
360
361////////////////////////////////////////////////////////////////////////////////
362/// Clean the pointers to this object (gDirectory, TContext, etc.)
365{
366 // After CleanTargets either gFile was changed appropriately
367 // by a cd() or needs to be set to zero.
368 if (gFile == this) {
369 gFile = nullptr;
370 }
371
373}
374
375////////////////////////////////////////////////////////////////////////////////
376/// Make a clone of an object using the Streamer facility.
377///
378/// If the object derives from TNamed, this function is called
379/// by TNamed::Clone. TNamed::Clone uses the optional argument newname to set
380/// a new name to the newly created object.
381///
382/// If autoadd is true and if the object class has a
383/// DirectoryAutoAdd function, it will be called at the end of the
384/// function with the parameter gDirectory. This usually means that
385/// the object will be appended to the current ROOT directory.
387TObject *TDirectoryFile::CloneObject(const TObject *obj, Bool_t autoadd /* = kTRUE */)
388{
389 // if no default ctor return immediately (error issued by New())
390 char *pobj = (char*)obj->IsA()->New();
391 if (!pobj) return nullptr;
392
393 Int_t baseOffset = obj->IsA()->GetBaseClassOffset(TObject::Class());
394 if (baseOffset==-1) {
395 // cl does not inherit from TObject.
396 // Since this is not supported in this function, the only reason we could reach this code
397 // is because something is screwed up in the ROOT code.
398 Fatal("CloneObject","Incorrect detection of the inheritance from TObject for class %s.\n",
399 obj->IsA()->GetName());
400 }
402
403 //create a buffer where the object will be streamed
404 {
405 // NOTE: do we still need to make this change to gFile?
406 // NOTE: This can not be 'gDirectory=0' as at least roofit expect gDirectory to not be null
407 // during the streaming ....
408 TFile *filsav = gFile;
409 gFile = nullptr;
410 const Int_t bufsize = 10000;
412 buffer.MapObject(obj); //register obj in map to handle self reference
413 {
415 ((TObject*)obj)->ResetBit(kIsReferenced);
416
417 ((TObject*)obj)->Streamer(buffer);
418
419 if (isRef) ((TObject*)obj)->SetBit(kIsReferenced);
420 }
421
422 // read new object from buffer
423 buffer.SetReadMode();
424 buffer.ResetMap();
425 buffer.SetBufferOffset(0);
426 buffer.MapObject(newobj); //register obj in map to handle self reference
427 newobj->Streamer(buffer);
428 newobj->ResetBit(kIsReferenced);
429 newobj->ResetBit(kCanDelete);
430 gFile = filsav;
431 }
432
433 if (autoadd) {
434 ROOT::DirAutoAdd_t func = obj->IsA()->GetDirectoryAutoAdd();
435 if (func) {
436 func(newobj,this);
437 }
438 }
439 return newobj;
440}
441
442////////////////////////////////////////////////////////////////////////////////
443/// Scan the memory lists of all files for an object with name
446{
447 TFile *f;
449 TIter next(gROOT->GetListOfFiles());
450 while ((f = (TFile*)next())) {
451 TObject *obj = f->GetList()->FindObject(name);
452 if (obj) return obj;
453 }
454 return nullptr;
455}
456
457////////////////////////////////////////////////////////////////////////////////
458/// Find a directory named "apath".
459///
460/// It apath is null or empty, returns "this" directory.
461/// Otherwise use the name "apath" to find a directory.
462/// The absolute path syntax is:
463///
464/// file.root:/dir1/dir2
465///
466/// where file.root is the file and /dir1/dir2 the desired subdirectory
467/// in the file. Relative syntax is relative to "this" directory. E.g:
468/// ../aa.
469/// Returns 0 in case path does not exist.
470/// If printError is true, use Error with 'funcname' to issue an error message.
473 Bool_t printError, const char *funcname)
474{
475 Int_t nch = 0;
476 if (apath) nch = strlen(apath);
477 if (!nch) {
478 return this;
479 }
480
481 if (funcname==0 || strlen(funcname)==0) funcname = "GetDirectory";
482
483 TDirectory *result = this;
484
485 char *path = new char[nch+1]; path[0] = 0;
486 if (nch) strlcpy(path,apath,nch+1);
487 char *s = (char*)strchr(path, ':');
488 if (s) {
489 *s = '\0';
491 TDirectory *f = (TDirectory *)gROOT->GetListOfFiles()->FindObject(path);
492 // Check if this is a duplicate (2nd opening) on this file and prefer
493 // this file.
494 if (GetFile()) {
495 auto url = GetFile()->GetEndpointUrl();
496 if (f && 0 == url->Compare(f->GetFile()->GetEndpointUrl())) {
497 result = GetDirectory(s+1,printError,funcname);
498 delete [] path;
499 return result;
500 }
501 }
502 if (!f && !strcmp(gROOT->GetName(), path)) f = gROOT;
503 if (s) *s = ':';
504 if (f) {
505 result = f;
506 if (s && *(s+1)) result = f->GetDirectory(s+1,printError,funcname);
507 delete [] path; return result;
508 } else {
509 if (printError) Error(funcname, "No such file %s", path);
510 delete [] path; return nullptr;
511 }
512 }
513
514 // path starts with a slash (assumes current file)
515 if (path[0] == '/') {
517 if (!fFile) td = gROOT;
518 result = td->GetDirectory(path+1,printError,funcname);
519 delete [] path; return result;
520 }
521
522 TDirectoryFile *obj;
523 char *slash = (char*)strchr(path,'/');
524 if (!slash) { // we are at the lowest level
525 if (!strcmp(path, "..")) {
527 delete [] path; return result;
528 }
529 GetObject(path,obj);
530 if (!obj) {
531 if (printError) Error(funcname,"Unknown directory %s", path);
532 delete [] path; return nullptr;
533 }
534
535 delete [] path; return obj;
536 }
537
538 TString subdir(path);
539 slash = (char*)strchr(subdir.Data(),'/');
540 *slash = 0;
541 //Get object with path from current directory/file
542 if (!strcmp(subdir, "..")) {
544 if (mom)
545 result = mom->GetDirectory(slash+1,printError,funcname);
546 delete [] path; return result;
547 }
548 GetObject(subdir,obj);
549 if (!obj) {
550 if (printError) Error(funcname,"Unknown directory %s", subdir.Data());
551 delete [] path; return nullptr;
552 }
553
554 result = ((TDirectory*)obj)->GetDirectory(slash+1,printError,funcname);
555 delete [] path; return result;
556}
557
558////////////////////////////////////////////////////////////////////////////////
559/// Delete all objects from memory and directory structure itself.
562{
563 if (!fList || !fSeekDir) {
564 return;
565 }
566
567 // Save the directory key list and header
568 Save();
569
570 Bool_t nodelete = option ? (!strcmp(option, "nodelete") ? kTRUE : kFALSE) : kFALSE;
571
572 if (!nodelete) {
573 Bool_t fast = kTRUE;
575 while (lnk) {
576 if (lnk->GetObject()->IsA() == TDirectoryFile::Class()) {fast = kFALSE;break;}
577 lnk = lnk->Next();
578 }
579 // Delete objects from directory list, this in turn, recursively closes all
580 // sub-directories (that were allocated on the heap)
581 // if this dir contains subdirs, we must use the slow option for Delete!
582 // we must avoid "slow" as much as possible, in particular Delete("slow")
583 // with a large number of objects (eg >10^5) would take for ever.
584 {
585 if (fast) fList->Delete();
586 else fList->Delete("slow");
587 }
588 }
589
590 // Delete keys from key list (but don't delete the list header)
591 if (fKeys) {
592 fKeys->Delete("slow");
593 }
594
596}
597
598////////////////////////////////////////////////////////////////////////////////
599/// Delete Objects or/and keys in the current directory.
600///
601/// \param[in] namecycle Encodes the name and cycle of the objects to delete in
602/// the current directory (e.g. the top directory of a TFile)
603/// - <em>namecycle</em> has the format <em>name;cycle</em>.
604/// - <em>namecycle</em>="" is same as <em>namecycle</em>="T*"
605/// - <em>name</em>="*" means all objects, use "T*" to also delete subdirectories
606/// - <em>cycle</em>="*" means all cycles (memory and keys)
607/// - <em>cycle</em>="" or <em>cycle</em>="9999" ==> apply to a memory object
608/// - When <em>name</em>="*"" use "T*" to delete subdirectories also
609///
610/// To delete one directory, you must specify the directory cycle,
611/// eg. file.Delete("dir1;1");
612///
613/// Examples:
614/// | Pattern | Description |
615/// |---------|-------------|
616/// | foo | delete object named foo in memory |
617/// | foo* | delete all objects with a name starting with foo |
618/// | foo;1 | delete cycle 1 of foo on file |
619/// | foo;* | delete all cycles of foo on file and also from memory |
620/// | *;2 | delete all objects on file having the cycle 2 |
621/// | *;* | delete all objects from memory and file |
622/// | T*;* | delete all objects from memory and file and all subdirectories |
623///
624/// \note For some objects, this method, which is used e.g. by rootrm,
625/// properly deletes the specified cycles of the object, but does not free any ‘dependent’
626/// data records (unless it is a TDirectoryFile). In other words, in these cases, Delete
627/// does not free all subdata records, but rather orphans them, ie. the file size is not
628/// reduced, and there is later no option to shrink it nor recover the disappeared ‘dependent’
629/// items. For example, deleting a TTree does not free up space from the directory since the
630/// underlying basket records are not recursively deleted. If this is wanted, one can call
631/// TTree::Delete("all") before calling TDirectoryFile::Delete(); file size won't
632/// shrink either, but more space will be left open for overwriting with other objects.
633/// See also Purge() documentation. A workaround to reduce filesize is to clone all
634/// objects (excluding those to be deleted) into a new TFile.
635///
636/// ## WARNING
637/// If the key to be deleted contains special characters ("+","^","?", etc
638/// that have a special meaning for the regular expression parser (see TRegexp)
639/// then you must specify 2 backslash characters to escape the regular expression.
640/// For example, if the key to be deleted is namecycle = "C++", you must call
641///
642/// mydir.Delete("C\\+\\+"));
643///
645void TDirectoryFile::Delete(const char *namecycle)
646{
647 if (gDebug)
648 Info("Delete","Call for this = %s namecycle = %s",
649 GetName(), (namecycle ? namecycle : "null"));
650
652 Short_t cycle;
653 char name[kMaxLen];
654 const char *nmcy = (namecycle) ? namecycle : "";
656
657 Int_t deleteall = 0;
658 Int_t deletetree = 0;
659 if(strcmp(name,"*") == 0) deleteall = 1;
660 if(strcmp(name,"*T") == 0){ deleteall = 1; deletetree = 1;}
661 if(strcmp(name,"T*") == 0){ deleteall = 1; deletetree = 1;}
662 if(namecycle==0 || !namecycle[0]){ deleteall = 1; deletetree = 1;}
663 TRegexp re(name,kTRUE);
664 TString s;
665 Int_t deleteOK = 0;
666
667//*-*---------------------Case of Object in memory---------------------
668// ========================
669 if (cycle >= 9999 ) {
670 TNamed *idcur;
671 TIter next(fList);
672 while ((idcur = (TNamed *) next())) {
673 deleteOK = 0;
674 s = idcur->GetName();
675 if (deleteall || s.Index(re) != kNPOS) {
676 deleteOK = 1;
677 if (idcur->IsA() == TDirectoryFile::Class()) {
678 deleteOK = 2;
679 if (!deletetree && deleteall) deleteOK = 0;
680 }
681 }
682 if (deleteOK != 0) {
684 if (deleteOK==2) {
685 // read subdirectories to correctly delete them
686 if (deletetree)
687 ((TDirectory*) idcur)->ReadAll("dirs");
688 idcur->Delete(deletetree ? "T*;*" : "*");
689 delete idcur;
690 } else
691 idcur->Delete(name);
692 }
693 }
694// if (deleteOK == 2) {
695// Info("Delete","Dir:%lx %s", fList->FindObject(name), name);
696// delete fList->FindObject(name); //deleting a TDirectory
697// }
698 }
699//*-*---------------------Case of Key---------------------
700// ===========
701 if (cycle != 9999 ) {
702 if (IsWritable()) {
703 TKey *key;
705 while ((key = (TKey *) nextkey())) {
706 deleteOK = 0;
707 s = key->GetName();
708 if (deleteall || s.Index(re) != kNPOS) {
709 if (cycle == key->GetCycle()) deleteOK = 1;
710 if (cycle > 9999) deleteOK = 1;
711 //if (!strcmp(key->GetClassName(),"TDirectory")) {
712 if (strstr(key->GetClassName(),"TDirectory")) {
713 deleteOK = 2;
714 if (!deletetree && deleteall) deleteOK = 0;
715 if (cycle == key->GetCycle()) deleteOK = 2;
716 }
717 }
718 if (deleteOK) {
719 if (deleteOK==2) {
720 // read directory with subdirectories to correctly delete and free key structure
721 TDirectory* dir = GetDirectory(key->GetName(), kTRUE, "Delete");
722 if (dir!=0) {
723 dir->Delete("T*;*");
724 fList->Remove(dir);
725 delete dir;
726 }
727 }
728
729 key->Delete();
730 fKeys->Remove(key);
732 delete key;
733 }
734 }
735 TFile* f = GetFile();
736 if (fModified && (f!=0)) {
737 WriteKeys(); //*-* Write new keys structure
738 WriteDirHeader(); //*-* Write new directory header
739 f->WriteFree(); //*-* Write new free segments list
740 f->WriteHeader(); //*-* Write new file header
741 }
742 }
743 }
744}
745
746////////////////////////////////////////////////////////////////////////////////
747/// Encode directory header into output buffer
749void TDirectoryFile::FillBuffer(char *&buffer)
750{
755 {
756 // One of the address is larger than 2GB we need to use longer onfile
757 // integer, thus we increase the version number.
758 // Note that fSeekDir and fSeekKey are not necessarily correlated, if
759 // some object are 'removed' from the file and the holes are reused.
760 version += 1000;
761 }
762 tobuf(buffer, version);
764 if (reproducible) {
765 TDatime((UInt_t) 1).FillBuffer(buffer);
766 TDatime((UInt_t) 1).FillBuffer(buffer);
767 } else {
768 fDatimeC.FillBuffer(buffer);
769 fDatimeM.FillBuffer(buffer);
770 }
771 tobuf(buffer, fNbytesKeys);
772 tobuf(buffer, fNbytesName);
773 if (version > 1000) {
774 tobuf(buffer, fSeekDir);
775 tobuf(buffer, fSeekParent);
776 tobuf(buffer, fSeekKeys);
777 } else {
778 tobuf(buffer, (Int_t)fSeekDir);
779 tobuf(buffer, (Int_t)fSeekParent);
780 tobuf(buffer, (Int_t)fSeekKeys);
781 }
782 if (reproducible)
783 TUUID("00000000-0000-0000-0000-000000000000").FillBuffer(buffer);
784 else
785 fUUID.FillBuffer(buffer);
786 if (fFile && fFile->GetVersion() < 40000) return;
787 if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0));
788}
789
790////////////////////////////////////////////////////////////////////////////////
791/// Find key with name `keyname` in the current directory.
792/// `keyname` may be of the form name;cycle.
793/// See GetKey() for details on the semantics of this form.
795TKey *TDirectoryFile::FindKey(const char *keyname) const
796{
797 Short_t cycle;
798 char name[kMaxLen];
799
801 return GetKey(name,cycle);
802}
803
804////////////////////////////////////////////////////////////////////////////////
805/// Find key with name `keyname` in the current directory or
806/// its subdirectories.
807/// `keyname` may be of the form name;cycle.
808/// See GetKey() for details on the semantics of this form.
809///
810/// NOTE: that If a key is found, the directory containing the key becomes
811/// the current directory
813TKey *TDirectoryFile::FindKeyAny(const char *keyname) const
814{
816 Short_t cycle;
817 char name[kMaxLen];
818
820
821 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
822 if (!listOfKeys) {
823 Error("FindKeyAny", "Unexpected type of TDirectoryFile::fKeys!");
824 return nullptr;
825 }
826
827 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
828 for (auto key: TRangeDynCast<TKey>(*keyList)) {
829 if (key && !strcmp(key->GetName(), name)
830 && (cycle == 9999 || cycle >= key->GetCycle())) {
831 const_cast<TDirectoryFile*>(this)->cd(); // may be we should not make cd ???
832 return key;
833 }
834 }
835 }
836
837 //try with subdirectories
838 TIter next(GetListOfKeys());
839 TKey *key;
840 while ((key = (TKey *) next())) {
841 //if (!strcmp(key->GetClassName(),"TDirectory")) {
842 if (strstr(key->GetClassName(),"TDirectory")) {
844 const_cast<TDirectoryFile*>(this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
845 TKey *k = subdir ? subdir->FindKeyAny(keyname) : nullptr;
846 if (k) return k;
847 }
848 }
849 if (dirsav) dirsav->cd();
850 return nullptr;
851}
852
853////////////////////////////////////////////////////////////////////////////////
854/// Find object by name in the list of memory objects of the current
855/// directory or its sub-directories.
856///
857/// After this call the current directory is not changed.
858/// To automatically set the current directory where the object is found,
859/// use FindKeyAny(aname)->ReadObj().
862{
863 //object may be already in the list of objects in memory
865 if (obj) return obj;
866
868 Short_t cycle;
869 char name[kMaxLen];
870
872
873 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
874 if (!listOfKeys) {
875 Error("FindObjectAny", "Unexpected type of TDirectoryFile::fKeys!");
876 return nullptr;
877 }
878
879 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
880 for (auto key: TRangeDynCast<TKey>(*keyList)) {
881 if (key && !strcmp(key->GetName(), name)
882 && (cycle == 9999 || cycle >= key->GetCycle())) {
883 return key->ReadObj();
884 }
885 }
886 }
887
888 //try with subdirectories
889 TIter next(GetListOfKeys());
890 TKey *key;
891 while ((key = (TKey *) next())) {
892 //if (!strcmp(key->GetClassName(),"TDirectory")) {
893 if (strstr(key->GetClassName(),"TDirectory")) {
895 ((TDirectory*)this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
896 TKey *k = subdir ? subdir->FindKeyAny(aname) : nullptr;
897 if (k) { if (dirsav) dirsav->cd(); return k->ReadObj();}
898 }
899 }
900 if (dirsav) dirsav->cd();
901 return nullptr;
902}
903
904////////////////////////////////////////////////////////////////////////////////
905/// Return pointer to object identified by namecycle.
906///
907/// Properties:
908/// - namecycle has the format name;cycle
909/// - name = * is illegal, cycle = * is illegal
910/// - cycle = "" or cycle = 9999 ==> apply to a memory object
911///
912/// Examples:
913/// | %Pattern | Explanation |
914/// |----------|-------------|
915/// | foo | get object named foo in memory if object is not in memory, try with highest cycle from file |
916/// | foo;1 | get cycle 1 of foo on file |
917///
918/// The retrieved object should in principle derive from TObject.
919/// If not, the function TDirectoryFile::Get<T> should be called.
920/// However, this function will still work for a non-TObject, provided that
921/// the calling application cast the return type to the correct type (which
922/// is the actual type of the object).
923///
924/// ### The Get<T> Method
925/// The method Get<T> offers better protection and avoids the need for any
926/// cast:
927/// ~~~{.cpp}
928/// auto objPtr = directory->Get<MyClass>("some object");
929/// if (objPtr) { ... the object exist and inherits from MyClass ... }
930/// ~~~
931///
932/// ### Very important note about inheritance
933/// In case the class of this object derives from TObject but not
934/// as a first inheritance, one must use dynamic_cast<>().
935///
936/// #### Example 1 - Normal case:
937///
938/// class MyClass : public TObject, public AnotherClass
939///
940/// then on return, one can adopt a C style cast:
941///
942/// auto objPtr = (MyClass*)directory->Get("some object of MyClass");
943///
944/// #### Example 2 - Special case:
945///
946/// class MyClass : public AnotherClass, public TObject
947///
948/// then on return, one must do:
949///
950/// auto objPtr = dynamic_cast<MyClass*>(directory->Get("some object of MyClass"));
951///
952/// Of course, dynamic_cast<> can also be used in the example 1.
953///
956{
957 Short_t cycle;
958 char name[kMaxLen];
959
961 Int_t nch = strlen(name);
962 for (Int_t i = nch-1; i > 0; i--) {
963 if (name[i] == '/') {
964 name[i] = 0;
966 const char *subnamecycle = namecycle + i + 1;
967 name[i] = '/';
968 return dirToSearch?dirToSearch->Get(subnamecycle):0;
969 }
970 }
971 const char *namobj = name;
972
973//*-*---------------------Case of Object in memory---------------------
974// ========================
975 TObject *idcur = fList ? fList->FindObject(namobj) : nullptr;
976 if (idcur) {
977 if (idcur==this && strlen(namobj)!=0) {
978 // The object has the same name has the directory and
979 // that's what we picked-up! We just need to ignore
980 // it ...
981 idcur = nullptr;
982 } else if (cycle == 9999) {
983 return idcur;
984 } else {
985 if (idcur->InheritsFrom(TCollection::Class()))
986 idcur->Delete(); // delete also list elements
987 delete idcur;
988 idcur = nullptr;
989 }
990 }
991
992//*-*---------------------Case of Key---------------------
993// ===========
994 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
995 if (!listOfKeys) {
996 Error("Get", "Unexpected type of TDirectoryFile::fKeys!");
997 return nullptr;
998 }
999
1000 if (const TList *keyList = listOfKeys->GetListForObject(namobj)) {
1001 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1002 if (key && !strcmp(key->GetName(), namobj)
1003 && (cycle == 9999 || cycle == key->GetCycle())) {
1005 return key->ReadObj();
1006 }
1007 }
1008 }
1009
1010 return nullptr;
1011}
1012
1013////////////////////////////////////////////////////////////////////////////////
1014/// Return pointer to object identified by namecycle.
1015///
1016/// The returned object may or may not derive from TObject.
1017///
1018/// - namecycle has the format name;cycle
1019/// - name = * is illegal, cycle = * is illegal
1020/// - cycle = "" or cycle = 9999 ==> apply to a memory object
1021///
1022/// ## Very important note
1023/// The calling application must cast the returned object to
1024/// the final type, e.g.
1025///
1026/// auto objPtr = (MyClass*)directory->GetObject("some object of MyClass");
1029{
1030 return GetObjectChecked(namecycle,(TClass*)nullptr);
1031}
1032
1033////////////////////////////////////////////////////////////////////////////////
1034/// See documentation of TDirectoryFile::GetObjectCheck(const char *namecycle, const TClass *cl)
1036void *TDirectoryFile::GetObjectChecked(const char *namecycle, const char* classname)
1037{
1038 return GetObjectChecked(namecycle,TClass::GetClass(classname));
1039}
1040
1041
1042////////////////////////////////////////////////////////////////////////////////
1043/// Return pointer to object identified by namecycle if and only if the actual
1044/// object is a type suitable to be stored as a pointer to a "expectedClass"
1045/// If expectedClass is null, no check is performed.
1046///
1047/// - namecycle has the format name;cycle
1048/// - name = * is illegal, cycle = * is illegal
1049/// - cycle = "" or cycle = 9999 ==> apply to a memory object
1050///
1051/// ### Very important note
1052/// The calling application must cast the returned pointer to
1053/// the type described by the 2 arguments (i.e. cl):
1054///
1055/// auto objPtr = (MyClass*)directory->GetObjectChecked("some object of MyClass","MyClass"));
1056///
1057/// Note: We recommend using the method TDirectoryFile::Get<T>:
1058/// ~~~{.cpp}
1059/// auto objPtr = directory->Get<MyClass>("some object inheriting from MyClass");
1060/// if (objPtr) { ... we found what we are looking for ... }
1061/// ~~~
1064{
1065
1066 // If the name is invalid, issue an error message and return a nullptr
1067 if (!namecycle || '\0' == namecycle[0]) {
1068 Error("GetObjectChecked", "The provided key name is invalid.");
1069 return nullptr;
1070 }
1071
1072 Short_t cycle;
1073 char name[kMaxLen];
1074
1076 Int_t nch = strlen(name);
1077 for (Int_t i = nch-1; i > 0; i--) {
1078 if (name[i] == '/') {
1079 name[i] = 0;
1081 const char *subnamecycle = namecycle + i + 1;
1082 name[i] = '/';
1083 if (dirToSearch) {
1084 return dirToSearch->GetObjectChecked(subnamecycle, expectedClass);
1085 } else {
1086 return nullptr;
1087 }
1088 }
1089 }
1090 const char *namobj = name;
1091
1092//*-*---------------------Case of Object in memory---------------------
1093// ========================
1094 if (expectedClass==0 || expectedClass->IsTObject()) {
1095 TObject *objcur = fList ? fList->FindObject(namobj) : nullptr;
1096 if (objcur) {
1097 if (objcur==this && strlen(namobj)!=0) {
1098 // The object has the same name has the directory and
1099 // that's what we picked-up! We just need to ignore
1100 // it ...
1101 objcur = nullptr;
1102 } else if (cycle == 9999) {
1103 // Check type
1104 if (expectedClass && objcur->IsA()->GetBaseClassOffset(expectedClass) == -1) return nullptr;
1105 else return objcur;
1106 } else {
1107 if (objcur->InheritsFrom(TCollection::Class()))
1108 objcur->Delete(); // delete also list elements
1109 delete objcur;
1110 objcur = nullptr;
1111 }
1112 }
1113 }
1114
1115//*-*---------------------Case of Key---------------------
1116// ===========
1117 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1118 if (!listOfKeys) {
1119 Error("GetObjectChecked", "Unexpected type of TDirectoryFile::fKeys!");
1120 return nullptr;
1121 }
1122
1123 if (const TList *keyList = listOfKeys->GetListForObject(namobj)) {
1124 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1125 if (key && !strcmp(key->GetName(), namobj)
1126 && (cycle == 9999 || cycle == key->GetCycle())) {
1128 return key->ReadObjectAny(expectedClass);
1129 }
1130 }
1131 }
1132
1133 return nullptr;
1134}
1135
1136////////////////////////////////////////////////////////////////////////////////
1137/// Return the buffer size to create new TKeys.
1138///
1139/// If the stored fBufferSize is null, the value returned is the average
1140/// buffer size of objects in the file so far.
1143{
1144 if (fBufferSize <= 0) return fFile->GetBestBuffer();
1145 else return fBufferSize;
1146}
1147
1148
1149////////////////////////////////////////////////////////////////////////////////
1150/// Return pointer to key with name,cycle. If no key exists with the specified
1151/// cycle, returns the key with the highest cycle that is lower than the requested cycle.
1152///
1153/// if cycle = 9999 returns highest cycle
1155TKey *TDirectoryFile::GetKey(const char *name, Short_t cycle) const
1156{
1157 if (!fKeys) return nullptr;
1158
1159 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1160 if (!listOfKeys) {
1161 Error("GetKey", "Unexpected type of TDirectoryFile::fKeys!");
1162 return nullptr;
1163 }
1164
1165 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
1166 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1167 if (key && !strcmp(key->GetName(), name)
1168 && (cycle == 9999 || cycle >= key->GetCycle())) {
1169 return key;
1170 }
1171 }
1172 }
1173
1174 return nullptr;
1175}
1176
1177////////////////////////////////////////////////////////////////////////////////
1178/// List Directory contents
1179///
1180/// Indentation is used to identify the directory tree
1181/// Subdirectories are listed first, then objects in memory, then objects on the file
1182///
1183/// The option can has the following format: <b>`[-d |-m][<regexp>]`</b>
1184/// Options:
1185/// - -d: only list objects in the file
1186/// - -m: only list objects in memory
1187/// The `<regexp>` will be used to match the name of the objects.
1188/// By default memory and disk objects are listed.
1191{
1193 std::cout <<ClassName()<<"*\t\t"<<GetName()<<"\t"<<GetTitle()<<std::endl;
1195
1197 TString opt = opta.Strip(TString::kBoth);
1200 TString reg;
1201 if (opt.BeginsWith("-m")) {
1202 diskobj = kFALSE;
1203 if (opt.Length() > 2) {
1204 reg = opt(2,opt.Length());
1205 }
1206 } else if (opt.BeginsWith("-d")) {
1207 memobj = kFALSE;
1208 if (opt.Length() > 2) {
1209 reg = opt(2,opt.Length());
1210 }
1211 } else if (!opt.IsNull()) {
1212 reg = opt;
1213 }
1214
1215 TRegexp re(reg, kTRUE);
1216
1217 if (memobj) {
1218 TObject *obj;
1220 while ((obj = (TObject *) nextobj())) {
1221 TString s = obj->GetName();
1222 if (!reg.IsNull() && s.Index(re) == kNPOS)
1223 continue;
1224 obj->ls(option); //*-* Loop on all the objects in memory
1225 }
1226 }
1227
1228 if (diskobj && fKeys) {
1229 //*-* Loop on all the keys
1230 for (TObjLink *lnk = fKeys->FirstLink(); lnk != nullptr; lnk = lnk->Next()) {
1231 TKey *key = (TKey*)lnk->GetObject();
1232 TString s = key->GetName();
1233 if (!reg.IsNull() && s.Index(re) == kNPOS)
1234 continue;
1235 bool first = (lnk->Prev() == nullptr) || (s != lnk->Prev()->GetObject()->GetName());
1236 bool hasbackup = (lnk->Next() != nullptr) && (s == lnk->Next()->GetObject()->GetName());
1237 if (first)
1238 if (hasbackup)
1239 key->ls(true);
1240 else
1241 key->ls();
1242 else
1243 key->ls(false);
1244 }
1245 }
1247}
1248
1249////////////////////////////////////////////////////////////////////////////////
1250/// Interface to TFile::Open
1256}
1257
1258////////////////////////////////////////////////////////////////////////////////
1259/// Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
1260///
1261/// @param name the name or hierarchy of the subdirectory ("a" or "a/b/c")
1262/// @param title the title
1263/// @param returnExistingDirectory if key-name is already existing, the returned
1264/// value points to preexisting sub-directory if true and to `nullptr` if false.
1265/// @return a pointer to the created sub-directory, not to the top sub-directory
1266/// of the hierarchy (in the above example, the returned TDirectory * points
1267/// to "c"). In case of an error, it returns `nullptr`. In case of a preexisting
1268/// sub-directory (hierarchy) with the requested name, the return value depends
1269/// on the parameter returnExistingDirectory.
1271TDirectory *TDirectoryFile::mkdir(const char *name, const char *title, Bool_t returnExistingDirectory)
1272{
1273 if (!name || !title || !name[0]) return nullptr;
1274 if (!title[0]) title = name;
1275 if (GetKey(name)) {
1277 return (TDirectoryFile*) GetDirectory(name);
1278 else {
1279 Error("mkdir","An object with name %s exists already",name);
1280 return nullptr;
1281 }
1282 }
1283 if (const char *slash = strchr(name,'/')) {
1285 TDirectoryFile *tmpdir = nullptr;
1286 GetObject(workname.Data(), tmpdir);
1287 if (!tmpdir) {
1288 tmpdir = (TDirectoryFile*)mkdir(workname.Data(),title);
1289 if (!tmpdir) return nullptr;
1290 }
1291 return tmpdir->mkdir(slash + 1);
1292 }
1293
1295
1296 return new TDirectoryFile(name, title, "", this);
1297}
1298
1299////////////////////////////////////////////////////////////////////////////////
1300/// Purge lowest key cycles in a directory.
1301///
1302/// By default, only the highest cycle of a key is kept. Keys for which
1303/// the "KEEP" flag has been set are not removed. See TKey::Keep().
1304/// NOTE: This does not reduce the size of a TFile--
1305/// the space is simply freed up to be overwritten.
1308{
1309 if (!IsWritable()) return;
1310
1312
1313 TKey *key;
1315
1316 while ((key = (TKey*)prev())) { // reverse loop on keys
1317 TKey *keyprev = (TKey*)GetListOfKeys()->Before(key);
1318 if (!keyprev) break;
1319 if (key->GetKeep() == 0) {
1320 if (strcmp(key->GetName(), keyprev->GetName()) == 0) {
1321 key->Delete(); // Remove from the file.
1322 delete key; // Remove from memory.
1323 }
1324 }
1325 }
1326 TFile *f = GetFile();
1327 if (fModified && f) {
1328 WriteKeys(); // Write new keys structure
1329 WriteDirHeader(); // Write new directory header
1330 f->WriteFree(); // Write new free segments list
1331 f->WriteHeader(); // Write new file header
1332 }
1333}
1334
1335////////////////////////////////////////////////////////////////////////////////
1336/// Read objects from a ROOT file directory into memory.
1337///
1338/// If an object is already in memory, the memory copy is deleted
1339/// and the object is again read from the file.
1340/// If opt=="dirs", only subdirectories will be read
1341/// If opt=="dirs*" complete directory tree will be read
1344{
1346
1347 TKey *key;
1348 TIter next(GetListOfKeys());
1349
1350 Bool_t readdirs = ((opt!=0) && ((strcmp(opt,"dirs")==0) || (strcmp(opt,"dirs*")==0)));
1351
1352 if (readdirs)
1353 while ((key = (TKey *) next())) {
1354
1355 //if (strcmp(key->GetClassName(),"TDirectory")!=0) continue;
1356 if (strstr(key->GetClassName(),"TDirectory")==0) continue;
1357
1358 TDirectory *dir = GetDirectory(key->GetName(), kTRUE, "ReadAll");
1359
1360 if ((dir!=0) && (strcmp(opt,"dirs*")==0)) dir->ReadAll("dirs*");
1361 }
1362 else
1363 while ((key = (TKey *) next())) {
1364 TObject *thing = GetList()->FindObject(key->GetName());
1365 if (thing) { delete thing; }
1366 key->ReadObj();
1367 }
1368}
1369
1370////////////////////////////////////////////////////////////////////////////////
1371/// Read the linked list of keys.
1372///
1373/// Every directory has a linked list (fKeys). This linked list has been
1374/// written on the file via WriteKeys as a single data record.
1375///
1376/// It is interesting to call this function in the following situation.
1377/// Assume another process1 is connecting this directory in Update mode
1378/// - Process1 is adding/updating objects in this directory
1379/// - You want to see the latest status from process1.
1380/// Example Process1:
1381/// ~~~{.cpp}
1382/// obj1.Write();
1383/// obj2.Write();
1384/// gDirectory->SaveSelf();
1385/// ~~~
1386///
1387/// Example Process2:
1388/// ~~~{.cpp}
1389/// gDirectory->ReadKeys();
1390/// obj1->Draw();
1391/// ~~~
1392/// This is an efficient way (without opening/closing files) to view
1393/// the latest updates of a file being modified by another process
1394/// as it is typically the case in a data acquisition system.
1397{
1398 if (!fFile || !fKeys) return 0;
1399
1400 if (!fFile->IsBinary())
1401 return fFile->DirReadKeys(this);
1402
1404
1405 char *buffer;
1406 if (forceRead) {
1407 fKeys->Delete();
1408 //In case directory was updated by another process, read new
1409 //position for the keys
1411 char *header = new char[nbytes];
1412 buffer = header;
1414 if ( fFile->ReadBuffer(buffer,nbytes) ) {
1415 // ReadBuffer return kTRUE in case of failure.
1416 delete [] header;
1417 return 0;
1418 }
1419 buffer += fNbytesName;
1421 frombuf(buffer,&versiondir);
1422 fDatimeC.ReadBuffer(buffer);
1423 fDatimeM.ReadBuffer(buffer);
1424 frombuf(buffer, &fNbytesKeys);
1425 frombuf(buffer, &fNbytesName);
1426 if (versiondir > 1000) {
1427 frombuf(buffer, &fSeekDir);
1428 frombuf(buffer, &fSeekParent);
1429 frombuf(buffer, &fSeekKeys);
1430 } else {
1432 frombuf(buffer, &sdir); fSeekDir = (Long64_t)sdir;
1434 frombuf(buffer, &skeys); fSeekKeys = (Long64_t)skeys;
1435 }
1436 delete [] header;
1437 }
1438
1439 Int_t nkeys = 0;
1440 Long64_t fsize = fFile->GetSize();
1441 if ( fSeekKeys > 0) {
1442 TKey *headerkey = new TKey(fSeekKeys, fNbytesKeys, this);
1443 headerkey->ReadFile();
1444 buffer = headerkey->GetBuffer();
1445 headerkey->ReadKeyBuffer(buffer);
1446
1447 TKey *key;
1448 frombuf(buffer, &nkeys);
1449 for (Int_t i = 0; i < nkeys; i++) {
1450 key = new TKey(this);
1451 key->ReadKeyBuffer(buffer);
1452 if (key->GetSeekKey() < 64 || key->GetSeekKey() > fsize) {
1453 Error("ReadKeys","reading illegal key, exiting after %d keys",i);
1454 fKeys->Remove(key);
1455 nkeys = i;
1456 break;
1457 }
1458 if (key->GetSeekPdir() < 64 || key->GetSeekPdir() > fsize) {
1459 Error("ReadKeys","reading illegal key, exiting after %d keys",i);
1460 fKeys->Remove(key);
1461 nkeys = i;
1462 break;
1463 }
1464 fKeys->Add(key);
1465 }
1466 delete headerkey;
1467 }
1468
1469 return nkeys;
1470}
1471
1472
1473////////////////////////////////////////////////////////////////////////////////
1474/// Read object with keyname from the current directory
1475///
1476/// Read contents of object with specified name from the current directory.
1477/// First the key with keyname is searched in the current directory,
1478/// next the key buffer is deserialized into the object.
1479/// The object must have been created before via the default constructor.
1480/// See TObject::Write().
1483{
1484 if (!fFile) { Error("ReadTObject","No file open"); return 0; }
1485 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1486 if (!listOfKeys) {
1487 Error("ReadTObject", "Unexpected type of TDirectoryFile::fKeys!");
1488 return 0;
1489 }
1490
1491 if (const TList *keyList = listOfKeys->GetListForObject(keyname)) {
1492 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1493 if (key && !strcmp(key->GetName(), keyname) ) {
1494 return key->Read(obj);
1495 }
1496 }
1497 }
1498
1499 Error("ReadTObject","Key not found");
1500 return 0;
1501}
1502
1503////////////////////////////////////////////////////////////////////////////////
1504/// Reset the TDirectory after its content has been merged into another
1505/// Directory.
1506///
1507/// This returns the TDirectoryFile object back to its state
1508/// before any data has been written to the file.
1509/// The object in the in-memory list are assumed to also have been reset.
1512{
1513 // There is nothing to reset in the base class (TDirectory) since
1514 // we do want to key the list of in-memory object as is.
1515 fModified = kFALSE;
1516 // Does not change: fWritable
1517 fDatimeC.Set();
1518 fDatimeM.Set();
1519 fNbytesKeys = 0; // updated when the keys are written
1520 fNbytesName = 0; // updated by Init
1521 // Does not change (user customization): fBufferSize;
1522 fSeekDir = 0; // updated by Init
1523 fSeekParent = 0; // updated by Init
1524 fSeekKeys = 0; // updated by Init
1525 // Does not change: fFile
1526 TKey *key = fKeys ? (TKey*)fKeys->FindObject(fName) : nullptr;
1527 TClass *cl = IsA();
1528 if (key) {
1529 cl = TClass::GetClass(key->GetClassName());
1530 }
1531 // NOTE: We should check that the content is really mergeable and in
1532 // the in-mmeory list, before deleting the keys.
1533 if (fKeys) {
1534 fKeys->Delete("slow");
1535 }
1536
1538
1539 // Do the same with the sub-directories.
1540 TIter next(GetList());
1541 TObject *idcur;
1542 while ((idcur = next())) {
1543 if (idcur->IsA() == TDirectoryFile::Class()) {
1544 ((TDirectoryFile*)idcur)->ResetAfterMerge(info);
1545 }
1546 }
1547
1548}
1549
1550////////////////////////////////////////////////////////////////////////////////
1551/// Removes subdirectory from the directory
1552///
1553/// When directory is deleted, all keys in all subdirectories will be
1554/// read first and deleted from file (if exists)
1555/// Equivalent call is Delete("name;*");
1557void TDirectoryFile::rmdir(const char *name)
1558{
1559 if (!name || (*name==0)) return;
1560
1561 TString mask(name);
1562 mask += ";*";
1563 Delete(mask);
1564}
1565
1566////////////////////////////////////////////////////////////////////////////////
1567/// Save recursively all directory keys and headers
1570{
1572
1573 SaveSelf();
1574
1575 // recursively save all sub-directories
1576 if (fList && fList->FirstLink()) {
1577 auto lnk = fList->FirstLink()->shared_from_this();
1578 while (lnk) {
1579 TObject *idcur = lnk->GetObject();
1580 if (TDirectoryFile *dir = dynamic_cast<TDirectoryFile *>(idcur)) {
1581 dir->Save();
1582 }
1583 lnk = lnk->NextSP();
1584 }
1585 }
1586}
1587
1588////////////////////////////////////////////////////////////////////////////////
1589/// Save object in filename.
1590///
1591/// If filename is `nullptr` or "", a file with "<objectname>.root" is created.
1592/// The name of the key is the object name.
1593/// By default new file will be created. Using option "a", one can append object
1594/// to the existing ROOT file.
1595/// If the operation is successful, it returns the number of bytes written to the file
1596/// otherwise it returns 0.
1597/// By default a message is printed. Use option "q" to not print the message.
1598/// If filename contains ".json" extension, JSON representation of the object
1599/// will be created and saved in the text file. Such file can be used in
1600/// JavaScript ROOT (https://root.cern/js/) to display object in web browser
1601/// When creating JSON file, option string may contain compression level from 0 to 3 (default 0)
1603Int_t TDirectoryFile::SaveObjectAs(const TObject *obj, const char *filename, Option_t *option) const
1604{
1605 // option can contain single letter args: "a" for append, "q" for quiet in any combinations
1606
1607 if (!obj) return 0;
1608 TString fname, opt = option;
1609 if (filename && *filename)
1610 fname = filename;
1611 else
1612 fname.Form("%s.root", obj->GetName());
1613 opt.ToLower();
1614
1615 Int_t nbytes = 0;
1616 if (fname.Index(".json") > 0) {
1618 } else {
1619 TContext ctxt; // The TFile::Open will change the current directory.
1620 auto *local = TFile::Open(fname.Data(), opt.Contains("a") ? "update" : "recreate");
1621 if (!local) return 0;
1622 nbytes = obj->Write();
1623 delete local;
1624 }
1625 if (!opt.Contains("q") && !gSystem->AccessPathName(fname.Data()))
1626 obj->Info("SaveAs", "ROOT file %s has been created", fname.Data());
1627 return nbytes;
1628}
1629
1630////////////////////////////////////////////////////////////////////////////////
1631/// Save Directory keys and header
1632///
1633/// If the directory has been modified (fModified set), write the keys
1634/// and the directory header. This function assumes the cd is correctly set.
1635///
1636/// It is recommended to use this function in the following situation:
1637/// Assume a process1 using a directory in Update mode
1638/// - New objects or modified objects have been written to the directory.
1639/// - You do not want to close the file.
1640/// - You want your changes be visible from another process2 already connected
1641/// to this directory in read mode.
1642/// - Call this function.
1643/// - In process2, use TDirectoryFile::ReadKeys to refresh the directory.
1646{
1647 if (IsWritable() && (fModified || force) && fFile) {
1649 if (fFile->GetListOfFree())
1650 dowrite = fFile->GetListOfFree()->First() != nullptr;
1651 if (dowrite) {
1653 if (dirsav != this) cd();
1654 WriteKeys(); //*-*- Write keys record
1655 WriteDirHeader(); //*-*- Update directory record
1656 if (dirsav && dirsav != this) dirsav->cd();
1657 }
1658 }
1659}
1660
1661////////////////////////////////////////////////////////////////////////////////
1662/// Set the default buffer size when creating new TKeys.
1663///
1664/// See also TDirectoryFile::GetBufferSize
1669}
1670
1671////////////////////////////////////////////////////////////////////////////////
1672/// Find the action to be executed in the dictionary of the parent class
1673/// and store the corresponding exec number into fBits.
1674///
1675/// This function searches a data member in the class of parent with an
1676/// offset corresponding to this.
1677/// If a comment "TEXEC:" is found in the comment field of the data member,
1678/// the function stores the exec identifier of the exec statement
1679/// following this keyword.
1682{
1683 Int_t offset = (char*)ref - (char*)parent;
1684 TClass *cl = parent->IsA();
1685 cl->BuildRealData(parent);
1687 TIter next(info->GetElements());
1689 while((element = (TStreamerElement*)next())) {
1690 if (element->GetOffset() != offset) continue;
1691 Int_t execid = element->GetExecID();
1692 if (execid > 0) ref->SetBit(execid << 8);
1693 return;
1694 }
1695}
1696
1697////////////////////////////////////////////////////////////////////////////////
1698/// Set the new value of fWritable recursively
1701{
1703
1705
1706 // recursively set all sub-directories
1707 if (fList) {
1708 TObject *idcur;
1709 TIter next(fList);
1710 while ((idcur = next())) {
1711 if (idcur->InheritsFrom(TDirectoryFile::Class())) {
1713 dir->SetWritable(writable);
1714 }
1715 }
1716 }
1717}
1718
1719
1720////////////////////////////////////////////////////////////////////////////////
1721/// Return the size in bytes of the directory header
1724{
1725 Int_t nbytes = 22;
1726
1727 nbytes += fDatimeC.Sizeof();
1728 nbytes += fDatimeM.Sizeof();
1729 nbytes += fUUID.Sizeof();
1730 //assume that the file may be above 2 Gbytes if file version is > 4
1731 if (fFile && fFile->GetVersion() >= 40000) nbytes += 12;
1732 return nbytes;
1733}
1734
1735
1736////////////////////////////////////////////////////////////////////////////////
1737/// Stream a class object
1740{
1742 if (b.IsReading()) {
1743 BuildDirectoryFile((TFile*)b.GetParent(), nullptr);
1744 if (fFile && fFile->IsWritable()) fWritable = kTRUE;
1745
1746 if (fFile && !fFile->IsBinary()) {
1747 Version_t R__v = b.ReadVersion(0, 0);
1748
1750
1751 b.ClassBegin(dirclass, R__v);
1752
1753 TString sbuf;
1754
1755 b.ClassMember("CreateTime","TString");
1756 sbuf.Streamer(b);
1757 TDatime timeC(sbuf.Data());
1758 fDatimeC = timeC;
1759
1760 b.ClassMember("ModifyTime","TString");
1761 sbuf.Streamer(b);
1762 TDatime timeM(sbuf.Data());
1763 fDatimeM = timeM;
1764
1765 b.ClassMember("UUID","TString");
1766 sbuf.Streamer(b);
1767 TUUID id(sbuf.Data());
1768 fUUID = id;
1769
1770 b.ClassEnd(dirclass);
1771
1772 fSeekKeys = 0; // read keys later in the TKeySQL class
1773 } else {
1774 b >> version;
1777 b >> fNbytesKeys;
1778 b >> fNbytesName;
1779 if (version > 1000) {
1781 b >> fSeekDir;
1782 b >> fSeekParent;
1783 b >> fSeekKeys;
1784 } else {
1786 b >> sdir; fSeekDir = (Long64_t)sdir;
1789 }
1790 v = version%1000;
1791 if (v == 2) {
1793 } else if (v > 2) {
1794 fUUID.Streamer(b);
1795 }
1796 }
1797 fList->UseRWLock();
1799 gROOT->GetUUIDs()->AddUUID(fUUID,this);
1800 if (fSeekKeys) ReadKeys();
1801 } else {
1802 if (fFile && !fFile->IsBinary()) {
1803 b.WriteVersion(TDirectoryFile::Class());
1804
1805 TString sbuf;
1806
1807 b.ClassBegin(TDirectoryFile::Class());
1808
1809 b.ClassMember("CreateTime","TString");
1811 sbuf.Streamer(b);
1812
1813 b.ClassMember("ModifyTime","TString");
1814 fDatimeM.Set();
1816 sbuf.Streamer(b);
1817
1818 b.ClassMember("UUID","TString");
1819 sbuf = fUUID.AsString();
1820 sbuf.Streamer(b);
1821
1822 b.ClassEnd(TDirectoryFile::Class());
1823 } else {
1825 if (fFile && fFile->GetEND() > TFile::kStartBigFile) version += 1000;
1826 b << version;
1829 b << fNbytesKeys;
1830 b << fNbytesName;
1831 if (version > 1000) {
1832 b << fSeekDir;
1833 b << fSeekParent;
1834 b << fSeekKeys;
1835 } else {
1836 b << (Int_t)fSeekDir;
1837 b << (Int_t)fSeekParent;
1838 b << (Int_t)fSeekKeys;
1839 }
1840 fUUID.Streamer(b);
1841 if (version <=1000) for (Int_t i=0;i<3;i++) b << Int_t(0);
1842 }
1843 }
1844}
1845
1846////////////////////////////////////////////////////////////////////////////////
1847/// Write all objects in memory to disk.
1848///
1849/// Loop on all objects in memory (including subdirectories).
1850/// A new key is created in the keys linked list for each object.
1851/// For allowed options see TObject::Write().
1852/// The directory header info is rewritten on the directory header record.
1854Int_t TDirectoryFile::Write(const char *, Int_t opt, Int_t bufsize)
1855{
1856 if (!IsWritable()) return 0;
1858
1859 // Loop on all objects (including subdirs)
1860 TIter next(fList);
1861 TObject *obj;
1862 Int_t nbytes = 0;
1863 while ((obj=next())) {
1864 nbytes += obj->Write(0,opt,bufsize);
1865 }
1866 if (R__likely(!(opt & kOnlyPrepStep)))
1867 SaveSelf(kTRUE); // force save itself
1868
1869 return nbytes;
1870}
1871
1872////////////////////////////////////////////////////////////////////////////////
1873/// One can not save a const TDirectory object.
1875Int_t TDirectoryFile::Write(const char *n, Int_t opt, Int_t bufsize) const
1876{
1877 Error("Write const","A const TDirectory object should not be saved. We try to proceed anyway.");
1878 return const_cast<TDirectoryFile*>(this)->Write(n, opt, bufsize);
1879}
1880
1881////////////////////////////////////////////////////////////////////////////////
1882/// Write object obj to this directory.
1883///
1884/// The data structure corresponding to this object is serialized.
1885/// The corresponding buffer is written to this directory
1886/// with an associated key with name "name".
1887///
1888/// Writing an object to a file involves the following steps:
1889/// - Creation of a support TKey object in the directory. The TKey object
1890/// creates a TBuffer object.
1891/// - The TBuffer object is filled via the class::Streamer function.
1892/// - If the file is compressed (default) a second buffer is created to hold
1893/// the compressed buffer.
1894/// - Reservation of the corresponding space in the file by looking in the
1895/// TFree list of free blocks of the file.
1896/// - The buffer is written to the file.
1897///
1898/// By default, the buffersize will be taken from the average buffer size
1899/// of all objects written to the current file so far.
1900/// Use TDirectoryFile::SetBufferSize to force a given buffer size.
1901///
1902/// If a name is specified, it will be the name of the key.
1903/// If name is not given, the name of the key will be the name as returned
1904/// by obj->GetName().
1905///
1906/// The option can be a combination of:
1907/// - "SingleKey"
1908/// - "Overwrite"
1909/// - "WriteDelete"
1910/// Using the "Overwrite" option a previous key with the same name is
1911/// overwritten. The previous key is deleted before writing the new object.
1912/// Using the "WriteDelete" option a previous key with the same name is
1913/// deleted only after the new object has been written. This option
1914/// is safer than kOverwrite but it is slower.
1915/// The "SingleKey" option is only used by TCollection::Write() to write
1916/// a container with a single key instead of each object in the container
1917/// with its own key.
1918/// An object is read from this directory via TDirectoryFile::Get.
1919/// The function returns the total number of bytes written to the directory.
1920/// It returns 0 if the object cannot be written.
1921///
1922/// WARNING: avoid special characters like '^','$','.' in the name as they
1923/// are used by the regular expression parser (see TRegexp).
1926{
1928
1929 if (fFile==0) {
1930 const char *objname = "no name specified";
1931 if (name) objname = name;
1932 else if (obj) objname = obj->GetName();
1933 Error("WriteTObject","The current directory (%s) is not associated with a file. The object (%s) has not been written.",GetName(),objname);
1934 return 0;
1935 }
1936
1937 if (!fFile->IsWritable()) {
1939 // Do not print the error if the file already had a SysError.
1940 Error("WriteTObject","Directory %s is not writable", fFile->GetName());
1941 }
1942 return 0;
1943 }
1944
1945 if (!obj) return 0;
1946
1947 TString opt = option;
1948 opt.ToLower();
1949
1950 TKey *key=0, *oldkey=0;
1952 if (bufsize > 0) bsize = bufsize;
1953
1954 const char *oname;
1955 if (name && *name)
1956 oname = name;
1957 else
1958 oname = obj->GetName();
1959
1960 // Remove trailing blanks in object name
1961 Int_t nch = strlen(oname);
1962 char *newName = nullptr;
1963 if (nch && oname[nch-1] == ' ') {
1964 Warning("WriteTObject", "The key name '%s' will be stored in file without the trailing blanks.", obj->GetName());
1965 // See https://github.com/root-project/root/issues/17003
1966 newName = new char[nch+1];
1968 for (Int_t i=0;i<nch;i++) {
1969 if (newName[nch-i-1] != ' ') break;
1970 newName[nch-i-1] = 0;
1971 }
1972 oname = newName;
1973 }
1974
1975 if (opt.Contains("overwrite")) {
1976 //One must use GetKey. FindObject would return the lowest cycle of the key!
1977 //key = (TKey*)gDirectory->GetListOfKeys()->FindObject(oname);
1978 key = GetKey(oname);
1979 if (key) {
1980 key->Delete();
1981 delete key;
1982 }
1983 }
1984 if (opt.Contains("writedelete")) {
1985 oldkey = GetKey(oname);
1986 }
1987 key = fFile->CreateKey(this, obj, oname, bsize);
1988 if (newName) delete [] newName;
1989
1990 if (!key->GetSeekKey()) {
1991 fKeys->Remove(key);
1992 delete key;
1994 return 0;
1995 }
1996 fFile->SumBuffer(key->GetObjlen());
1997 Int_t nbytes = key->WriteFile(0);
2000 return 0;
2001 }
2002 if (oldkey) {
2003 oldkey->Delete();
2004 delete oldkey;
2005 }
2007
2008 return nbytes;
2009}
2010
2011////////////////////////////////////////////////////////////////////////////////
2012/// Write object from pointer of class classname in this directory.
2013///
2014/// obj may not derive from TObject. See TDirectoryFile::WriteTObject for comments
2015///
2016/// ## Very important note
2017/// The value passed as 'obj' needs to be from a pointer to the type described by classname.
2018/// For example:
2019/// ~~~{.cpp}
2020/// TopClass *top;
2021/// BottomClass *bottom;
2022/// top = bottom;
2023/// ~~~
2024/// you can do:
2025/// ~~~{.cpp}
2026/// directory->WriteObjectAny(top,"top","name of object");
2027/// directory->WriteObjectAny(bottom,"bottom","name of object");
2028/// ~~~
2029/// <b>BUT YOU CAN NOT DO</b> the following since it will fail with multiple inheritance:
2030/// ~~~{.cpp}
2031/// directory->WriteObjectAny(top,"bottom","name of object");
2032/// ~~~
2033/// We <b>STRONGLY</b> recommend to use
2034/// ~~~{.cpp}
2035/// TopClass *top = ....;
2036/// directory->WriteObject(top,"name of object")
2037/// ~~~
2038/// See also remarks in TDirectoryFile::WriteTObject
2040Int_t TDirectoryFile::WriteObjectAny(const void *obj, const char *classname, const char *name, Option_t *option, Int_t bufsize)
2041{
2042 TClass *cl = TClass::GetClass(classname);
2043 if (!cl) {
2044 TObject *info_obj = *(TObject**)obj;
2046 if (!info) {
2047 Error("WriteObjectAny","Unknown class: %s",classname);
2048 return 0;
2049 } else {
2050 cl = info->GetClass();
2051 }
2052 }
2053 return WriteObjectAny(obj,cl,name,option,bufsize);
2054}
2055
2056////////////////////////////////////////////////////////////////////////////////
2057/// Write object of class with dictionary cl in this directory.
2058///
2059/// obj may not derive from TObject
2060/// To get the TClass* cl pointer, one can use
2061///
2062/// TClass *cl = TClass::GetClass("classname");
2063///
2064/// An alternative is to call the function WriteObjectAny above.
2065/// see TDirectoryFile::WriteTObject for comments
2067Int_t TDirectoryFile::WriteObjectAny(const void *obj, const TClass *cl, const char *name, Option_t *option, Int_t bufsize)
2068{
2070
2071 if (!fFile) return 0;
2072
2073 if (!cl) {
2074 Error("WriteObject","Unknown type for %s, it can not be written.",name);
2075 return 0;
2076 }
2077
2078 if (!fFile->IsWritable()) {
2080 // Do not print the error if the file already had a SysError.
2081 Error("WriteObject","File %s is not writable", fFile->GetName());
2082 }
2083 return 0;
2084 }
2085
2086 if (!obj) return 0;
2087
2088 const char *className = cl->GetName();
2089 const char *oname;
2090 if (name && *name)
2091 oname = name;
2092 else
2093 oname = className;
2094
2095 if (cl && cl->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(cl->GetCollectionProxy())) {
2096 Error("WriteObjectAny",
2097 "The class requested (%s) for the key name \"%s\""
2098 " is an instance of an stl collection and does not have a compiled CollectionProxy."
2099 " Please generate the dictionary for this collection (%s). No data will be written.",
2100 className, oname, className);
2101 return 0;
2102 }
2103
2104 TKey *key, *oldkey = nullptr;
2106 if (bufsize > 0) bsize = bufsize;
2107
2108 TString opt = option;
2109 opt.ToLower();
2110
2111 // Remove trailing blanks in object name
2112 Int_t nch = strlen(oname);
2113 char *newName = nullptr;
2114 if (nch && oname[nch-1] == ' ') {
2115 newName = new char[nch+1];
2117 for (Int_t i=0;i<nch;i++) {
2118 if (newName[nch-i-1] != ' ') break;
2119 newName[nch-i-1] = 0;
2120 }
2121 oname = newName;
2122 }
2123
2124 if (opt.Contains("overwrite")) {
2125 //One must use GetKey. FindObject would return the lowest cycle of the key!
2126 //key = (TKey*)gDirectory->GetListOfKeys()->FindObject(oname);
2127 key = GetKey(oname);
2128 if (key) {
2129 key->Delete();
2130 delete key;
2131 }
2132 }
2133 if (opt.Contains("writedelete")) {
2134 oldkey = GetKey(oname);
2135 }
2136 key = fFile->CreateKey(this, obj, cl, oname, bsize);
2137 if (newName) delete [] newName;
2138
2139 if (!key->GetSeekKey()) {
2140 fKeys->Remove(key);
2141 delete key;
2142 return 0;
2143 }
2144 fFile->SumBuffer(key->GetObjlen());
2145 Int_t nbytes = key->WriteFile(0);
2146 if (fFile->TestBit(TFile::kWriteError)) return 0;
2147
2148 if (oldkey) {
2149 oldkey->Delete();
2150 delete oldkey;
2151 }
2152
2153 return nbytes;
2154}
2155
2156////////////////////////////////////////////////////////////////////////////////
2157/// Overwrite the Directory header record.
2160{
2161 TFile* f = GetFile();
2162 if (!f) return;
2163
2164 if (!f->IsBinary()) {
2165 fDatimeM.Set();
2166 f->DirWriteHeader(this);
2167 return;
2168 }
2169
2170 Int_t nbytes = TDirectoryFile::Sizeof(); //Warning ! TFile has a Sizeof()
2171 char *header = new char[nbytes];
2172 char *buffer = header;
2173 fDatimeM.Set();
2175 Long64_t pointer = fSeekDir + fNbytesName; // do not overwrite the name/title part
2176 fModified = kFALSE;
2177 f->Seek(pointer);
2178 f->WriteBuffer(header, nbytes);
2179 if (f->MustFlush()) f->Flush();
2180 delete [] header;
2181}
2182
2183////////////////////////////////////////////////////////////////////////////////
2184/// Write Keys linked list on the file.
2185///
2186/// The linked list of keys (fKeys) is written as a single data record
2189{
2190 TFile* f = GetFile();
2191 if (!f) return;
2192
2193 if (!f->IsBinary()) {
2194 f->DirWriteKeys(this);
2195 return;
2196 }
2197
2198//*-* Delete the old keys structure if it exists
2199 if (fSeekKeys != 0) {
2200 f->MakeFree(fSeekKeys, fSeekKeys + fNbytesKeys -1);
2201 }
2202//*-* Write new keys record
2203 TIter next(fKeys);
2204 TKey *key;
2205 Int_t nkeys = fKeys->GetSize();
2206 Int_t nbytes = sizeof nkeys; //*-* Compute size of all keys
2207 if (f->GetEND() > TFile::kStartBigFile) nbytes += 8;
2208 while ((key = (TKey*)next())) {
2209 nbytes += key->Sizeof();
2210 }
2211 TKey *headerkey = new TKey(fName,fTitle,IsA(),nbytes,this);
2212 if (headerkey->GetSeekKey() == 0) {
2213 delete headerkey;
2214 return;
2215 }
2216 char *buffer = headerkey->GetBuffer();
2217 next.Reset();
2218 tobuf(buffer, nkeys);
2219 while ((key = (TKey*)next())) {
2220 key->FillBuffer(buffer);
2221 }
2222
2223 fSeekKeys = headerkey->GetSeekKey();
2224 fNbytesKeys = headerkey->GetNbytes();
2225 headerkey->WriteFile();
2226 delete headerkey;
2227}
void frombuf(char *&buf, Bool_t *x)
Definition Bytes.h:278
void tobuf(char *&buf, Bool_t x)
Definition Bytes.h:55
#define R__likely(expr)
Definition RConfig.hxx:587
#define SafeDelete(p)
Definition RConfig.hxx:525
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
int Int_t
Definition RtypesCore.h:45
short Version_t
Definition RtypesCore.h:65
long Long_t
Definition RtypesCore.h:54
unsigned int UInt_t
Definition RtypesCore.h:46
short Short_t
Definition RtypesCore.h:39
constexpr Bool_t kFALSE
Definition RtypesCore.h:94
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:117
long long Long64_t
Definition RtypesCore.h:69
constexpr Bool_t kTRUE
Definition RtypesCore.h:93
const char Option_t
Definition RtypesCore.h:66
#define BIT(n)
Definition Rtypes.h:91
#define ClassImp(name)
Definition Rtypes.h:376
const Bool_t kIterBackward
Definition TCollection.h:43
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
const Int_t kMaxLen
const UInt_t kIsBigFile
const Int_t kMaxLen
#define gDirectory
Definition TDirectory.h:384
#define gFile
Definition TFile.h:434
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void reg
char name[80]
Definition TGX11.cxx:110
Int_t gDebug
Definition TROOT.cxx:622
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:414
R__EXTERN TSystem * gSystem
Definition TSystem.h:572
#define R__LOCKGUARD(mutex)
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.
Definition TBufferFile.h:47
void MapObject(const TObject *obj, UInt_t offset=1) override
Add object to the fMap container.
void ResetMap() override
Delete existing fMap and reset map counter.
static Int_t ExportToFile(const char *filename, const TObject *obj, const char *option=nullptr)
Convert object into JSON and store in text file Returns size of the produce file Used in TObject::Sav...
Buffer base class used for serializing objects.
Definition TBuffer.h:43
@ kWrite
Definition TBuffer.h:73
void SetBufferOffset(Int_t offset=0)
Definition TBuffer.h:93
void SetReadMode()
Set buffer in read mode.
Definition TBuffer.cxx:302
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
void BuildRealData(void *pointer=nullptr, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition TClass.cxx:2142
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4732
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:3008
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:3079
static TClass * Class()
virtual bool UseRWLock(Bool_t enable=true)
Set this collection to use a RW lock upon access, making it thread safe.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition TDatime.h:37
void FillBuffer(char *&buffer)
Encode Date/Time into buffer, used by I/O system.
Definition TDatime.cxx:229
const char * AsSQLString() const
Return the date & time in SQL compatible string format, like: 1997-01-15 20:16:28.
Definition TDatime.cxx:152
Int_t Sizeof() const
Definition TDatime.h:81
virtual void Streamer(TBuffer &)
Stream a object of type TDatime.
Definition TDatime.cxx:416
void Set()
Set Date/Time to current time as reported by the system.
Definition TDatime.cxx:289
void ReadBuffer(char *&buffer)
Decode Date/Time from output buffer, used by I/O system.
Definition TDatime.cxx:278
A ROOT file is structured in Directories (like a file system).
void SetBufferSize(Int_t bufsize) override
Set the default buffer size when creating new TKeys.
void SetTRefAction(TObject *ref, TObject *parent) override
Find the action to be executed in the dictionary of the parent class and store the corresponding exec...
void Close(Option_t *option="") override
Delete all objects from memory and directory structure itself.
Bool_t cd() override
Change current directory to "this" directory.
TFile * fFile
Pointer to current file in memory.
void Browse(TBrowser *b) override
Browse the content of the directory.
void Append(TObject *obj, Bool_t replace=kFALSE) override
Append object to this directory.
void SaveSelf(Bool_t force=kFALSE) override
Save Directory keys and header.
static TClass * Class()
Bool_t IsWritable() const override
void Streamer(TBuffer &) override
Stream a class object.
void Delete(const char *namecycle="") override
Delete Objects or/and keys in the current directory.
virtual void ResetAfterMerge(TFileMergeInfo *)
Reset the TDirectory after its content has been merged into another Directory.
Int_t AppendKey(TKey *key) override
Insert key in the linked list of keys of this directory.
Int_t ReadKeys(Bool_t forceRead=kTRUE) override
Read the linked list of keys.
TDatime fDatimeM
Date and time of last modification.
void * GetObjectUnchecked(const char *namecycle) override
Return pointer to object identified by namecycle.
TKey * FindKey(const char *keyname) const override
Find key with name keyname in the current directory.
TKey * GetKey(const char *name, Short_t cycle=9999) const override
Return pointer to key with name,cycle.
void * GetObjectChecked(const char *namecycle, const char *classname) override
See documentation of TDirectoryFile::GetObjectCheck(const char *namecycle, const TClass *cl)
void InitDirectoryFile(TClass *cl=nullptr)
Initialize the key associated with this directory (and the related data members.
void Purge(Short_t nkeep=1) override
Purge lowest key cycles in a directory.
void Save() override
Save recursively all directory keys and headers.
~TDirectoryFile() override
Destructor.
TObject * FindObjectAnyFile(const char *name) const override
Scan the memory lists of all files for an object with name.
Int_t fNbytesKeys
Number of bytes for the keys.
Bool_t fModified
True if directory has been modified.
TDirectory * mkdir(const char *name, const char *title="", Bool_t returnExistingDirectory=kFALSE) override
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
TList * GetListOfKeys() const override
void CleanTargets()
Clean the pointers to this object (gDirectory, TContext, etc.)
TObject * FindObjectAny(const char *name) const override
Find object by name in the list of memory objects of the current directory or its sub-directories.
Long64_t fSeekKeys
Location of Keys record on file.
void WriteKeys() override
Write Keys linked list on the file.
TFile * GetFile() const override
Int_t fBufferSize
Default buffer size to create new TKeys.
Int_t Sizeof() const override
Return the size in bytes of the directory header.
TObject * CloneObject(const TObject *obj, Bool_t autoadd=kTRUE) override
Make a clone of an object using the Streamer facility.
TDirectory * GetDirectory(const char *apath, Bool_t printError=false, const char *funcname="GetDirectory") override
Find a directory named "apath".
Long64_t fSeekParent
Location of parent directory on file.
Int_t WriteObjectAny(const void *obj, const char *classname, const char *name, Option_t *option="", Int_t bufsize=0) override
Write object from pointer of class classname in this directory.
void BuildDirectoryFile(TFile *motherFile, TDirectory *motherDir)
Initialise directory to defaults.
void rmdir(const char *name) override
Removes subdirectory from the directory.
Int_t Write(const char *name=nullptr, Int_t opt=0, Int_t bufsize=0) override
Write all objects in memory to disk.
Long64_t fSeekDir
Location of directory on file.
Int_t fNbytesName
Number of bytes in TNamed at creation time.
TDatime fDatimeC
Date and time when directory is created.
Bool_t fWritable
True if directory is writable.
Int_t WriteTObject(const TObject *obj, const char *name=nullptr, Option_t *option="", Int_t bufsize=0) override
Write object obj to this directory.
Int_t ReadTObject(TObject *obj, const char *keyname) override
Read object with keyname from the current directory.
TFile * OpenFile(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0) override
Interface to TFile::Open.
Int_t GetBufferSize() const override
Return the buffer size to create new TKeys.
Int_t SaveObjectAs(const TObject *obj, const char *filename="", Option_t *option="") const override
Save object in filename.
TObject * Get(const char *namecycle) override
Return pointer to object identified by namecycle.
static constexpr Version_t Class_Version()
TDirectoryFile()
Default TDirectoryFile constructor.
TKey * FindKeyAny(const char *keyname) const override
Find key with name keyname in the current directory or its subdirectories.
void FillBuffer(char *&buffer) override
Encode directory header into output buffer.
void WriteDirHeader() override
Overwrite the Directory header record.
void SetWritable(Bool_t writable=kTRUE) override
Set the new value of fWritable recursively.
TClass * IsA() const override
void ReadAll(Option_t *option="") override
Read objects from a ROOT file directory into memory.
TList * fKeys
Pointer to keys list in memory.
void ls(Option_t *option="") const override
List Directory contents.
TDirectory::TContext keeps track and restore the current directory.
Definition TDirectory.h:89
Describe directory structure in memory.
Definition TDirectory.h:45
static TClass * Class()
void Delete(const char *namecycle="") override
Delete Objects or/and keys in a directory.
virtual TList * GetList() const
Definition TDirectory.h:222
virtual void ReadAll(Option_t *="")
Definition TDirectory.h:247
static size_t DecodeNameCycle(const char *namecycle, char *name, Short_t &cycle, const size_t namesize=0)
Decode a namecycle "aap;2" contained in the null-terminated string buffer into name "aap" and cycle 2...
void CleanTargets()
Clean the pointers to this object (gDirectory, TContext, etc.).
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
TObject * FindObject(const char *name) const override
Find object by name in the list of memory objects.
virtual Bool_t cd()
Change current directory to "this" directory.
TUUID fUUID
Definition TDirectory.h:143
TDirectory * GetMotherDir() const
Definition TDirectory.h:225
TObject * fMother
Definition TDirectory.h:141
void GetObject(const char *namecycle, T *&ptr)
Get an object with proper type checking.
Definition TDirectory.h:212
TList * fList
Definition TDirectory.h:142
virtual TObject * FindObjectAny(const char *name) const
Find object by name in the list of memory objects of the current directory or its sub-directories.
Streamer around an arbitrary STL like container, which implements basic container functionality.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131
virtual void Seek(Long64_t offset, ERelativeTo pos=kBeg)
Seek to a specific position in the file. Pos it either kBeg, kCur or kEnd.
Definition TFile.cxx:2305
Int_t GetVersion() const
Definition TFile.h:328
Bool_t IsBinary() const
Definition TFile.h:342
virtual Int_t DirReadKeys(TDirectory *)
Definition TFile.h:247
TList * GetListOfFree() const
Definition TFile.h:320
Int_t GetBestBuffer() const
Return the best buffer size of objects on this file.
Definition TFile.cxx:1173
virtual TKey * CreateKey(TDirectory *mother, const TObject *obj, const char *name, Int_t bufsize)
Creates key for object and converts data to buffer.
Definition TFile.cxx:1056
virtual Long64_t GetSize() const
Returns the current file size.
Definition TFile.cxx:1337
virtual Long64_t GetEND() const
Definition TFile.h:314
void SumBuffer(Int_t bufsize)
Increment statistics for buffer sizes of objects in this file.
Definition TFile.cxx:2448
static TFile *& CurrentFile()
Return the current ROOT file if any.
Definition TFile.cxx:1076
virtual const TUrl * GetEndpointUrl() const
Definition TFile.h:318
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:4121
@ kReproducible
Definition TFile.h:276
@ kWriteError
Definition TFile.h:273
@ kStartBigFile
Definition TFile.h:283
virtual Bool_t ReadBuffer(char *buf, Int_t len)
Read a buffer from the file.
Definition TFile.cxx:1801
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition THashList.h:34
void Reset()
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition TKey.h:28
void Delete(Option_t *option="") override
Delete an object from the file.
Definition TKey.cxx:538
virtual Long64_t GetSeekKey() const
Definition TKey.h:89
Int_t Sizeof() const override
Return the size in bytes of the key header structure.
Definition TKey.cxx:1343
Int_t GetKeylen() const
Definition TKey.h:84
Int_t GetObjlen() const
Definition TKey.h:87
Short_t GetKeep() const
Returns the "KEEP" status.
Definition TKey.cxx:593
virtual const char * GetClassName() const
Definition TKey.h:75
void ReadKeyBuffer(char *&buffer)
Decode input buffer.
Definition TKey.cxx:1232
virtual Long64_t GetSeekPdir() const
Definition TKey.h:90
void SetMotherDir(TDirectory *dir)
Definition TKey.h:112
virtual void ls(Bool_t current) const
List Key contents.
Definition TKey.cxx:694
Short_t GetCycle() const
Return cycle number associated to this key.
Definition TKey.cxx:577
virtual TObject * ReadObj()
To read a TObject* from the file.
Definition TKey.cxx:758
virtual Int_t WriteFile(Int_t cycle=1, TFile *f=nullptr)
Write the encoded object supported by this key.
Definition TKey.cxx:1457
virtual char * GetBuffer() const
Definition TKey.h:78
void FillBuffer(char *&buffer) override
Encode key header into output buffer.
Definition TKey.cxx:601
A doubly linked list.
Definition TList.h:38
TObject * Before(const TObject *obj) const override
Returns the object before object obj.
Definition TList.cxx:369
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition TList.cxx:576
void Add(TObject *obj) override
Definition TList.h:81
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:820
TObject * First() const override
Return the first object in the list. Returns 0 when list is empty.
Definition TList.cxx:657
void AddBefore(const TObject *before, TObject *obj) override
Insert object before object before in the list.
Definition TList.cxx:194
virtual TObjLink * FirstLink() const
Definition TList.h:102
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:468
This class implements a shared memory region mapped to a file.
Definition TMapFile.h:26
static TClass * Class()
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
TString fTitle
Definition TNamed.h:33
TString fName
Definition TNamed.h:32
Mother of all ROOT objects.
Definition TObject.h:41
virtual Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition TObject.cxx:573
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:457
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:202
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:226
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1057
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:421
static TClass * Class()
virtual Int_t Write(const char *name=nullptr, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition TObject.cxx:964
@ kOnlyPrepStep
Used to request that the class specific implementation of TObject::Write just prepare the objects to ...
Definition TObject.h:112
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:864
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:543
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:1099
virtual TClass * IsA() const
Definition TObject.h:246
virtual void ls(Option_t *option="") const
The ls function lists the contents of a class on stdout.
Definition TObject.cxx:592
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:68
@ kIsReferenced
if object is referenced by a TRef or TRefArray
Definition TObject.h:71
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:1045
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition TROOT.cxx:2888
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition TROOT.cxx:2896
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition TROOT.cxx:2748
Regular expression class.
Definition TRegexp.h:31
Describe one element (data member) to be Streamed.
Describes a persistent version of a class.
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
void ToLower()
Change string to lower-case.
Definition TString.cxx:1182
@ kBoth
Definition TString.h:276
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:623
Bool_t IsNull() const
Definition TString.h:414
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:632
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1309
This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDent...
Definition TUUID.h:42
virtual void Streamer(TBuffer &)
const char * AsString() const
Return UUID as string. Copy string immediately since it will be reused.
Definition TUUID.cxx:571
Int_t Sizeof() const
Definition TUUID.h:85
void FillBuffer(char *&buffer)
Stream UUID into output buffer.
Definition TUUID.cxx:275
void StreamerV1(TBuffer &b)
Stream UUID from input buffer.
Definition TUUID.cxx:309
Abstract Interface class describing Streamer information for one class.
std::ostream & Info()
Definition hadd.cxx:177
const Int_t n
Definition legend1.C:16
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition Rtypes.h:120
TCanvas * slash()
Definition slash.C:1