Logo ROOT  
Reference Guide
TBranchObject.cxx
Go to the documentation of this file.
1// @(#)root/tree:$Id$
2// Author: Rene Brun 11/02/96
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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/** \class TBranchObject
13\ingroup tree
14
15A Branch for the case of an object.
16*/
17
18#include "TBranchObject.h"
19
20#include "TBasket.h"
21#include "TBranchClones.h"
22#include "TBrowser.h"
23#include "TBuffer.h"
24#include "TClass.h"
25#include "TClonesArray.h"
26#include "TDataMember.h"
27#include "TDataType.h"
28#include "TFile.h"
29#include "TLeafObject.h"
30#include "TRealData.h"
31#include "TStreamerInfo.h"
32#include "TTree.h"
33#include "snprintf.h"
34
36
37////////////////////////////////////////////////////////////////////////////////
38/// Default constructor for BranchObject.
39
41: TBranch()
42{
43 fNleaves = 1;
44 fOldObject = 0;
45}
46
47////////////////////////////////////////////////////////////////////////////////
48/// Create a BranchObject.
49
50TBranchObject::TBranchObject(TTree *tree, const char* name, const char* classname, void* addobj, Int_t basketsize, Int_t splitlevel, Int_t compress, Bool_t isptrptr /* = kTRUE */)
51: TBranch()
52{
53 Init(tree,0,name,classname,addobj,basketsize,splitlevel,compress,isptrptr);
54}
55
56////////////////////////////////////////////////////////////////////////////////
57/// Create a BranchObject.
58
59TBranchObject::TBranchObject(TBranch *parent, const char* name, const char* classname, void* addobj, Int_t basketsize, Int_t splitlevel, Int_t compress, Bool_t isptrptr /* = kTRUE */)
60: TBranch()
61{
62 Init(0,parent,name,classname,addobj,basketsize,splitlevel,compress,isptrptr);
63}
64
65////////////////////////////////////////////////////////////////////////////////
66/// Initialization routine (run from the constructor so do not make this function virtual)
67
68void TBranchObject::Init(TTree *tree, TBranch *parent, const char* name, const char* classname, void* addobj, Int_t basketsize, Int_t /*splitlevel*/, Int_t compress, Bool_t isptrptr)
69{
70 if (tree==0 && parent!=0) tree = parent->GetTree();
71 fTree = tree;
72 fMother = parent ? parent->GetMother() : this;
73 fParent = parent;
74
75 TClass* cl = TClass::GetClass(classname);
76
77 if (!cl) {
78 Error("TBranchObject", "Cannot find class:%s", classname);
79 return;
80 }
81
82 if (!isptrptr) {
83 fOldObject = (TObject*)addobj;
84 addobj = &fOldObject;
85 } else {
86 fOldObject = 0;
87 }
88
89 char** apointer = (char**) addobj;
90 TObject* obj = (TObject*) (*apointer);
91
92 Bool_t delobj = kFALSE;
93 if (!obj) {
94 obj = (TObject*) cl->New();
95 delobj = kTRUE;
96 }
97
98 tree->BuildStreamerInfo(cl, obj);
99
100 if (delobj) {
101 cl->Destructor(obj);
102 }
103
104 SetName(name);
105 SetTitle(name);
106
107 fCompress = compress;
108 if ((compress == -1) && tree->GetDirectory()) {
109 TFile* bfile = tree->GetDirectory()->GetFile();
110 if (bfile) {
112 }
113 }
114 if (basketsize < 100) {
115 basketsize = 100;
116 }
117 fBasketSize = basketsize;
118 fAddress = (char*) addobj;
119 fClassName = classname;
123
124 for (Int_t i = 0; i < fMaxBaskets; ++i) {
125 fBasketBytes[i] = 0;
126 fBasketEntry[i] = 0;
127 fBasketSeek[i] = 0;
128 }
129
130 TLeaf* leaf = new TLeafObject(this, name, classname);
131 leaf->SetAddress(addobj);
132 fNleaves = 1;
133 fLeaves.Add(leaf);
134 tree->GetListOfLeaves()->Add(leaf);
135
136 // Set the bit kAutoDelete to specify that when reading
137 // in TLeafObject::ReadBasket, the object should be deleted
138 // before calling Streamer.
139 // It is foreseen to not set this bit in a future version.
140 if (isptrptr) SetAutoDelete(kTRUE);
141
143 fFileName = "";
144
145}
146
147////////////////////////////////////////////////////////////////////////////////
148/// Destructor for a BranchObject.
149
151{
153}
154
155////////////////////////////////////////////////////////////////////////////////
156/// Browse the branch content.
157
159{
160 Int_t nbranches = fBranches.GetEntriesFast();
161 if (nbranches > 1) {
163 }
164 if (GetBrowsables() && GetBrowsables()->GetSize()) {
166 }
167}
168
169////////////////////////////////////////////////////////////////////////////////
170/// Loop on all leaves of this branch to fill Basket buffer.
171
173{
174 Int_t nbytes = 0;
175 Int_t nbranches = fBranches.GetEntriesFast();
176 if (nbranches) {
177 ++fEntries;
179 for (Int_t i = 0; i < nbranches; ++i) {
180 TBranch* branch = (TBranch*) fBranches[i];
181 if (!branch->TestBit(kDoNotProcess)) {
182 Int_t bc = branch->FillImpl(imtHelper);
183 nbytes += bc;
184 }
185 }
186 } else {
187 if (!TestBit(kDoNotProcess)) {
188 Int_t bc = TBranch::FillImpl(imtHelper);
189 nbytes += bc;
190 }
191 }
192 return nbytes;
193}
194
195////////////////////////////////////////////////////////////////////////////////
196/// Read all branches of a BranchObject and return total number of bytes.
197///
198/// - If entry = 0 take current entry number + 1
199/// - If entry < 0 reset entry number to 0
200///
201/// The function returns the number of bytes read from the input buffer.
202///
203/// - If entry does not exist the function returns 0.
204/// - If an I/O error occurs, the function returns -1.
205
207{
208 if (TestBit(kDoNotProcess) && !getall) {
209 return 0;
210 }
211 Int_t nbytes;
212 Int_t nbranches = fBranches.GetEntriesFast();
213
214 if (nbranches) {
215 if (fAddress == 0) {
217 }
218 nbytes = 0;
219 Int_t nb;
220 for (Int_t i = 0; i < nbranches; ++i) {
221 TBranch* branch = (TBranch*) fBranches[i];
222 if (branch) {
223 nb = branch->GetEntry(entry, getall);
224 if (nb < 0) {
225 return nb;
226 }
227 nbytes += nb;
228 }
229 }
230 } else {
231 nbytes = TBranch::GetEntry(entry, getall);
232 }
233 return nbytes;
234}
235
236////////////////////////////////////////////////////////////////////////////////
237/// Fill expectedClass and expectedType with information on the data type of the
238/// object/values contained in this branch (and thus the type of pointers
239/// expected to be passed to Set[Branch]Address
240/// return 0 in case of success and > 0 in case of failure.
241
243{
244 expectedClass = 0;
245 expectedType = kOther_t;
246 TLeafObject* lobj = (TLeafObject*) GetListOfLeaves()->At(0);
247 if (!lobj) {
248 Error("GetExpectedType", "Did not find any leaves in %s",GetName());
249 return 1;
250 }
251 expectedClass = lobj->GetClass();
252 return 0;
253}
254
255////////////////////////////////////////////////////////////////////////////////
256/// Return TRUE if more than one leaf or if fBrowsables, FALSE otherwise.
257
259{
260 Int_t nbranches = fBranches.GetEntriesFast();
261
262 if (nbranches >= 1) {
263 return kTRUE;
264 }
265
266 TList* browsables = const_cast<TBranchObject*>(this)->GetBrowsables();
267
268 return browsables && browsables->GetSize();
269}
270
271////////////////////////////////////////////////////////////////////////////////
272/// Print TBranch parameters.
273
275{
276 Int_t nbranches = fBranches.GetEntriesFast();
277 if (nbranches) {
278 Printf("*Branch :%-9s : %-54s *", GetName(), GetTitle());
279 Printf("*Entries : %8d : BranchObject (see below) *", Int_t(fEntries));
280 Printf("*............................................................................*");
281 for (Int_t i = 0; i < nbranches; ++i) {
282 TBranch* branch = (TBranch*) fBranches.At(i);
283 if (branch) {
284 branch->Print(option);
285 }
286 }
287 } else {
289 }
290}
291
292////////////////////////////////////////////////////////////////////////////////
293/// Reset a branch.
294///
295/// - Existing buffers are deleted.
296/// - Entries, max and min are reset.
297
299{
301
302 Int_t nbranches = fBranches.GetEntriesFast();
303 for (Int_t i = 0; i < nbranches; ++i) {
304 TBranch* branch = (TBranch*) fBranches[i];
305 branch->Reset(option);
306 }
307}
308
309////////////////////////////////////////////////////////////////////////////////
310/// Reset a Branch after a Merge operation (drop data but keep customizations)
312{
314
315 Int_t nbranches = fBranches.GetEntriesFast();
316 for (Int_t i = 0; i < nbranches; ++i) {
317 TBranch* branch = (TBranch*) fBranches[i];
318 branch->ResetAfterMerge(info);
319 }
320}
321
322////////////////////////////////////////////////////////////////////////////////
323/// Set address of this branch.
324
326{
327 if (TestBit(kDoNotProcess)) {
328 return;
329 }
330
331 // Special case when called from code generated by TTree::MakeClass.
332 if (Longptr_t(add) == -1) {
333 SetBit(kWarn);
334 return;
335 }
336
337 fReadEntry = -1;
338 Int_t nbranches = fBranches.GetEntriesFast();
339
340 TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(0);
341 if (leaf) {
342 leaf->SetAddress(add);
343 }
344
345 fAddress = (char*) add;
346 char** ppointer = (char**) add;
347
348 char* obj = 0;
349 if (ppointer) {
350 obj = *ppointer;
351 }
352
354
355 if (!cl) {
356 for (Int_t i = 0; i < nbranches; ++i) {
357 TBranch* br = (TBranch*) fBranches[i];
358 br->SetAddress(obj);
359 }
360 return;
361 }
362
363 if (ppointer && !obj) {
364 obj = (char*) cl->New();
365 *ppointer = obj;
366 }
367
368 if (!cl->GetListOfRealData()) {
369 cl->BuildRealData(obj);
370 }
371
373 if (ppointer) {
374 TClonesArray* clones = (TClonesArray*) *ppointer;
375 if (!clones) {
376 Error("SetAddress", "Pointer to TClonesArray is null");
377 return;
378 }
379 TClass* clm = clones->GetClass();
380 if (clm) {
381 clm->BuildRealData(); //just in case clm derives from an abstract class
382 clm->GetStreamerInfo();
383 }
384 }
385 }
386
387 //
388 // Loop over our data members looking
389 // for sub-branches for them. If we
390 // find one, set its address.
391 //
392
393 char* fullname = new char[200];
394
395 const char* bname = GetName();
396
397 Int_t isDot = 0;
398 if (bname[strlen(bname)-1] == '.') {
399 isDot = 1;
400 }
401
402 char* pointer = 0;
403 TRealData* rd = 0;
404 TIter next(cl->GetListOfRealData());
405 while ((rd = (TRealData*) next())) {
406 if (rd->TestBit(TRealData::kTransient)) continue;
407
408 TDataMember* dm = rd->GetDataMember();
409 if (!dm || !dm->IsPersistent()) {
410 continue;
411 }
412 const char* rdname = rd->GetName();
413 TDataType* dtype = dm->GetDataType();
414 Int_t code = 0;
415 if (dtype) {
416 code = dm->GetDataType()->GetType();
417 }
418 Int_t offset = rd->GetThisOffset();
419 if (ppointer) {
420 pointer = obj + offset;
421 }
422 TBranch* branch = 0;
423 if (dm->IsaPointer()) {
424 TClass* clobj = 0;
425 if (!dm->IsBasic()) {
426 clobj = TClass::GetClass(dm->GetTypeName());
427 }
428 if (clobj && clobj->InheritsFrom(TClonesArray::Class())) {
429 if (isDot) {
430 snprintf(fullname,200, "%s%s", bname, &rdname[1]);
431 } else {
432 snprintf(fullname,200, "%s", &rdname[1]);
433 }
434 branch = (TBranch*) fBranches.FindObject(fullname);
435 } else {
436 if (!clobj) {
437 // this is a basic type we can handle only if
438 // it has a dimension:
439 const char* index = dm->GetArrayIndex();
440 if (!index[0]) {
441 if (code == 1) {
442 // Case of a string ... we do not need the size
443 if (isDot) {
444 snprintf(fullname,200, "%s%s", bname, &rdname[0]);
445 } else {
446 snprintf(fullname,200, "%s", &rdname[0]);
447 }
448 } else {
449 continue;
450 }
451 }
452 if (isDot) {
453 snprintf(fullname,200, "%s%s", bname, &rdname[0]);
454 } else {
455 snprintf(fullname,200, "%s", &rdname[0]);
456 }
457 // let's remove the stars!
459 UInt_t pos;
460 for (cursor = 0, pos = 0; cursor < strlen(fullname); ++cursor) {
461 if (fullname[cursor] != '*') {
462 fullname[pos++] = fullname[cursor];
463 }
464 }
465 fullname[pos] = '\0';
466 branch = (TBranch*) fBranches.FindObject(fullname);
467 } else {
468 if (!clobj->IsTObject()) {
469 continue;
470 }
471 if (isDot) {
472 snprintf(fullname,200, "%s%s", bname, &rdname[1]);
473 } else {
474 snprintf(fullname,200, "%s", &rdname[1]);
475 }
476 branch = (TBranch*) fBranches.FindObject(fullname);
477 }
478 }
479 } else {
480 if (dm->IsBasic()) {
481 if (isDot) {
482 snprintf(fullname,200, "%s%s", bname, &rdname[0]);
483 } else {
484 snprintf(fullname,200, "%s", &rdname[0]);
485 }
486 branch = (TBranch*) fBranches.FindObject(fullname);
487 }
488 }
489 if (branch) {
490 branch->SetAddress(pointer);
491 }
492 }
493
494 delete[] fullname;
495}
496
497////////////////////////////////////////////////////////////////////////////////
498/// Set the AutoDelete bit.
499///
500/// This function can be used to instruct Root in TBranchObject::ReadBasket
501/// to not delete the object referenced by a branchobject before reading a
502/// new entry. By default, the object is deleted.
503/// - If autodel is kTRUE, this existing object will be deleted, a new object
504/// created by the default constructor, then object->Streamer called.
505/// - If autodel is kFALSE, the existing object is not deleted. Root assumes
506/// that the user is taking care of deleting any internal object or array
507/// This can be done in Streamer itself.
508/// - If this branch has sub-branches, the function sets autodel for these
509/// branches as well.
510/// We STRONGLY suggest to activate this option by default when you create
511/// the top level branch. This will make the read phase more efficient
512/// because it minimizes the numbers of new/delete operations.
513/// Once this option has been set and the Tree is written to a file, it is
514/// not necessary to specify the option again when reading, unless you
515/// want to set the opposite mode.
516
518{
519 TBranch::SetAutoDelete(autodel);
520
521 Int_t nbranches = fBranches.GetEntriesFast();
522 for (Int_t i=0;i<nbranches;i++) {
523 TBranch *branch = (TBranch*)fBranches[i];
524 branch->SetAutoDelete(autodel);
525 }
526}
527
528////////////////////////////////////////////////////////////////////////////////
529/// Reset basket size for all subbranches of this branch.
530
532{
533 TBranch::SetBasketSize(buffsize);
534
535 Int_t nbranches = fBranches.GetEntriesFast();
536 for (Int_t i = 0; i < nbranches; ++i) {
537 TBranch* branch = (TBranch*) fBranches[i];
538 branch->SetBasketSize(fBasketSize);
539 }
540}
541
542////////////////////////////////////////////////////////////////////////////////
543/// Stream an object of class TBranchObject.
544
546{
547 if (R__b.IsReading()) {
549 // We should rewarn in this process.
552 } else {
553 TDirectory* dirsav = fDirectory;
554 fDirectory = 0; // to avoid recursive calls
555
557
558 // make sure that all TStreamerInfo objects referenced by
559 // this class are written to the file
561
562 // if branch is in a separate file save this branch
563 // as an independent key
564 if (!dirsav) {
565 return;
566 }
567 if (!dirsav->IsWritable()) {
568 fDirectory = dirsav;
569 return;
570 }
571 TDirectory* pdirectory = fTree->GetDirectory();
572 if (!pdirectory) {
573 fDirectory = dirsav;
574 return;
575 }
576 const char* treeFileName = pdirectory->GetFile()->GetName();
577 TBranch* mother = GetMother();
578 const char* motherFileName = treeFileName;
579 if (mother && (mother != this)) {
580 motherFileName = mother->GetFileName();
581 }
582 if ((fFileName.Length() > 0) && strcmp(motherFileName, fFileName.Data())) {
583 dirsav->WriteTObject(this);
584 }
585 fDirectory = dirsav;
586 }
587}
588
589////////////////////////////////////////////////////////////////////////////////
590/// -- If the branch address is not set, we set all addresses starting with
591/// the top level parent branch. This is required to be done in order for
592/// GetOffset to be correct and for GetEntry to run.
593
595{
596 if (fAddress == 0) {
597 // try to create object
598 if (!TestBit(kWarn)) {
600 if (cl) {
601 TObject** voidobj = (TObject**) new Long_t[1];
602 *voidobj = (TObject*) cl->New();
603 SetAddress(voidobj);
604 } else {
605 Warning("GetEntry", "Cannot get class: %s", fClassName.Data());
606 SetBit(kWarn);
607 }
608 }
609 }
610}
611
612////////////////////////////////////////////////////////////////////////////////
613/// Update branch addresses if a new object was created.
614
616{
617 void** ppointer = (void**) fAddress;
618 if (!ppointer) {
619 return;
620 }
621 TObject* obj = (TObject*) (*ppointer);
622 if (obj != fOldObject) {
623 fOldObject = obj;
625 }
626}
627
int Int_t
Definition: RtypesCore.h:45
long Longptr_t
Definition: RtypesCore.h:82
const Bool_t kFALSE
Definition: RtypesCore.h:101
long Long_t
Definition: RtypesCore.h:54
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 ClassImp(name)
Definition: Rtypes.h:375
EDataType
Definition: TDataType.h:28
@ kOther_t
Definition: TDataType.h:32
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 cursor
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 b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
char name[80]
Definition: TGX11.cxx:110
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition: TString.cxx:2470
#define snprintf
Definition: civetweb.c:1540
A helper class for managing IMT work during TTree:Fill operations.
A Branch for the case of an object.
Definition: TBranchObject.h:26
void SetAddress(void *addobj) override
Set address of this branch.
void ResetAfterMerge(TFileMergeInfo *) override
Reset a Branch after a Merge operation (drop data but keep customizations)
virtual ~TBranchObject()
Destructor for a BranchObject.
TObject * fOldObject
!Pointer to old object
Definition: TBranchObject.h:43
void SetAutoDelete(Bool_t autodel=kTRUE) override
Set the AutoDelete bit.
void SetupAddresses() override
– If the branch address is not set, we set all addresses starting with the top level parent branch.
Int_t GetExpectedType(TClass *&clptr, EDataType &type) override
Fill expectedClass and expectedType with information on the data type of the object/values contained ...
void UpdateAddress() override
Update branch addresses if a new object was created.
void Streamer(TBuffer &) override
Stream an object of class TBranchObject.
Int_t GetEntry(Long64_t entry=0, Int_t getall=0) override
Read all branches of a BranchObject and return total number of bytes.
TString fClassName
Class name of referenced object.
Definition: TBranchObject.h:42
Bool_t IsFolder() const override
Return TRUE if more than one leaf or if fBrowsables, FALSE otherwise.
TBranchObject()
Default constructor for BranchObject.
void Print(Option_t *option="") const override
Print TBranch parameters.
void Init(TTree *tree, TBranch *parent, const char *name, const char *classname, void *addobj, Int_t basketsize, Int_t splitlevel, Int_t compress, Bool_t isptrptr)
Initialization routine (run from the constructor so do not make this function virtual)
Int_t FillImpl(ROOT::Internal::TBranchIMTHelper *) override
Loop on all leaves of this branch to fill Basket buffer.
void SetBasketSize(Int_t buffsize) override
Reset basket size for all subbranches of this branch.
void Reset(Option_t *option="") override
Reset a branch.
static TClass * Class()
void Browse(TBrowser *b) override
Browse the branch content.
A TTree is a list of TBranches.
Definition: TBranch.h:89
virtual void SetAutoDelete(Bool_t autodel=kTRUE)
Set the automatic delete bit.
Definition: TBranch.cxx:2654
TString fFileName
Name of file where buffers are stored ("" if in same file as Tree header)
Definition: TBranch.h:145
Int_t fMaxBaskets
Maximum number of Baskets so far.
Definition: TBranch.h:121
TTree * GetTree() const
Definition: TBranch.h:248
@ kDoNotProcess
Active bit for branches.
Definition: TBranch.h:101
TObjArray fLeaves
-> List of leaves of this branch
Definition: TBranch.h:135
char * fAddress
! Address of 1st leaf (variable or object)
Definition: TBranch.h:143
virtual TList * GetBrowsables()
Returns (and, if 0, creates) browsable objects for this branch See TVirtualBranchBrowsable::FillListO...
Definition: TBranch.cxx:1310
Long64_t * fBasketEntry
[fMaxBaskets] Table of first entry in each basket
Definition: TBranch.h:138
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Read all leaves of entry and return total number of bytes read.
Definition: TBranch.cxx:1644
const char * GetFileName() const
Definition: TBranch.h:230
Long64_t fReadEntry
! Current entry number when reading
Definition: TBranch.h:126
void Print(Option_t *option="") const override
Print TBranch parameters.
Definition: TBranch.cxx:2279
virtual void SetAddress(void *add)
Set address of this branch.
Definition: TBranch.cxx:2620
Int_t fNleaves
! Number of leaves
Definition: TBranch.h:124
Int_t * fBasketBytes
[fMaxBaskets] Length of baskets on file
Definition: TBranch.h:137
TObjArray fBranches
-> List of Branches of this branch
Definition: TBranch.h:134
virtual void ResetAfterMerge(TFileMergeInfo *)
Reset a Branch.
Definition: TBranch.cxx:2536
TDirectory * fDirectory
! Pointer to directory where this branch buffers are stored
Definition: TBranch.h:144
TBranch * fMother
! Pointer to top-level parent branch in the tree.
Definition: TBranch.h:141
TBranch * fParent
! Pointer to parent branch.
Definition: TBranch.h:142
virtual void SetBasketSize(Int_t buffsize)
Set the basket size The function makes sure that the basket size is greater than fEntryOffsetlen.
Definition: TBranch.cxx:2667
Long64_t * fBasketSeek
[fMaxBaskets] Addresses of baskets on file
Definition: TBranch.h:139
TObjArray * GetListOfLeaves()
Definition: TBranch.h:243
Int_t fBasketSize
Initial Size of Basket Buffer.
Definition: TBranch.h:114
virtual void Reset(Option_t *option="")
Reset a Branch.
Definition: TBranch.cxx:2495
TBranch * GetMother() const
Get our top-level parent branch in the tree.
Definition: TBranch.cxx:2065
Int_t fCompress
Compression level and algorithm.
Definition: TBranch.h:113
virtual Int_t FillImpl(ROOT::Internal::TBranchIMTHelper *)
Loop on all leaves of this branch to fill Basket buffer.
Definition: TBranch.cxx:854
Long64_t fEntries
Number of entries.
Definition: TBranch.h:130
TTree * fTree
! Pointer to Tree header
Definition: TBranch.h:140
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual void ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force)=0
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition: TClass.cxx:4967
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition: TClass.cxx:5389
void BuildRealData(void *pointer=nullptr, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition: TClass.cxx:2031
TList * GetListOfRealData() const
Definition: TClass.h:451
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition: TClass.cxx:5927
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:4588
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4863
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:2969
An array of clone (identical) objects.
Definition: TClonesArray.h:29
TClass * GetClass() const
Definition: TClonesArray.h:53
static TClass * Class()
void Browse(TBrowser *b) override
Browse this collection (called by TBrowser).
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:184
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
Bool_t IsPersistent() const
Definition: TDataMember.h:91
Bool_t IsBasic() const
Return true if data member is a basic type, e.g. char, int, long...
Bool_t IsaPointer() const
Return true if data member is a pointer.
TDataType * GetDataType() const
Definition: TDataMember.h:76
const char * GetTypeName() const
Get type of data member, e,g.: "class TDirectory*" -> "TDirectory".
const char * GetArrayIndex() const
If the data member is pointer and has a valid array size in its comments GetArrayIndex returns a stri...
Basic data type descriptor (datatype information is obtained from CINT).
Definition: TDataType.h:44
Int_t GetType() const
Definition: TDataType.h:68
Describe directory structure in memory.
Definition: TDirectory.h:45
virtual Int_t WriteTObject(const TObject *obj, const char *name=nullptr, Option_t *="", Int_t=0)
Write an object with proper type checking.
virtual TFile * GetFile() const
Definition: TDirectory.h:211
virtual Bool_t IsWritable() const
Definition: TDirectory.h:227
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
Int_t GetCompressionSettings() const
Definition: TFile.h:401
A TLeaf for a general object derived from TObject.
Definition: TLeafObject.h:31
TClass * GetClass() const
Definition: TLeafObject.h:59
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:57
virtual void SetAddress(void *add=nullptr)
Definition: TLeaf.h:185
A doubly linked list.
Definition: TList.h:38
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition: TNamed.h:48
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
Int_t GetEntriesFast() const
Definition: TObjArray.h:58
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:356
TObject * At(Int_t idx) const override
Definition: TObjArray.h:164
TObject * UncheckedAt(Int_t i) const
Definition: TObjArray.h:84
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
Definition: TObjArray.cxx:415
void Add(TObject *obj) override
Definition: TObjArray.h:68
Mother of all ROOT objects.
Definition: TObject.h:41
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:201
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:956
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:775
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:970
void ResetBit(UInt_t f)
Definition: TObject.h:200
The TRealData class manages the effective list of all data members for a given class.
Definition: TRealData.h:30
const char * GetName() const override
Returns name of object.
Definition: TRealData.h:52
TDataMember * GetDataMember() const
Definition: TRealData.h:53
@ kTransient
Definition: TRealData.h:44
Long_t GetThisOffset() const
Definition: TRealData.h:55
Ssiz_t Length() const
Definition: TString.h:410
const char * Data() const
Definition: TString.h:369
A TTree represents a columnar dataset.
Definition: TTree.h:79
TDirectory * GetDirectory() const
Definition: TTree.h:458
Definition: tree.py:1