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
94 if (!initMotherDir) initMotherDir = gDirectory;
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
107 BuildDirectoryFile(initMotherDir ? initMotherDir->GetFile() : nullptr, initMotherDir);
108
109 TDirectory* motherdir = GetMotherDir();
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 }
155 TDirectory* motherdir = GetMotherDir();
156 fSeekParent = f->GetSeekDir();
157 Int_t nbytes = TDirectoryFile::Sizeof();
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()) {
218 TMapFile *mfile = (TMapFile*)fMother;
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
246 TObjLink *lnk = fKeys->FirstLink();
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;
267 TIter nextin(fList);
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.
306void TDirectoryFile::BuildDirectoryFile(TFile* motherFile, TDirectory* motherDir)
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();
325 fMother = motherDir;
326 fFile = motherFile ? motherFile : TFile::CurrentFile();
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 }
401 TObject *newobj = (TObject*)(pobj+baseOffset);
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;
411 TBufferFile buffer(TBuffer::kWrite,bufsize);
412 buffer.MapObject(obj); //register obj in map to handle self reference
413 {
414 Bool_t isRef = obj->TestBit(kIsReferenced);
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] == '/') {
516 TDirectory *td = fFile;
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, "..")) {
526 result = GetMotherDir();
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, "..")) {
543 TDirectory* mom = GetMotherDir();
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;
574 TObjLink *lnk = fList->FirstLink();
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 a directory
600///
601/// Properties of the namecycle string:
602/// - namecycle has the format name;cycle
603/// - namecycle = "" is same as namecycle ="T*"
604/// - name = * means all
605/// - cycle = * means all cycles (memory and keys)
606/// - cycle = "" or cycle = 9999 ==> apply to a memory object
607/// When name=* use T* to delete subdirectories also
608///
609/// To delete one directory, you must specify the directory cycle,
610/// eg. file.Delete("dir1;1");
611///
612/// Examples:
613/// | Pattern | Description |
614/// |---------|-------------|
615/// | foo | delete object named foo in memory |
616/// | foo* | delete all objects with a name starting with foo |
617/// | foo;1 | delete cycle 1 of foo on file |
618/// | foo;* | delete all cycles of foo on file and also from memory |
619/// | *;2 | delete all objects on file having the cycle 2 |
620/// | *;* | delete all objects from memory and file |
621/// | T*;* | delete all objects from memory and file and all subdirectories |
622///
623/// ## WARNING
624/// If the key to be deleted contains special characters ("+","^","?", etc
625/// that have a special meaning for the regular expression parser (see TRegexp)
626/// then you must specify 2 backslash characters to escape the regular expression.
627/// For example, if the key to be deleted is namecycle = "C++", you must call
628///
629/// mydir.Delete("C\\+\\+"));
630///
632void TDirectoryFile::Delete(const char *namecycle)
633{
634 if (gDebug)
635 Info("Delete","Call for this = %s namecycle = %s",
636 GetName(), (namecycle ? namecycle : "null"));
637
638 TDirectory::TContext ctxt(this);
639 Short_t cycle;
640 char name[kMaxLen];
641 const char *nmcy = (namecycle) ? namecycle : "";
642 DecodeNameCycle(nmcy, name, cycle, kMaxLen);
643
644 Int_t deleteall = 0;
645 Int_t deletetree = 0;
646 if(strcmp(name,"*") == 0) deleteall = 1;
647 if(strcmp(name,"*T") == 0){ deleteall = 1; deletetree = 1;}
648 if(strcmp(name,"T*") == 0){ deleteall = 1; deletetree = 1;}
649 if(namecycle==0 || !namecycle[0]){ deleteall = 1; deletetree = 1;}
650 TRegexp re(name,kTRUE);
651 TString s;
652 Int_t deleteOK = 0;
653
654//*-*---------------------Case of Object in memory---------------------
655// ========================
656 if (cycle >= 9999 ) {
657 TNamed *idcur;
658 TIter next(fList);
659 while ((idcur = (TNamed *) next())) {
660 deleteOK = 0;
661 s = idcur->GetName();
662 if (deleteall || s.Index(re) != kNPOS) {
663 deleteOK = 1;
664 if (idcur->IsA() == TDirectoryFile::Class()) {
665 deleteOK = 2;
666 if (!deletetree && deleteall) deleteOK = 0;
667 }
668 }
669 if (deleteOK != 0) {
670 fList->Remove(idcur);
671 if (deleteOK==2) {
672 // read subdirectories to correctly delete them
673 if (deletetree)
674 ((TDirectory*) idcur)->ReadAll("dirs");
675 idcur->Delete(deletetree ? "T*;*" : "*");
676 delete idcur;
677 } else
678 idcur->Delete(name);
679 }
680 }
681// if (deleteOK == 2) {
682// Info("Delete","Dir:%lx %s", fList->FindObject(name), name);
683// delete fList->FindObject(name); //deleting a TDirectory
684// }
685 }
686//*-*---------------------Case of Key---------------------
687// ===========
688 if (cycle != 9999 ) {
689 if (IsWritable()) {
690 TKey *key;
691 TIter nextkey(GetListOfKeys());
692 while ((key = (TKey *) nextkey())) {
693 deleteOK = 0;
694 s = key->GetName();
695 if (deleteall || s.Index(re) != kNPOS) {
696 if (cycle == key->GetCycle()) deleteOK = 1;
697 if (cycle > 9999) deleteOK = 1;
698 //if (!strcmp(key->GetClassName(),"TDirectory")) {
699 if (strstr(key->GetClassName(),"TDirectory")) {
700 deleteOK = 2;
701 if (!deletetree && deleteall) deleteOK = 0;
702 if (cycle == key->GetCycle()) deleteOK = 2;
703 }
704 }
705 if (deleteOK) {
706 if (deleteOK==2) {
707 // read directory with subdirectories to correctly delete and free key structure
708 TDirectory* dir = GetDirectory(key->GetName(), kTRUE, "Delete");
709 if (dir!=0) {
710 dir->Delete("T*;*");
711 fList->Remove(dir);
712 delete dir;
713 }
714 }
715
716 key->Delete();
717 fKeys->Remove(key);
719 delete key;
720 }
721 }
722 TFile* f = GetFile();
723 if (fModified && (f!=0)) {
724 WriteKeys(); //*-* Write new keys structure
725 WriteDirHeader(); //*-* Write new directory header
726 f->WriteFree(); //*-* Write new free segments list
727 f->WriteHeader(); //*-* Write new file header
728 }
729 }
730 }
731}
732
733////////////////////////////////////////////////////////////////////////////////
734/// Encode directory header into output buffer
736void TDirectoryFile::FillBuffer(char *&buffer)
737{
738 Version_t version = TDirectoryFile::Class_Version();
742 {
743 // One of the address is larger than 2GB we need to use longer onfile
744 // integer, thus we increase the version number.
745 // Note that fSeekDir and fSeekKey are not necessarily correlated, if
746 // some object are 'removed' from the file and the holes are reused.
747 version += 1000;
748 }
749 tobuf(buffer, version);
750 const bool reproducible = TestBit(TFile::kReproducible) || (fFile && fFile->TestBit(TFile::kReproducible));
751 if (reproducible) {
752 TDatime((UInt_t) 1).FillBuffer(buffer);
753 TDatime((UInt_t) 1).FillBuffer(buffer);
754 } else {
755 fDatimeC.FillBuffer(buffer);
756 fDatimeM.FillBuffer(buffer);
757 }
758 tobuf(buffer, fNbytesKeys);
759 tobuf(buffer, fNbytesName);
760 if (version > 1000) {
761 tobuf(buffer, fSeekDir);
762 tobuf(buffer, fSeekParent);
763 tobuf(buffer, fSeekKeys);
764 } else {
765 tobuf(buffer, (Int_t)fSeekDir);
766 tobuf(buffer, (Int_t)fSeekParent);
767 tobuf(buffer, (Int_t)fSeekKeys);
768 }
769 if (reproducible)
770 TUUID("00000000-0000-0000-0000-000000000000").FillBuffer(buffer);
771 else
772 fUUID.FillBuffer(buffer);
773 if (fFile && fFile->GetVersion() < 40000) return;
774 if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0));
775}
776
777////////////////////////////////////////////////////////////////////////////////
778/// Find key with name keyname in the current directory
780TKey *TDirectoryFile::FindKey(const char *keyname) const
781{
782 Short_t cycle;
783 char name[kMaxLen];
784
785 DecodeNameCycle(keyname, name, cycle, kMaxLen);
786 return GetKey(name,cycle);
787}
788
789////////////////////////////////////////////////////////////////////////////////
790/// Find key with name keyname in the current directory or
791/// its subdirectories.
792///
793/// NOTE: that If a key is found, the directory containing the key becomes
794/// the current directory
796TKey *TDirectoryFile::FindKeyAny(const char *keyname) const
797{
798 TDirectory *dirsav = gDirectory;
799 Short_t cycle;
800 char name[kMaxLen];
801
802 DecodeNameCycle(keyname, name, cycle, kMaxLen);
803
804 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
805 if (!listOfKeys) {
806 Error("FindKeyAny", "Unexpected type of TDirectoryFile::fKeys!");
807 return nullptr;
808 }
809
810 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
811 for (auto key: TRangeDynCast<TKey>(*keyList)) {
812 if (key && !strcmp(key->GetName(), name)
813 && (cycle == 9999 || cycle >= key->GetCycle())) {
814 const_cast<TDirectoryFile*>(this)->cd(); // may be we should not make cd ???
815 return key;
816 }
817 }
818 }
819
820 //try with subdirectories
821 TIter next(GetListOfKeys());
822 TKey *key;
823 while ((key = (TKey *) next())) {
824 //if (!strcmp(key->GetClassName(),"TDirectory")) {
825 if (strstr(key->GetClassName(),"TDirectory")) {
826 TDirectory* subdir =
827 const_cast<TDirectoryFile*>(this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
828 TKey *k = subdir ? subdir->FindKeyAny(keyname) : nullptr;
829 if (k) return k;
830 }
831 }
832 if (dirsav) dirsav->cd();
833 return nullptr;
834}
835
836////////////////////////////////////////////////////////////////////////////////
837/// Find object by name in the list of memory objects of the current
838/// directory or its sub-directories.
839///
840/// After this call the current directory is not changed.
841/// To automatically set the current directory where the object is found,
842/// use FindKeyAny(aname)->ReadObj().
844TObject *TDirectoryFile::FindObjectAny(const char *aname) const
845{
846 //object may be already in the list of objects in memory
848 if (obj) return obj;
849
850 TDirectory *dirsav = gDirectory;
851 Short_t cycle;
852 char name[kMaxLen];
853
854 DecodeNameCycle(aname, name, cycle, kMaxLen);
855
856 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
857 if (!listOfKeys) {
858 Error("FindObjectAny", "Unexpected type of TDirectoryFile::fKeys!");
859 return nullptr;
860 }
861
862 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
863 for (auto key: TRangeDynCast<TKey>(*keyList)) {
864 if (key && !strcmp(key->GetName(), name)
865 && (cycle == 9999 || cycle >= key->GetCycle())) {
866 return key->ReadObj();
867 }
868 }
869 }
870
871 //try with subdirectories
872 TIter next(GetListOfKeys());
873 TKey *key;
874 while ((key = (TKey *) next())) {
875 //if (!strcmp(key->GetClassName(),"TDirectory")) {
876 if (strstr(key->GetClassName(),"TDirectory")) {
877 TDirectory* subdir =
878 ((TDirectory*)this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
879 TKey *k = subdir ? subdir->FindKeyAny(aname) : nullptr;
880 if (k) { if (dirsav) dirsav->cd(); return k->ReadObj();}
881 }
882 }
883 if (dirsav) dirsav->cd();
884 return nullptr;
885}
886
887////////////////////////////////////////////////////////////////////////////////
888/// Return pointer to object identified by namecycle.
889///
890/// Properties:
891/// - namecycle has the format name;cycle
892/// - name = * is illegal, cycle = * is illegal
893/// - cycle = "" or cycle = 9999 ==> apply to a memory object
894///
895/// Examples:
896/// | %Pattern | Explanation |
897/// |----------|-------------|
898/// | foo | get object named foo in memory if object is not in memory, try with highest cycle from file |
899/// | foo;1 | get cycle 1 of foo on file |
900///
901/// The retrieved object should in principle derive from TObject.
902/// If not, the function TDirectoryFile::Get<T> should be called.
903/// However, this function will still work for a non-TObject, provided that
904/// the calling application cast the return type to the correct type (which
905/// is the actual type of the object).
906///
907/// ### The Get<T> Method
908/// The method Get<T> offers better protection and avoids the need for any
909/// cast:
910/// ~~~{.cpp}
911/// auto objPtr = directory->Get<MyClass>("some object");
912/// if (objPtr) { ... the object exist and inherits from MyClass ... }
913/// ~~~
914///
915/// ### Very important note about inheritance
916/// In case the class of this object derives from TObject but not
917/// as a first inheritance, one must use dynamic_cast<>().
918///
919/// #### Example 1 - Normal case:
920///
921/// class MyClass : public TObject, public AnotherClass
922///
923/// then on return, one can adopt a C style cast:
924///
925/// auto objPtr = (MyClass*)directory->Get("some object of MyClass");
926///
927/// #### Example 2 - Special case:
928///
929/// class MyClass : public AnotherClass, public TObject
930///
931/// then on return, one must do:
932///
933/// auto objPtr = dynamic_cast<MyClass*>(directory->Get("some object of MyClass"));
934///
935/// Of course, dynamic_cast<> can also be used in the example 1.
936///
938TObject *TDirectoryFile::Get(const char *namecycle)
939{
940 Short_t cycle;
941 char name[kMaxLen];
942
943 DecodeNameCycle(namecycle, name, cycle, kMaxLen);
944 Int_t nch = strlen(name);
945 for (Int_t i = nch-1; i > 0; i--) {
946 if (name[i] == '/') {
947 name[i] = 0;
948 TDirectory* dirToSearch=GetDirectory(name);
949 const char *subnamecycle = namecycle + i + 1;
950 name[i] = '/';
951 return dirToSearch?dirToSearch->Get(subnamecycle):0;
952 }
953 }
954 const char *namobj = name;
955
956//*-*---------------------Case of Object in memory---------------------
957// ========================
958 TObject *idcur = fList ? fList->FindObject(namobj) : nullptr;
959 if (idcur) {
960 if (idcur==this && strlen(namobj)!=0) {
961 // The object has the same name has the directory and
962 // that's what we picked-up! We just need to ignore
963 // it ...
964 idcur = nullptr;
965 } else if (cycle == 9999) {
966 return idcur;
967 } else {
968 if (idcur->InheritsFrom(TCollection::Class()))
969 idcur->Delete(); // delete also list elements
970 delete idcur;
971 idcur = nullptr;
972 }
973 }
974
975//*-*---------------------Case of Key---------------------
976// ===========
977 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
978 if (!listOfKeys) {
979 Error("Get", "Unexpected type of TDirectoryFile::fKeys!");
980 return nullptr;
981 }
982
983 if (const TList *keyList = listOfKeys->GetListForObject(namobj)) {
984 for (auto key: TRangeDynCast<TKey>(*keyList)) {
985 if (key && !strcmp(key->GetName(), namobj)
986 && (cycle == 9999 || cycle == key->GetCycle())) {
987 TDirectory::TContext ctxt(this);
988 return key->ReadObj();
989 }
990 }
991 }
992
993 return nullptr;
994}
995
996////////////////////////////////////////////////////////////////////////////////
997/// Return pointer to object identified by namecycle.
998///
999/// The returned object may or may not derive from TObject.
1000///
1001/// - namecycle has the format name;cycle
1002/// - name = * is illegal, cycle = * is illegal
1003/// - cycle = "" or cycle = 9999 ==> apply to a memory object
1004///
1005/// ## Very important note
1006/// The calling application must cast the returned object to
1007/// the final type, e.g.
1008///
1009/// auto objPtr = (MyClass*)directory->GetObject("some object of MyClass");
1011void *TDirectoryFile::GetObjectUnchecked(const char *namecycle)
1012{
1013 return GetObjectChecked(namecycle,(TClass*)nullptr);
1014}
1015
1016////////////////////////////////////////////////////////////////////////////////
1017/// See documentation of TDirectoryFile::GetObjectCheck(const char *namecycle, const TClass *cl)
1019void *TDirectoryFile::GetObjectChecked(const char *namecycle, const char* classname)
1020{
1021 return GetObjectChecked(namecycle,TClass::GetClass(classname));
1022}
1023
1024
1025////////////////////////////////////////////////////////////////////////////////
1026/// Return pointer to object identified by namecycle if and only if the actual
1027/// object is a type suitable to be stored as a pointer to a "expectedClass"
1028/// If expectedClass is null, no check is performed.
1029///
1030/// - namecycle has the format name;cycle
1031/// - name = * is illegal, cycle = * is illegal
1032/// - cycle = "" or cycle = 9999 ==> apply to a memory object
1033///
1034/// ### Very important note
1035/// The calling application must cast the returned pointer to
1036/// the type described by the 2 arguments (i.e. cl):
1037///
1038/// auto objPtr = (MyClass*)directory->GetObjectChecked("some object of MyClass","MyClass"));
1039///
1040/// Note: We recommend using the method TDirectoryFile::Get<T>:
1041/// ~~~{.cpp}
1042/// auto objPtr = directory->Get<MyClass>("some object inheriting from MyClass");
1043/// if (objPtr) { ... we found what we are looking for ... }
1044/// ~~~
1046void *TDirectoryFile::GetObjectChecked(const char *namecycle, const TClass* expectedClass)
1047{
1048
1049 // If the name is invalid, issue an error message and return a nullptr
1050 if (!namecycle || '\0' == namecycle[0]) {
1051 Error("GetObjectChecked", "The provided key name is invalid.");
1052 return nullptr;
1053 }
1054
1055 Short_t cycle;
1056 char name[kMaxLen];
1057
1058 DecodeNameCycle(namecycle, name, cycle, kMaxLen);
1059 Int_t nch = strlen(name);
1060 for (Int_t i = nch-1; i > 0; i--) {
1061 if (name[i] == '/') {
1062 name[i] = 0;
1063 TDirectory* dirToSearch=GetDirectory(name);
1064 const char *subnamecycle = namecycle + i + 1;
1065 name[i] = '/';
1066 if (dirToSearch) {
1067 return dirToSearch->GetObjectChecked(subnamecycle, expectedClass);
1068 } else {
1069 return nullptr;
1070 }
1071 }
1072 }
1073 const char *namobj = name;
1074
1075//*-*---------------------Case of Object in memory---------------------
1076// ========================
1077 if (expectedClass==0 || expectedClass->IsTObject()) {
1078 TObject *objcur = fList ? fList->FindObject(namobj) : nullptr;
1079 if (objcur) {
1080 if (objcur==this && strlen(namobj)!=0) {
1081 // The object has the same name has the directory and
1082 // that's what we picked-up! We just need to ignore
1083 // it ...
1084 objcur = nullptr;
1085 } else if (cycle == 9999) {
1086 // Check type
1087 if (expectedClass && objcur->IsA()->GetBaseClassOffset(expectedClass) == -1) return nullptr;
1088 else return objcur;
1089 } else {
1090 if (objcur->InheritsFrom(TCollection::Class()))
1091 objcur->Delete(); // delete also list elements
1092 delete objcur;
1093 objcur = nullptr;
1094 }
1095 }
1096 }
1097
1098//*-*---------------------Case of Key---------------------
1099// ===========
1100 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1101 if (!listOfKeys) {
1102 Error("GetObjectChecked", "Unexpected type of TDirectoryFile::fKeys!");
1103 return nullptr;
1104 }
1105
1106 if (const TList *keyList = listOfKeys->GetListForObject(namobj)) {
1107 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1108 if (key && !strcmp(key->GetName(), namobj)
1109 && (cycle == 9999 || cycle == key->GetCycle())) {
1110 TDirectory::TContext ctxt(this);
1111 return key->ReadObjectAny(expectedClass);
1112 }
1113 }
1114 }
1115
1116 return nullptr;
1117}
1118
1119////////////////////////////////////////////////////////////////////////////////
1120/// Return the buffer size to create new TKeys.
1121///
1122/// If the stored fBufferSize is null, the value returned is the average
1123/// buffer size of objects in the file so far.
1126{
1127 if (fBufferSize <= 0) return fFile->GetBestBuffer();
1128 else return fBufferSize;
1129}
1130
1131
1132////////////////////////////////////////////////////////////////////////////////
1133/// Return pointer to key with name,cycle
1134///
1135/// if cycle = 9999 returns highest cycle
1137TKey *TDirectoryFile::GetKey(const char *name, Short_t cycle) const
1138{
1139 if (!fKeys) return nullptr;
1140
1141 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1142 if (!listOfKeys) {
1143 Error("GetKey", "Unexpected type of TDirectoryFile::fKeys!");
1144 return nullptr;
1145 }
1146
1147 if (const TList *keyList = listOfKeys->GetListForObject(name)) {
1148 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1149 if (key && !strcmp(key->GetName(), name)
1150 && (cycle == 9999 || cycle >= key->GetCycle())) {
1151 return key;
1152 }
1153 }
1154 }
1155
1156 return nullptr;
1157}
1158
1159////////////////////////////////////////////////////////////////////////////////
1160/// List Directory contents
1161///
1162/// Indentation is used to identify the directory tree
1163/// Subdirectories are listed first, then objects in memory, then objects on the file
1164///
1165/// The option can has the following format: <b>[-d |-m][<regexp>]</b>
1166/// Options:
1167/// - -d: only list objects in the file
1168/// - -m: only list objects in memory
1169/// The <regexp> will be used to match the name of the objects.
1170/// By default memory and disk objects are listed.
1172void TDirectoryFile::ls(Option_t *option) const
1173{
1175 std::cout <<ClassName()<<"*\t\t"<<GetName()<<"\t"<<GetTitle()<<std::endl;
1177
1178 TString opta = option;
1179 TString opt = opta.Strip(TString::kBoth);
1180 Bool_t memobj = kTRUE;
1181 Bool_t diskobj = kTRUE;
1182 TString reg = "*";
1183 if (opt.BeginsWith("-m")) {
1184 diskobj = kFALSE;
1185 if (opt.Length() > 2)
1186 reg = opt(2,opt.Length());
1187 } else if (opt.BeginsWith("-d")) {
1188 memobj = kFALSE;
1189 if (opt.Length() > 2)
1190 reg = opt(2,opt.Length());
1191 } else if (!opt.IsNull())
1192 reg = opt;
1193
1194 TRegexp re(reg, kTRUE);
1195
1196 if (memobj) {
1197 TObject *obj;
1198 TIter nextobj(fList);
1199 while ((obj = (TObject *) nextobj())) {
1200 TString s = obj->GetName();
1201 if (s.Index(re) == kNPOS) continue;
1202 obj->ls(option); //*-* Loop on all the objects in memory
1203 }
1204 }
1205
1206 if (diskobj && fKeys) {
1207 //*-* Loop on all the keys
1208 TObjLink *lnk = fKeys->FirstLink();
1209 while (lnk) {
1210 TKey *key = (TKey*)lnk->GetObject();
1211 TString s = key->GetName();
1212 if (s.Index(re) == kNPOS) continue;
1213 bool first = (lnk->Prev() == nullptr) || (s != lnk->Prev()->GetObject()->GetName());
1214 bool hasbackup = (lnk->Next() != nullptr) && (s == lnk->Next()->GetObject()->GetName());
1215 if (first)
1216 if (hasbackup)
1217 key->ls(true);
1218 else
1219 key->ls();
1220 else
1221 key->ls(false);
1222 lnk = lnk->Next();
1223 }
1224 }
1226}
1227
1228////////////////////////////////////////////////////////////////////////////////
1229/// Interface to TFile::Open
1231TFile *TDirectoryFile::OpenFile(const char *name, Option_t *option,const char *ftitle, Int_t compress, Int_t netopt)
1232{
1233 return TFile::Open(name,option,ftitle,compress,netopt);
1234
1235}
1236
1237////////////////////////////////////////////////////////////////////////////////
1238/// Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
1239///
1240/// Returns 0 in case of error or if a sub-directory (hierarchy) with the requested
1241/// name already exists.
1242/// returnExistingDirectory returns a pointer to an already existing sub-directory instead of 0.
1243/// Returns a pointer to the created sub-directory or to the top sub-directory of
1244/// the hierarchy (in the above example, the returned TDirectory * always points
1245/// to "a").
1247TDirectory *TDirectoryFile::mkdir(const char *name, const char *title, Bool_t returnExistingDirectory)
1248{
1249 if (!name || !title || !name[0]) return nullptr;
1250 if (!title[0]) title = name;
1251 if (GetKey(name)) {
1252 if (returnExistingDirectory)
1253 return (TDirectoryFile*) GetDirectory(name);
1254 else {
1255 Error("mkdir","An object with name %s exists already",name);
1256 return nullptr;
1257 }
1258 }
1259 TDirectoryFile *newdir = nullptr;
1260 if (const char *slash = strchr(name,'/')) {
1261 TString workname(name, Long_t(slash-name));
1262 TDirectoryFile *tmpdir = nullptr;
1263 GetObject(workname.Data(), tmpdir);
1264 if (!tmpdir) {
1265 tmpdir = (TDirectoryFile*)mkdir(workname.Data(),title);
1266 if (!tmpdir) return nullptr;
1267 }
1268 if (!newdir) newdir = tmpdir;
1269 tmpdir->mkdir(slash+1);
1270 return newdir;
1271 }
1272
1273 TDirectory::TContext ctxt(this);
1274
1275 newdir = new TDirectoryFile(name, title, "", this);
1276
1277 return newdir;
1278}
1279
1280////////////////////////////////////////////////////////////////////////////////
1281/// Purge lowest key cycles in a directory.
1282///
1283/// By default, only the highest cycle of a key is kept. Keys for which
1284/// the "KEEP" flag has been set are not removed. See TKey::Keep().
1285/// NOTE: This does not reduce the size of a TFile--
1286/// the space is simply freed up to be overwritten.
1289{
1290 if (!IsWritable()) return;
1291
1292 TDirectory::TContext ctxt(this);
1293
1294 TKey *key;
1296
1297 while ((key = (TKey*)prev())) { // reverse loop on keys
1298 TKey *keyprev = (TKey*)GetListOfKeys()->Before(key);
1299 if (!keyprev) break;
1300 if (key->GetKeep() == 0) {
1301 if (strcmp(key->GetName(), keyprev->GetName()) == 0) {
1302 key->Delete(); // Remove from the file.
1303 delete key; // Remove from memory.
1304 }
1305 }
1306 }
1307 TFile *f = GetFile();
1308 if (fModified && f) {
1309 WriteKeys(); // Write new keys structure
1310 WriteDirHeader(); // Write new directory header
1311 f->WriteFree(); // Write new free segments list
1312 f->WriteHeader(); // Write new file header
1313 }
1314}
1315
1316////////////////////////////////////////////////////////////////////////////////
1317/// Read objects from a ROOT file directory into memory.
1318///
1319/// If an object is already in memory, the memory copy is deleted
1320/// and the object is again read from the file.
1321/// If opt=="dirs", only subdirectories will be read
1322/// If opt=="dirs*" complete directory tree will be read
1325{
1326 TDirectory::TContext ctxt(this);
1327
1328 TKey *key;
1329 TIter next(GetListOfKeys());
1330
1331 Bool_t readdirs = ((opt!=0) && ((strcmp(opt,"dirs")==0) || (strcmp(opt,"dirs*")==0)));
1332
1333 if (readdirs)
1334 while ((key = (TKey *) next())) {
1335
1336 //if (strcmp(key->GetClassName(),"TDirectory")!=0) continue;
1337 if (strstr(key->GetClassName(),"TDirectory")==0) continue;
1338
1339 TDirectory *dir = GetDirectory(key->GetName(), kTRUE, "ReadAll");
1340
1341 if ((dir!=0) && (strcmp(opt,"dirs*")==0)) dir->ReadAll("dirs*");
1342 }
1343 else
1344 while ((key = (TKey *) next())) {
1345 TObject *thing = GetList()->FindObject(key->GetName());
1346 if (thing) { delete thing; }
1347 key->ReadObj();
1348 }
1349}
1350
1351////////////////////////////////////////////////////////////////////////////////
1352/// Read the linked list of keys.
1353///
1354/// Every directory has a linked list (fKeys). This linked list has been
1355/// written on the file via WriteKeys as a single data record.
1356///
1357/// It is interesting to call this function in the following situation.
1358/// Assume another process1 is connecting this directory in Update mode
1359/// - Process1 is adding/updating objects in this directory
1360/// - You want to see the latest status from process1.
1361/// Example Process1:
1362/// ~~~{.cpp}
1363/// obj1.Write();
1364/// obj2.Write();
1365/// gDirectory->SaveSelf();
1366/// ~~~
1367///
1368/// Example Process2:
1369/// ~~~{.cpp}
1370/// gDirectory->ReadKeys();
1371/// obj1->Draw();
1372/// ~~~
1373/// This is an efficient way (without opening/closing files) to view
1374/// the latest updates of a file being modified by another process
1375/// as it is typically the case in a data acquisition system.
1378{
1379 if (!fFile || !fKeys) return 0;
1380
1381 if (!fFile->IsBinary())
1382 return fFile->DirReadKeys(this);
1383
1384 TDirectory::TContext ctxt(this);
1385
1386 char *buffer;
1387 if (forceRead) {
1388 fKeys->Delete();
1389 //In case directory was updated by another process, read new
1390 //position for the keys
1392 char *header = new char[nbytes];
1393 buffer = header;
1395 if ( fFile->ReadBuffer(buffer,nbytes) ) {
1396 // ReadBuffer return kTRUE in case of failure.
1397 delete [] header;
1398 return 0;
1399 }
1400 buffer += fNbytesName;
1401 Version_t versiondir;
1402 frombuf(buffer,&versiondir);
1403 fDatimeC.ReadBuffer(buffer);
1404 fDatimeM.ReadBuffer(buffer);
1405 frombuf(buffer, &fNbytesKeys);
1406 frombuf(buffer, &fNbytesName);
1407 if (versiondir > 1000) {
1408 frombuf(buffer, &fSeekDir);
1409 frombuf(buffer, &fSeekParent);
1410 frombuf(buffer, &fSeekKeys);
1411 } else {
1412 Int_t sdir,sparent,skeys;
1413 frombuf(buffer, &sdir); fSeekDir = (Long64_t)sdir;
1414 frombuf(buffer, &sparent); fSeekParent = (Long64_t)sparent;
1415 frombuf(buffer, &skeys); fSeekKeys = (Long64_t)skeys;
1416 }
1417 delete [] header;
1418 }
1419
1420 Int_t nkeys = 0;
1421 Long64_t fsize = fFile->GetSize();
1422 if ( fSeekKeys > 0) {
1423 TKey *headerkey = new TKey(fSeekKeys, fNbytesKeys, this);
1424 headerkey->ReadFile();
1425 buffer = headerkey->GetBuffer();
1426 headerkey->ReadKeyBuffer(buffer);
1427
1428 TKey *key;
1429 frombuf(buffer, &nkeys);
1430 for (Int_t i = 0; i < nkeys; i++) {
1431 key = new TKey(this);
1432 key->ReadKeyBuffer(buffer);
1433 if (key->GetSeekKey() < 64 || key->GetSeekKey() > fsize) {
1434 Error("ReadKeys","reading illegal key, exiting after %d keys",i);
1435 fKeys->Remove(key);
1436 nkeys = i;
1437 break;
1438 }
1439 if (key->GetSeekPdir() < 64 || key->GetSeekPdir() > fsize) {
1440 Error("ReadKeys","reading illegal key, exiting after %d keys",i);
1441 fKeys->Remove(key);
1442 nkeys = i;
1443 break;
1444 }
1445 fKeys->Add(key);
1446 }
1447 delete headerkey;
1448 }
1449
1450 return nkeys;
1451}
1452
1453
1454////////////////////////////////////////////////////////////////////////////////
1455/// Read object with keyname from the current directory
1456///
1457/// Read contents of object with specified name from the current directory.
1458/// First the key with keyname is searched in the current directory,
1459/// next the key buffer is deserialized into the object.
1460/// The object must have been created before via the default constructor.
1461/// See TObject::Write().
1463Int_t TDirectoryFile::ReadTObject(TObject *obj, const char *keyname)
1464{
1465 if (!fFile) { Error("ReadTObject","No file open"); return 0; }
1466 auto listOfKeys = dynamic_cast<THashList *>(GetListOfKeys());
1467 if (!listOfKeys) {
1468 Error("ReadTObject", "Unexpected type of TDirectoryFile::fKeys!");
1469 return 0;
1470 }
1471
1472 if (const TList *keyList = listOfKeys->GetListForObject(keyname)) {
1473 for (auto key: TRangeDynCast<TKey>(*keyList)) {
1474 if (key && !strcmp(key->GetName(), keyname) ) {
1475 return key->Read(obj);
1476 }
1477 }
1478 }
1479
1480 Error("ReadTObject","Key not found");
1481 return 0;
1482}
1483
1484////////////////////////////////////////////////////////////////////////////////
1485/// Reset the TDirectory after its content has been merged into another
1486/// Directory.
1487///
1488/// This returns the TDirectoryFile object back to its state
1489/// before any data has been written to the file.
1490/// The object in the in-memory list are assumed to also have been reset.
1493{
1494 // There is nothing to reset in the base class (TDirectory) since
1495 // we do want to key the list of in-memory object as is.
1496 fModified = kFALSE;
1497 // Does not change: fWritable
1498 fDatimeC.Set();
1499 fDatimeM.Set();
1500 fNbytesKeys = 0; // updated when the keys are written
1501 fNbytesName = 0; // updated by Init
1502 // Does not change (user customization): fBufferSize;
1503 fSeekDir = 0; // updated by Init
1504 fSeekParent = 0; // updated by Init
1505 fSeekKeys = 0; // updated by Init
1506 // Does not change: fFile
1507 TKey *key = fKeys ? (TKey*)fKeys->FindObject(fName) : nullptr;
1508 TClass *cl = IsA();
1509 if (key) {
1510 cl = TClass::GetClass(key->GetClassName());
1511 }
1512 // NOTE: We should check that the content is really mergeable and in
1513 // the in-mmeory list, before deleting the keys.
1514 if (fKeys) {
1515 fKeys->Delete("slow");
1516 }
1517
1519
1520 // Do the same with the sub-directories.
1521 TIter next(GetList());
1522 TObject *idcur;
1523 while ((idcur = next())) {
1524 if (idcur->IsA() == TDirectoryFile::Class()) {
1525 ((TDirectoryFile*)idcur)->ResetAfterMerge(info);
1526 }
1527 }
1528
1529}
1530
1531////////////////////////////////////////////////////////////////////////////////
1532/// Removes subdirectory from the directory
1533///
1534/// When directory is deleted, all keys in all subdirectories will be
1535/// read first and deleted from file (if exists)
1536/// Equivalent call is Delete("name;*");
1538void TDirectoryFile::rmdir(const char *name)
1539{
1540 if (!name || (*name==0)) return;
1541
1542 TString mask(name);
1543 mask += ";*";
1544 Delete(mask);
1545}
1546
1547////////////////////////////////////////////////////////////////////////////////
1548/// Save recursively all directory keys and headers
1551{
1552 TDirectory::TContext ctxt(this);
1553
1554 SaveSelf();
1555
1556 // recursively save all sub-directories
1557 if (fList && fList->FirstLink()) {
1558 auto lnk = fList->FirstLink()->shared_from_this();
1559 while (lnk) {
1560 TObject *idcur = lnk->GetObject();
1561 if (idcur && idcur->InheritsFrom(TDirectoryFile::Class())) {
1562 TDirectoryFile *dir = (TDirectoryFile *)idcur;
1563 dir->Save();
1564 }
1565 lnk = lnk->NextSP();
1566 }
1567 }
1568}
1569
1570////////////////////////////////////////////////////////////////////////////////
1571/// Save object in filename.
1572///
1573/// If filename is 0 or "", a file with "objectname.root" is created.
1574/// The name of the key is the object name.
1575/// If the operation is successful, it returns the number of bytes written to the file
1576/// otherwise it returns 0.
1577/// By default a message is printed. Use option "q" to not print the message.
1578/// If filename contains ".json" extension, JSON representation of the object
1579/// will be created and saved in the text file. Such file can be used in
1580/// JavaScript ROOT (https://root.cern.ch/js/) to display object in web browser
1581/// When creating JSON file, option string may contain compression level from 0 to 3 (default 0)
1583Int_t TDirectoryFile::SaveObjectAs(const TObject *obj, const char *filename, Option_t *option) const
1584{
1585 if (!obj) return 0;
1586 TDirectory *dirsav = gDirectory;
1587 TString fname = filename;
1588 if (!filename || !filename[0]) {
1589 fname.Form("%s.root",obj->GetName());
1590 }
1591 Int_t nbytes = 0;
1592 if (fname.Index(".json") > 0) {
1593 nbytes = TBufferJSON::ExportToFile(fname, obj, option);
1594 } else {
1595 TFile *local = TFile::Open(fname.Data(),"recreate");
1596 if (!local) return 0;
1597 nbytes = obj->Write();
1598 delete local;
1599 if (dirsav) dirsav->cd();
1600 }
1601 TString opt = option;
1602 opt.ToLower();
1603 if (!opt.Contains("q")) {
1604 if (!gSystem->AccessPathName(fname.Data())) obj->Info("SaveAs", "ROOT file %s has been created", fname.Data());
1605 }
1606 return nbytes;
1607}
1608
1609////////////////////////////////////////////////////////////////////////////////
1610/// Save Directory keys and header
1611///
1612/// If the directory has been modified (fModified set), write the keys
1613/// and the directory header. This function assumes the cd is correctly set.
1614///
1615/// It is recommended to use this function in the following situation:
1616/// Assume a process1 using a directory in Update mode
1617/// - New objects or modified objects have been written to the directory.
1618/// - You do not want to close the file.
1619/// - You want your changes be visible from another process2 already connected
1620/// to this directory in read mode.
1621/// - Call this function.
1622/// - In process2, use TDirectoryFile::ReadKeys to refresh the directory.
1625{
1626 if (IsWritable() && (fModified || force) && fFile) {
1627 Bool_t dowrite = kTRUE;
1628 if (fFile->GetListOfFree())
1629 dowrite = fFile->GetListOfFree()->First() != nullptr;
1630 if (dowrite) {
1631 TDirectory *dirsav = gDirectory;
1632 if (dirsav != this) cd();
1633 WriteKeys(); //*-*- Write keys record
1634 WriteDirHeader(); //*-*- Update directory record
1635 if (dirsav && dirsav != this) dirsav->cd();
1636 }
1637 }
1638}
1639
1640////////////////////////////////////////////////////////////////////////////////
1641/// Set the default buffer size when creating new TKeys.
1642///
1643/// See also TDirectoryFile::GetBufferSize
1646{
1647 fBufferSize = bufsize;
1648}
1649
1650////////////////////////////////////////////////////////////////////////////////
1651/// Find the action to be executed in the dictionary of the parent class
1652/// and store the corresponding exec number into fBits.
1653///
1654/// This function searches a data member in the class of parent with an
1655/// offset corresponding to this.
1656/// If a comment "TEXEC:" is found in the comment field of the data member,
1657/// the function stores the exec identifier of the exec statement
1658/// following this keyword.
1661{
1662 Int_t offset = (char*)ref - (char*)parent;
1663 TClass *cl = parent->IsA();
1664 cl->BuildRealData(parent);
1666 TIter next(info->GetElements());
1667 TStreamerElement *element;
1668 while((element = (TStreamerElement*)next())) {
1669 if (element->GetOffset() != offset) continue;
1670 Int_t execid = element->GetExecID();
1671 if (execid > 0) ref->SetBit(execid << 8);
1672 return;
1673 }
1674}
1675
1676////////////////////////////////////////////////////////////////////////////////
1677/// Set the new value of fWritable recursively
1680{
1681 TDirectory::TContext ctxt(this);
1682
1683 fWritable = writable;
1684
1685 // recursively set all sub-directories
1686 if (fList) {
1687 TObject *idcur;
1688 TIter next(fList);
1689 while ((idcur = next())) {
1690 if (idcur->InheritsFrom(TDirectoryFile::Class())) {
1691 TDirectoryFile *dir = (TDirectoryFile*)idcur;
1692 dir->SetWritable(writable);
1693 }
1694 }
1695 }
1696}
1697
1698
1699////////////////////////////////////////////////////////////////////////////////
1700/// Return the size in bytes of the directory header
1703{
1704 Int_t nbytes = 22;
1705
1706 nbytes += fDatimeC.Sizeof();
1707 nbytes += fDatimeM.Sizeof();
1708 nbytes += fUUID.Sizeof();
1709 //assume that the file may be above 2 Gbytes if file version is > 4
1710 if (fFile && fFile->GetVersion() >= 40000) nbytes += 12;
1711 return nbytes;
1712}
1713
1714
1715////////////////////////////////////////////////////////////////////////////////
1716/// Stream a class object
1717
1718void TDirectoryFile::Streamer(TBuffer &b)
1719{
1720 Version_t v,version;
1721 if (b.IsReading()) {
1722 BuildDirectoryFile((TFile*)b.GetParent(), nullptr);
1723 if (fFile && fFile->IsWritable()) fWritable = kTRUE;
1724
1725 if (fFile && !fFile->IsBinary()) {
1726 Version_t R__v = b.ReadVersion(0, 0);
1727
1728 TClass* dirclass = (R__v < 5) ? TDirectory::Class() : TDirectoryFile::Class();
1729
1730 b.ClassBegin(dirclass, R__v);
1731
1732 TString sbuf;
1733
1734 b.ClassMember("CreateTime","TString");
1735 sbuf.Streamer(b);
1736 TDatime timeC(sbuf.Data());
1737 fDatimeC = timeC;
1738
1739 b.ClassMember("ModifyTime","TString");
1740 sbuf.Streamer(b);
1741 TDatime timeM(sbuf.Data());
1742 fDatimeM = timeM;
1743
1744 b.ClassMember("UUID","TString");
1745 sbuf.Streamer(b);
1746 TUUID id(sbuf.Data());
1747 fUUID = id;
1748
1749 b.ClassEnd(dirclass);
1750
1751 fSeekKeys = 0; // read keys later in the TKeySQL class
1752 } else {
1753 b >> version;
1754 fDatimeC.Streamer(b);
1755 fDatimeM.Streamer(b);
1756 b >> fNbytesKeys;
1757 b >> fNbytesName;
1758 if (version > 1000) {
1760 b >> fSeekDir;
1761 b >> fSeekParent;
1762 b >> fSeekKeys;
1763 } else {
1764 Int_t sdir,sparent,skeys;
1765 b >> sdir; fSeekDir = (Long64_t)sdir;
1766 b >> sparent; fSeekParent = (Long64_t)sparent;
1767 b >> skeys; fSeekKeys = (Long64_t)skeys;
1768 }
1769 v = version%1000;
1770 if (v == 2) {
1772 } else if (v > 2) {
1773 fUUID.Streamer(b);
1774 }
1775 }
1776 fList->UseRWLock();
1778 gROOT->GetUUIDs()->AddUUID(fUUID,this);
1779 if (fSeekKeys) ReadKeys();
1780 } else {
1781 if (fFile && !fFile->IsBinary()) {
1782 b.WriteVersion(TDirectoryFile::Class());
1783
1784 TString sbuf;
1785
1786 b.ClassBegin(TDirectoryFile::Class());
1787
1788 b.ClassMember("CreateTime","TString");
1789 sbuf = fDatimeC.AsSQLString();
1790 sbuf.Streamer(b);
1791
1792 b.ClassMember("ModifyTime","TString");
1793 fDatimeM.Set();
1794 sbuf = fDatimeM.AsSQLString();
1795 sbuf.Streamer(b);
1796
1797 b.ClassMember("UUID","TString");
1798 sbuf = fUUID.AsString();
1799 sbuf.Streamer(b);
1800
1801 b.ClassEnd(TDirectoryFile::Class());
1802 } else {
1803 version = TDirectoryFile::Class_Version();
1804 if (fFile && fFile->GetEND() > TFile::kStartBigFile) version += 1000;
1805 b << version;
1806 fDatimeC.Streamer(b);
1807 fDatimeM.Streamer(b);
1808 b << fNbytesKeys;
1809 b << fNbytesName;
1810 if (version > 1000) {
1811 b << fSeekDir;
1812 b << fSeekParent;
1813 b << fSeekKeys;
1814 } else {
1815 b << (Int_t)fSeekDir;
1816 b << (Int_t)fSeekParent;
1817 b << (Int_t)fSeekKeys;
1818 }
1819 fUUID.Streamer(b);
1820 if (version <=1000) for (Int_t i=0;i<3;i++) b << Int_t(0);
1821 }
1822 }
1823}
1824
1825////////////////////////////////////////////////////////////////////////////////
1826/// Write all objects in memory to disk.
1827///
1828/// Loop on all objects in memory (including subdirectories).
1829/// A new key is created in the keys linked list for each object.
1830/// For allowed options see TObject::Write().
1831/// The directory header info is rewritten on the directory header record.
1833Int_t TDirectoryFile::Write(const char *, Int_t opt, Int_t bufsize)
1834{
1835 if (!IsWritable()) return 0;
1836 TDirectory::TContext ctxt(this);
1837
1838 // Loop on all objects (including subdirs)
1839 TIter next(fList);
1840 TObject *obj;
1841 Int_t nbytes = 0;
1842 while ((obj=next())) {
1843 nbytes += obj->Write(0,opt,bufsize);
1844 }
1845 if (R__likely(!(opt & kOnlyPrepStep)))
1846 SaveSelf(kTRUE); // force save itself
1847
1848 return nbytes;
1849}
1850
1851////////////////////////////////////////////////////////////////////////////////
1852/// One can not save a const TDirectory object.
1854Int_t TDirectoryFile::Write(const char *n, Int_t opt, Int_t bufsize) const
1855{
1856 Error("Write const","A const TDirectory object should not be saved. We try to proceed anyway.");
1857 return const_cast<TDirectoryFile*>(this)->Write(n, opt, bufsize);
1858}
1859
1860////////////////////////////////////////////////////////////////////////////////
1861/// Write object obj to this directory.
1862///
1863/// The data structure corresponding to this object is serialized.
1864/// The corresponding buffer is written to this directory
1865/// with an associated key with name "name".
1866///
1867/// Writing an object to a file involves the following steps:
1868/// - Creation of a support TKey object in the directory. The TKey object
1869/// creates a TBuffer object.
1870/// - The TBuffer object is filled via the class::Streamer function.
1871/// - If the file is compressed (default) a second buffer is created to hold
1872/// the compressed buffer.
1873/// - Reservation of the corresponding space in the file by looking in the
1874/// TFree list of free blocks of the file.
1875/// - The buffer is written to the file.
1876///
1877/// By default, the buffersize will be taken from the average buffer size
1878/// of all objects written to the current file so far.
1879/// Use TDirectoryFile::SetBufferSize to force a given buffer size.
1880///
1881/// If a name is specified, it will be the name of the key.
1882/// If name is not given, the name of the key will be the name as returned
1883/// by obj->GetName().
1884///
1885/// The option can be a combination of:
1886/// - "SingleKey"
1887/// - "Overwrite"
1888/// - "WriteDelete"
1889/// Using the "Overwrite" option a previous key with the same name is
1890/// overwritten. The previous key is deleted before writing the new object.
1891/// Using the "WriteDelete" option a previous key with the same name is
1892/// deleted only after the new object has been written. This option
1893/// is safer than kOverwrite but it is slower.
1894/// The "SingleKey" option is only used by TCollection::Write() to write
1895/// a container with a single key instead of each object in the container
1896/// with its own key.
1897/// An object is read from this directory via TDirectoryFile::Get.
1898/// The function returns the total number of bytes written to the directory.
1899/// It returns 0 if the object cannot be written.
1900///
1901/// WARNING: avoid special characters like '^','$','.' in the name as they
1902/// are used by the regular expression parser (see TRegexp).
1904Int_t TDirectoryFile::WriteTObject(const TObject *obj, const char *name, Option_t *option, Int_t bufsize)
1905{
1906 TDirectory::TContext ctxt(this);
1907
1908 if (fFile==0) {
1909 const char *objname = "no name specified";
1910 if (name) objname = name;
1911 else if (obj) objname = obj->GetName();
1912 Error("WriteTObject","The current directory (%s) is not associated with a file. The object (%s) has not been written.",GetName(),objname);
1913 return 0;
1914 }
1915
1916 if (!fFile->IsWritable()) {
1918 // Do not print the error if the file already had a SysError.
1919 Error("WriteTObject","Directory %s is not writable", fFile->GetName());
1920 }
1921 return 0;
1922 }
1923
1924 if (!obj) return 0;
1925
1926 TString opt = option;
1927 opt.ToLower();
1928
1929 TKey *key=0, *oldkey=0;
1930 Int_t bsize = GetBufferSize();
1931 if (bufsize > 0) bsize = bufsize;
1932
1933 const char *oname;
1934 if (name && *name)
1935 oname = name;
1936 else
1937 oname = obj->GetName();
1938
1939 // Remove trailing blanks in object name
1940 Int_t nch = strlen(oname);
1941 char *newName = nullptr;
1942 if (nch && oname[nch-1] == ' ') {
1943 newName = new char[nch+1];
1944 strlcpy(newName,oname,nch+1);
1945 for (Int_t i=0;i<nch;i++) {
1946 if (newName[nch-i-1] != ' ') break;
1947 newName[nch-i-1] = 0;
1948 }
1949 oname = newName;
1950 }
1951
1952 if (opt.Contains("overwrite")) {
1953 //One must use GetKey. FindObject would return the lowest cycle of the key!
1954 //key = (TKey*)gDirectory->GetListOfKeys()->FindObject(oname);
1955 key = GetKey(oname);
1956 if (key) {
1957 key->Delete();
1958 delete key;
1959 }
1960 }
1961 if (opt.Contains("writedelete")) {
1962 oldkey = GetKey(oname);
1963 }
1964 key = fFile->CreateKey(this, obj, oname, bsize);
1965 if (newName) delete [] newName;
1966
1967 if (!key->GetSeekKey()) {
1968 fKeys->Remove(key);
1969 delete key;
1970 if (bufsize) fFile->SetBufferSize(bufsize);
1971 return 0;
1972 }
1973 fFile->SumBuffer(key->GetObjlen());
1974 Int_t nbytes = key->WriteFile(0);
1976 if (bufsize) fFile->SetBufferSize(bufsize);
1977 return 0;
1978 }
1979 if (oldkey) {
1980 oldkey->Delete();
1981 delete oldkey;
1982 }
1983 if (bufsize) fFile->SetBufferSize(bufsize);
1984
1985 return nbytes;
1986}
1987
1988////////////////////////////////////////////////////////////////////////////////
1989/// Write object from pointer of class classname in this directory.
1990///
1991/// obj may not derive from TObject. See TDirectoryFile::WriteTObject for comments
1992///
1993/// ## Very important note
1994/// The value passed as 'obj' needs to be from a pointer to the type described by classname.
1995/// For example:
1996/// ~~~{.cpp}
1997/// TopClass *top;
1998/// BottomClass *bottom;
1999/// top = bottom;
2000/// ~~~
2001/// you can do:
2002/// ~~~{.cpp}
2003/// directory->WriteObjectAny(top,"top","name of object");
2004/// directory->WriteObjectAny(bottom,"bottom","name of object");
2005/// ~~~
2006/// <b>BUT YOU CAN NOT DO</b> the following since it will fail with multiple inheritance:
2007/// ~~~{.cpp}
2008/// directory->WriteObjectAny(top,"bottom","name of object");
2009/// ~~~
2010/// We <b>STRONGLY</b> recommend to use
2011/// ~~~{.cpp}
2012/// TopClass *top = ....;
2013/// directory->WriteObject(top,"name of object")
2014/// ~~~
2015/// See also remarks in TDirectoryFile::WriteTObject
2017Int_t TDirectoryFile::WriteObjectAny(const void *obj, const char *classname, const char *name, Option_t *option, Int_t bufsize)
2018{
2019 TClass *cl = TClass::GetClass(classname);
2020 if (!cl) {
2021 TObject *info_obj = *(TObject**)obj;
2022 TVirtualStreamerInfo *info = dynamic_cast<TVirtualStreamerInfo*>(info_obj);
2023 if (!info) {
2024 Error("WriteObjectAny","Unknown class: %s",classname);
2025 return 0;
2026 } else {
2027 cl = info->GetClass();
2028 }
2029 }
2030 return WriteObjectAny(obj,cl,name,option,bufsize);
2031}
2032
2033////////////////////////////////////////////////////////////////////////////////
2034/// Write object of class with dictionary cl in this directory.
2035///
2036/// obj may not derive from TObject
2037/// To get the TClass* cl pointer, one can use
2038///
2039/// TClass *cl = TClass::GetClass("classname");
2040///
2041/// An alternative is to call the function WriteObjectAny above.
2042/// see TDirectoryFile::WriteTObject for comments
2044Int_t TDirectoryFile::WriteObjectAny(const void *obj, const TClass *cl, const char *name, Option_t *option, Int_t bufsize)
2045{
2046 TDirectory::TContext ctxt(this);
2047
2048 if (!fFile) return 0;
2049
2050 if (!cl) {
2051 Error("WriteObject","Unknown type for %s, it can not be written.",name);
2052 return 0;
2053 }
2054
2055 if (!fFile->IsWritable()) {
2057 // Do not print the error if the file already had a SysError.
2058 Error("WriteObject","File %s is not writable", fFile->GetName());
2059 }
2060 return 0;
2061 }
2062
2063 if (!obj) return 0;
2064
2065 const char *className = cl->GetName();
2066 const char *oname;
2067 if (name && *name)
2068 oname = name;
2069 else
2070 oname = className;
2071
2072 if (cl && cl->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(cl->GetCollectionProxy())) {
2073 Error("WriteObjectAny",
2074 "The class requested (%s) for the key name \"%s\""
2075 " is an instance of an stl collection and does not have a compiled CollectionProxy."
2076 " Please generate the dictionary for this collection (%s). No data will be written.",
2077 className, oname, className);
2078 return 0;
2079 }
2080
2081 TKey *key, *oldkey = nullptr;
2082 Int_t bsize = GetBufferSize();
2083 if (bufsize > 0) bsize = bufsize;
2084
2085 TString opt = option;
2086 opt.ToLower();
2087
2088 // Remove trailing blanks in object name
2089 Int_t nch = strlen(oname);
2090 char *newName = nullptr;
2091 if (nch && oname[nch-1] == ' ') {
2092 newName = new char[nch+1];
2093 strlcpy(newName,oname,nch+1);
2094 for (Int_t i=0;i<nch;i++) {
2095 if (newName[nch-i-1] != ' ') break;
2096 newName[nch-i-1] = 0;
2097 }
2098 oname = newName;
2099 }
2100
2101 if (opt.Contains("overwrite")) {
2102 //One must use GetKey. FindObject would return the lowest cycle of the key!
2103 //key = (TKey*)gDirectory->GetListOfKeys()->FindObject(oname);
2104 key = GetKey(oname);
2105 if (key) {
2106 key->Delete();
2107 delete key;
2108 }
2109 }
2110 if (opt.Contains("writedelete")) {
2111 oldkey = GetKey(oname);
2112 }
2113 key = fFile->CreateKey(this, obj, cl, oname, bsize);
2114 if (newName) delete [] newName;
2115
2116 if (!key->GetSeekKey()) {
2117 fKeys->Remove(key);
2118 delete key;
2119 return 0;
2120 }
2121 fFile->SumBuffer(key->GetObjlen());
2122 Int_t nbytes = key->WriteFile(0);
2123 if (fFile->TestBit(TFile::kWriteError)) return 0;
2124
2125 if (oldkey) {
2126 oldkey->Delete();
2127 delete oldkey;
2128 }
2129
2130 return nbytes;
2131}
2132
2133////////////////////////////////////////////////////////////////////////////////
2134/// Overwrite the Directory header record.
2137{
2138 TFile* f = GetFile();
2139 if (!f) return;
2140
2141 if (!f->IsBinary()) {
2142 fDatimeM.Set();
2143 f->DirWriteHeader(this);
2144 return;
2145 }
2146
2147 Int_t nbytes = TDirectoryFile::Sizeof(); //Warning ! TFile has a Sizeof()
2148 char *header = new char[nbytes];
2149 char *buffer = header;
2150 fDatimeM.Set();
2152 Long64_t pointer = fSeekDir + fNbytesName; // do not overwrite the name/title part
2153 fModified = kFALSE;
2154 f->Seek(pointer);
2155 f->WriteBuffer(header, nbytes);
2156 if (f->MustFlush()) f->Flush();
2157 delete [] header;
2158}
2159
2160////////////////////////////////////////////////////////////////////////////////
2161/// Write Keys linked list on the file.
2162///
2163/// The linked list of keys (fKeys) is written as a single data record
2166{
2167 TFile* f = GetFile();
2168 if (!f) return;
2169
2170 if (!f->IsBinary()) {
2171 f->DirWriteKeys(this);
2172 return;
2173 }
2174
2175//*-* Delete the old keys structure if it exists
2176 if (fSeekKeys != 0) {
2177 f->MakeFree(fSeekKeys, fSeekKeys + fNbytesKeys -1);
2178 }
2179//*-* Write new keys record
2180 TIter next(fKeys);
2181 TKey *key;
2182 Int_t nkeys = fKeys->GetSize();
2183 Int_t nbytes = sizeof nkeys; //*-* Compute size of all keys
2184 if (f->GetEND() > TFile::kStartBigFile) nbytes += 8;
2185 while ((key = (TKey*)next())) {
2186 nbytes += key->Sizeof();
2187 }
2188 TKey *headerkey = new TKey(fName,fTitle,IsA(),nbytes,this);
2189 if (headerkey->GetSeekKey() == 0) {
2190 delete headerkey;
2191 return;
2192 }
2193 char *buffer = headerkey->GetBuffer();
2194 next.Reset();
2195 tobuf(buffer, nkeys);
2196 while ((key = (TKey*)next())) {
2197 key->FillBuffer(buffer);
2198 }
2199
2200 fSeekKeys = headerkey->GetSeekKey();
2201 fNbytesKeys = headerkey->GetNbytes();
2202 headerkey->WriteFile();
2203 delete headerkey;
2204}
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:599
#define SafeDelete(p)
Definition RConfig.hxx:537
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
const Ssiz_t kNPOS
Definition RtypesCore.h:124
int Int_t
Definition RtypesCore.h:45
short Version_t
Definition RtypesCore.h:65
unsigned int UInt_t
Definition RtypesCore.h:46
const Bool_t kFALSE
Definition RtypesCore.h:101
long Long_t
Definition RtypesCore.h:54
short Short_t
Definition RtypesCore.h:39
long long Long64_t
Definition RtypesCore.h:80
const Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define BIT(n)
Definition Rtypes.h:85
#define ClassImp(name)
Definition Rtypes.h:364
const Bool_t kIterBackward
Definition TCollection.h:43
const Int_t kMaxLen
const UInt_t kIsBigFile
const Int_t kMaxLen
#define gDirectory
Definition TDirectory.h:385
#define gFile
Definition TFile.h:345
XFontStruct * id
Definition TGX11.cxx:109
char name[80]
Definition TGX11.cxx:110
Int_t gDebug
Definition TROOT.cxx:592
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:404
R__EXTERN TSystem * gSystem
Definition TSystem.h:559
#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:80
void BuildRealData(void *pointer=0, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition TClass.cxx:2029
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition TClass.cxx:5924
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:4585
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2895
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:2966
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
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).
virtual ~TDirectoryFile()
Destructor.
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.
Bool_t IsWritable() const override
void Delete(const char *namecycle="") override
Delete Objects or/and keys in a 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.
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.
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.
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
void Delete(const char *namecycle="") override
Delete Objects or/and keys in a directory.
virtual TList * GetList() const
Definition TDirectory.h:222
virtual Int_t AppendKey(TKey *)
Definition TDirectory.h:184
virtual TDirectory * GetDirectory(const char *namecycle, Bool_t printError=false, const char *funcname="GetDirectory")
Find a directory using apath.
virtual void ReadAll(Option_t *="")
Definition TDirectory.h:247
virtual TObject * Get(const char *namecycle)
Return pointer to object identified by namecycle.
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.
static void DecodeNameCycle(const char *namecycle, char *name, Short_t &cycle, const size_t namesize=0)
Decode a namecycle "aap;2" into name "aap" and cycle "2".
virtual TFile * GetFile() const
Definition TDirectory.h:220
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
virtual void * GetObjectChecked(const char *namecycle, const char *classname)
See documentation of TDirectory::GetObjectCheck(const char *namecycle, const TClass *cl)
TList * fList
Definition TDirectory.h:142
virtual TKey * FindKeyAny(const char *) const
Definition TDirectory.h:198
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 a suite of consecutive data records (TKey instances) with a well defined format.
Definition TFile.h:54
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:2212
Int_t GetVersion() const
Definition TFile.h:239
Bool_t IsBinary() const
Definition TFile.h:253
@ kStartBigFile
Definition TFile.h:194
virtual Int_t DirReadKeys(TDirectory *)
Definition TFile.h:169
TList * GetListOfFree() const
Definition TFile.h:231
Int_t GetBestBuffer() const
Return the best buffer size of objects on this file.
Definition TFile.cxx:1123
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:996
virtual Long64_t GetSize() const
Returns the current file size.
Definition TFile.cxx:1285
virtual Long64_t GetEND() const
Definition TFile.h:225
void SumBuffer(Int_t bufsize)
Increment statistics for buffer sizes of objects in this file.
Definition TFile.cxx:2355
static TFile *& CurrentFile()
Return the current ROOT file if any.
Definition TFile.cxx:1016
virtual const TUrl * GetEndpointUrl() const
Definition TFile.h:229
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:4025
@ kReproducible
Definition TFile.h:191
@ kWriteError
Definition TFile.h:188
virtual Bool_t ReadBuffer(char *buf, Int_t len)
Read a buffer from the file.
Definition TFile.cxx:1708
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
virtual Long64_t GetSeekKey() const
Definition TKey.h:90
virtual void FillBuffer(char *&buffer)
Encode key header into output buffer.
Definition TKey.cxx:601
virtual void Delete(Option_t *option="")
Delete an object from the file.
Definition TKey.cxx:538
Int_t GetKeylen() const
Definition TKey.h:85
Int_t GetObjlen() const
Definition TKey.h:88
Int_t GetNbytes() 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:76
virtual Bool_t ReadFile()
Read the key structure from the file.
Definition TKey.cxx:1265
virtual Int_t WriteFile(Int_t cycle=1, TFile *f=0)
Write the encoded object supported by this key.
Definition TKey.cxx:1450
void ReadKeyBuffer(char *&buffer)
Decode input buffer.
Definition TKey.cxx:1222
virtual Long64_t GetSeekPdir() const
Definition TKey.h:91
void SetMotherDir(TDirectory *dir)
Definition TKey.h:113
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:750
virtual char * GetBuffer() const
Definition TKey.h:79
virtual Int_t Sizeof() const
Return the size in bytes of the key header structure.
Definition TKey.cxx:1336
A doubly linked list.
Definition TList.h:38
virtual void Add(TObject *obj)
Definition TList.h:81
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition TList.cxx:822
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition TList.cxx:578
virtual TObjLink * FirstLink() const
Definition TList.h:102
virtual void AddBefore(const TObject *before, TObject *obj)
Insert object before object before in the list.
Definition TList.cxx:196
virtual TObject * Before(const TObject *obj) const
Returns the object before object obj.
Definition TList.cxx:371
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:470
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition TList.cxx:659
This class implements a shared memory region mapped to a file.
Definition TMapFile.h:25
void Add(const TObject *obj, const char *name="")
Add an object to the list of objects to be stored in shared memory.
Definition TMapFile.cxx:595
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
TString fTitle
Definition TNamed.h:33
TString fName
Definition TNamed.h:32
virtual const char * GetTitle() const
Returns title of object.
Definition TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
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:545
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:868
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:429
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:201
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:200
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:393
@ kOnlyPrepStep
Used to request that the class specific implementation of TObject::Write just prepare the objects to ...
Definition TObject.h:106
virtual void Delete(Option_t *option="")
Delete this object.
Definition TObject.cxx:241
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:766
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:515
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:963
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:991
virtual void ls(Option_t *option="") const
The ls function lists the contents of a class on stdout.
Definition TObject.cxx:564
void ResetBit(UInt_t f)
Definition TObject.h:200
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:62
@ kIsReferenced
if object is referenced by a TRef or TRefArray
Definition TObject.h:65
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:937
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition TROOT.cxx:2811
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition TROOT.cxx:2819
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition TROOT.cxx:2704
Regular expression class.
Definition TRegexp.h:31
Int_t GetOffset() const
virtual Int_t GetExecID() const
Returns the TExec id for the EXEC instruction in the comment field of a TRef data member.
Describes a persistent version of a class.
TObjArray * GetElements() const
Basic string class.
Definition TString.h:136
Ssiz_t Length() const
Definition TString.h:410
void ToLower()
Change string to lower-case.
Definition TString.cxx:1150
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition TString.cxx:1131
const char * Data() const
Definition TString.h:369
@ kBoth
Definition TString.h:267
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:615
Bool_t IsNull() const
Definition TString.h:407
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2314
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:624
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:639
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:1296
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:570
Int_t Sizeof() const
Definition TUUID.h:85
void FillBuffer(char *&buffer)
Stream UUID into output buffer.
Definition TUUID.cxx:274
void StreamerV1(TBuffer &b)
Stream UUID from input buffer.
Definition TUUID.cxx:308
Abstract Interface class describing Streamer information for one class.
virtual TClass * GetClass() const =0
const Int_t n
Definition legend1.C:16
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition Rtypes.h:113
Definition first.py:1
TCanvas * slash()
Definition slash.C:1