Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TBranchElement.cxx
Go to the documentation of this file.
1// @(#)root/tree:$Id$
2// Authors Rene Brun , Philippe Canal, Markus Frank 14/01/2001
3
4/*************************************************************************
5 * Copyright (C) 1995-2004, 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 TBranchElement
13\ingroup tree
14
15A Branch for the case of an object.
16*/
17
18#include "TBranchElement.h"
19
20#include "TBasket.h"
21#include "TBranchObject.h"
22#include "TBranchRef.h"
23#include "TBrowser.h"
24#include "TClass.h"
25#include "TClassEdit.h"
26#include "TClonesArray.h"
27#include "TDataMember.h"
28#include "TDataType.h"
29#include "TError.h"
30#include "TMath.h"
31#include "TFile.h"
32#include "TFolder.h"
33#include "TLeafElement.h"
34#include "TRealData.h"
35#include "TStreamerElement.h"
36#include "TStreamerInfo.h"
37#include "TTree.h"
40#include "TVirtualMutex.h"
41#include "TVirtualPad.h"
42#include "TBranchSTL.h"
43#include "TVirtualArray.h"
44#include "TBufferFile.h"
45#include "TInterpreter.h"
46#include "TROOT.h"
47
49#include "TSchemaRuleSet.h"
50
52
53////////////////////////////////////////////////////////////////////////////////
54
55namespace {
56 void RemovePrefix(TString& str, const TString &prefix) {
57 // -- Remove a prefix from a string.
58 // -- Require a '.' after the prefix.
59 if (prefix.Length() && prefix.Length() <= str.Length()
60 && (str.Data()[prefix.Length()] == '.' || (prefix[prefix.Length()-1]=='.')))
61 {
62 if (!str.Index(prefix))
63 str.Remove(0, prefix.Length());
64 }
65 }
66 struct R__PushCache {
68 TVirtualArray *fOnfileObject;
69
70 R__PushCache(TBufferFile &b, TVirtualArray *in, UInt_t size) : fBuffer(b), fOnfileObject(in) {
71 if (fOnfileObject) {
72 fOnfileObject->SetSize(size);
73 fBuffer.PushDataCache( fOnfileObject );
74 }
75 }
76 ~R__PushCache() {
77 if (fOnfileObject) fBuffer.PopDataCache();
78 }
79 };
80}
81
82////////////////////////////////////////////////////////////////////////////////
83/// Modify the container type of the branches
84
86 const Int_t nbranches = branches->GetEntriesFast();
87 for (Int_t i = 0; i < nbranches; ++i) {
88 TBranchElement* br = (TBranchElement*) branches->At(i);
89 switch (br->GetType()) {
90 case 31: br->SetType(41); break;
91 case 41: {
92 br->SetType(31);
93 br->fCollProxy = 0;
94 break;
95 }
96 }
97 br->SetReadLeavesPtr();
98 br->SetFillLeavesPtr();
99 // Note: This is a tail recursion.
101 }
102}
103
104////////////////////////////////////////////////////////////////////////////////
105
106namespace {
107 Bool_t CanSelfReference(TClass *cl) {
108 if (cl) {
109 if (cl->GetCollectionProxy()) {
110 TClass *inside = cl->GetCollectionProxy()->GetValueClass();
111 if (inside) {
112 return CanSelfReference(inside);
113 } else {
114 return kFALSE;
115 }
116 }
117 const static TClassRef stringClass("std::string");
118 if (cl == stringClass || cl == TString::Class()) {
119 return kFALSE;
120 }
121 // Here we could scan through the TStreamerInfo to see if there
122 // is any pointer anywhere and know whether this is a possibility
123 // of selfreference (but watch out for very indirect cases).
124 return kTRUE;
125 }
126 return kFALSE;
127 }
128}
129
130////////////////////////////////////////////////////////////////////////////////
131/// Default and I/O constructor.
132
134: TBranch()
135, fClassName()
136, fParentName()
137, fClonesName()
138, fCollProxy(0)
139, fCheckSum(0)
140, fClassVersion(0)
141, fID(0)
142, fType(0)
143, fStreamerType(-1)
144, fMaximum(0)
145, fSTLtype(ROOT::kNotSTL)
146, fNdata(1)
147, fBranchCount(0)
148, fBranchCount2(0)
149, fInfo(0)
150, fObject(0)
151, fOnfileObject(0)
152, fInit(kFALSE)
153, fInInitInfo(kFALSE)
154, fInitOffsets(kFALSE)
155, fTargetClass()
156, fCurrentClass()
157, fParentClass()
158, fBranchClass()
159, fClonesClass()
160, fBranchOffset(0)
161, fBranchID(-1)
162, fReadActionSequence(0)
163, fFillActionSequence(0)
164, fIterators(0)
165, fWriteIterators(0)
166, fPtrIterators(0)
167{
168 fNleaves = 0;
171}
172
173////////////////////////////////////////////////////////////////////////////////
174/// Constructor when the branch object is not a TClonesArray nor an STL container.
175///
176/// If splitlevel > 0 this branch in turn is split into sub-branches.
177
178TBranchElement::TBranchElement(TTree *tree, const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
179: TBranch()
180, fClassName(sinfo->GetName())
181, fParentName()
182, fClonesName()
183, fCollProxy(0)
184, fCheckSum(sinfo->GetCheckSum())
185, fClassVersion(sinfo->GetClass()->GetClassVersion())
186, fID(id)
187, fType(0)
188, fStreamerType(-1)
189, fMaximum(0)
190, fSTLtype(ROOT::kNotSTL)
191, fNdata(1)
192, fBranchCount(0)
193, fBranchCount2(0)
194, fInfo(sinfo)
195, fObject(0)
196, fOnfileObject(0)
197, fInit(kTRUE)
198, fInInitInfo(kFALSE)
199, fInitOffsets(kFALSE)
200, fTargetClass(fClassName)
201, fCurrentClass()
202, fParentClass()
203, fBranchClass(sinfo->GetClass())
204, fClonesClass()
205, fBranchOffset(0)
206, fBranchID(-1)
207, fReadActionSequence(0)
208, fFillActionSequence(0)
209, fIterators(0)
210, fWriteIterators(0)
211, fPtrIterators(0)
212{
213 if (tree) {
214 ROOT::TIOFeatures features = tree->GetIOFeatures();
215 SetIOFeatures(features);
216 }
217 Init(tree, 0, bname,sinfo,id,pointer,basketsize,splitlevel,btype);
218}
219
220////////////////////////////////////////////////////////////////////////////////
221/// Constructor when the branch object is not a TClonesArray nor an STL container.
222///
223/// If splitlevel > 0 this branch in turn is split into sub-branches.
224
225TBranchElement::TBranchElement(TBranch *parent, const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
226: TBranch()
227, fClassName(sinfo->GetName())
228, fParentName()
229, fClonesName()
230, fCollProxy(0)
231, fCheckSum(sinfo->GetCheckSum())
232, fClassVersion(sinfo->GetClass()->GetClassVersion())
233, fID(id)
234, fType(0)
235, fStreamerType(-1)
236, fMaximum(0)
237, fSTLtype(ROOT::kNotSTL)
238, fNdata(1)
239, fBranchCount(0)
240, fBranchCount2(0)
241, fInfo(sinfo)
242, fObject(0)
243, fOnfileObject(0)
244, fInit(kTRUE)
245, fInInitInfo(kFALSE)
246, fInitOffsets(kFALSE)
247, fTargetClass( fClassName )
248, fCurrentClass()
249, fParentClass()
250, fBranchClass(sinfo->GetClass())
251, fClonesClass()
252, fBranchOffset(0)
253, fBranchID(-1)
254, fReadActionSequence(0)
255, fFillActionSequence(0)
256, fIterators(0)
257, fWriteIterators(0)
258, fPtrIterators(0)
259{
260 ROOT::TIOFeatures features = parent->GetIOFeatures();
261 SetIOFeatures(features);
262 Init(parent ? parent->GetTree() : 0, parent, bname,sinfo,id,pointer,basketsize,splitlevel,btype);
263}
264
265////////////////////////////////////////////////////////////////////////////////
266/// Init when the branch object is not a TClonesArray nor an STL container.
267///
268/// If splitlevel > 0 this branch in turn is split into sub-branches.
269
270void TBranchElement::Init(TTree *tree, TBranch *parent,const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
271{
272 TString name(bname);
273
274 // Set our TNamed attributes.
275 SetName(name);
276 SetTitle(name);
277
278 // Set our TBranch attributes.
279 fSplitLevel = splitlevel;
280 fTree = tree;
281 if (fTree == 0) return;
282 fMother = parent ? parent->GetMother() : this;
283 fParent = parent;
285 fFileName = "";
286
287 // Clear the bit kAutoDelete to specify that when reading
288 // the object should not be deleted before calling Streamer.
289
291
294
295 //---------------------------------------------------------------------------
296 // Handling the splitting of the STL collections of pointers
297 /////////////////////////////////////////////////////////////////////////////
298
299 Int_t splitSTLP = splitlevel - (splitlevel%TTree::kSplitCollectionOfPointers);
301
302 fCompress = -1;
303 if (fTree->GetDirectory()) {
304 TFile* bfile = fTree->GetDirectory()->GetFile();
305 if (bfile) {
307 }
308 }
309
310 //
311 // Initialize streamer type and element.
312 //
313
314 if (id > -1) {
315 // We are *not* a top-level branch.
316 TStreamerElement* element = sinfo->GetElement(id);
317 fStreamerType = element->GetType();
318 }
319
320 //
321 // Handle varying-length datatypes by allocating an offsets array.
322 //
323 // The fBits part of a TObject is of varying length because the pidf
324 // is streamed only when the TObject is referenced by a TRef.
325 //
326
327 fEntryOffsetLen = 0;
330 }
331
332 //
333 // Make sure the basket is big enough to contain the
334 // entry offset array plus 100 bytes of data.
335 //
336
337 if (basketsize < (100 + fEntryOffsetLen)) {
338 basketsize = 100 + fEntryOffsetLen;
339 }
340 fBasketSize = basketsize;
341
342 //
343 // Allocate and initialize the basket control arrays.
344 //
345
349
350 for (Int_t i = 0; i < fMaxBaskets; ++i) {
351 fBasketBytes[i] = 0;
352 fBasketEntry[i] = 0;
353 fBasketSeek[i] = 0;
354 }
355
356 // We need to keep track of the counter branch if we have
357 // one, since we cannot set it until we have created our
358 // leaf, which we do last.
359 TBranchElement* brOfCounter = 0;
360
361 if (id < 0) {
362 // -- We are a top-level branch. Don't split a top-level branch, TTree::Bronch will do that work.
363 if (fBranchClass.GetClass()) {
364 Bool_t hasCustomStreamer = kFALSE;
365 Bool_t canSelfReference = CanSelfReference(fBranchClass);
367 if (canSelfReference) SetBit(kBranchObject);
369 } else {
370 if (canSelfReference) SetBit(kBranchAny);
372 }
373 if (hasCustomStreamer) {
374 fType = -1;
375 }
376 }
377 } else {
378 // -- We are a sub-branch of a split object.
379 TStreamerElement* element = sinfo->GetElement(id);
381 // -- If we are an object data member which inherits from TObject,
382 // flag it so that later during i/o we will register the object
383 // with the buffer so that pointers are handled correctly.
384 if (CanSelfReference(fBranchClass)) {
387 } else {
389 }
390 }
391 }
392 if (element->IsA() == TStreamerBasicPointer::Class()) {
393 // -- Fixup title with counter if we are a varying length array data member.
395 TString countname;
396 countname = bname;
397 Ssiz_t dot = countname.Last('.');
398 if (dot>=0) {
399 countname.Remove(dot+1);
400 } else {
401 countname = "";
402 }
403 countname += bp->GetCountName();
404 brOfCounter = (TBranchElement *)fTree->GetBranch(countname);
405 countname.Form("%s[%s]",name.Data(),bp->GetCountName());
406 SetTitle(countname);
407
408 } else if (element->IsA() == TStreamerLoop::Class()) {
409 // -- Fixup title with counter if we are a varying length array data member.
410 TStreamerLoop *bp = (TStreamerLoop *)element;
411 TString countname;
412 countname = bname;
413 Ssiz_t dot = countname.Last('.');
414 if (dot>=0) {
415 countname.Remove(dot+1);
416 } else {
417 countname = "";
418 }
419 countname += bp->GetCountName();
420 brOfCounter = (TBranchElement *)fTree->GetBranch(countname);
421 countname.Form("%s[%s]",name.Data(),bp->GetCountName());
422 SetTitle(countname);
423
424 }
425
426 if (splitlevel > 0) {
427 // -- Create sub branches if requested by splitlevel.
428 const char* elemType = element->GetTypeName();
429 TClass *elementClass = element->GetClassPointer();
430 fSTLtype = elementClass ? elementClass->GetCollectionType() : ROOT::kNotSTL;
431 if (element->CannotSplit()) {
432 fSplitLevel = 0;
433 } else if (element->IsA() == TStreamerBase::Class()) {
434 // -- We are a base class element.
435 // Note: This does not include an STL container class which is
436 // being used as a base class because the streamer element
437 // in that case is not the base streamer element it is the
438 // STL streamer element.
439 fType = 1;
440 TClass* clOfElement = element->GetClassPointer();
441 Int_t nbranches = fBranches.GetEntriesFast();
442 // Note: The following code results in base class branches
443 // having two different cases for what their parent
444 // class will be, this is very annoying. It is also
445 // very annoying that the naming conventions for the
446 // sub-branch names are different as well.
447 if (!strcmp(name, clOfElement->GetName())) {
448 // -- If the branch's name is the same as the base class name,
449 // which happens when we are a child branch of a top-level
450 // branch whose name does not end in a dot and also has no
451 // internal dots, elide the branch name, and keep the branch
452 // hierarchy rooted at the ultimate parent, this keeps the base
453 // class part of the branch name from propagating downwards.
454 // FIXME: We are eliding the base class here, creating a break in the branch hierarchy.
455 // Note: We can use parent class (cltop) != branch class (elemClass) to detection elision.
456 Unroll("", fBranchClass.GetClass(), clOfElement, pointer, basketsize, splitlevel+splitSTLP, 0);
459 return;
460 }
461 // If the branch's name is not the same as the base class name,
462 // keep the branch name as a prefix (i.e., continue the branch
463 // hierarchy), but start a new class hierarchy at the base class.
464 //
465 // Note: If the parent branch was created by the branch constructor
466 // which takes a folder as a parameter, then this case will
467 // be used, because the branch name will be the same as the
468 // parent branch name.
469 // Note: This means that the sub-branches of a base class branch
470 // created by TTree::Bronch() have the base class name as
471 // as part of the branch name, while those created by
472 // Unroll() do not, ouch!!!
473 //
474 Unroll(name, clOfElement, clOfElement, pointer, basketsize, splitlevel+splitSTLP, 0);
475 if (strchr(bname, '.')) {
476 // Note: How can this happen?
477 // Answer: This is the case when using the new branch
478 // naming convention where the top-level branch ends in dot.
479 // Note: Well actually not entirely, we could also be a sub-branch
480 // of a split class, even when the top-level branch does not
481 // end in a dot.
482 // Note: Or the top-level branch could have been created by the
483 // branch constructor which takes a folder as input, in which
484 // case the top-level branch name will have internal dots
485 // representing the folder hierarchy.
488 return;
489 }
490 if (nbranches == fBranches.GetEntriesFast()) {
491 // -- We did not add any branches in the Unroll, finalize our name to be the base class name, because Unroll did not do it for us.
492 const auto bnamelen = strlen(bname);
493 if (bnamelen) {
494 name.Form("%s%s%s", bname, bname[bnamelen-1]=='.' ? "" : ".", clOfElement->GetName());
495 } else {
496 name.Form("%s", clOfElement->GetName());
497 }
498 SetName(name);
499 SetTitle(name);
500 }
503 return;
504 } else if (element->GetClassPointer() == TClonesArray::Class()) {
505 // -- We are a TClonesArray element.
506 Bool_t ispointer = element->IsaPointer();
507 TClonesArray *clones;
508 if (ispointer) {
509 char **ppointer = (char**)(pointer);
510 clones = (TClonesArray*)(*ppointer);
511 } else {
512 clones = (TClonesArray*)pointer;
513 }
514 // basket->DeleteEntryOffset(); //entryoffset not required for the clonesarray counter
515 fEntryOffsetLen = 0;
516 // ===> Create a leafcount
517 TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
518 fNleaves = 1;
519 fLeaves.Add(leaf);
520 fTree->GetListOfLeaves()->Add(leaf);
521 if (!clones) {
523 return;
524 }
525 TClass* clOfClones = clones->GetClass();
526 if (!clOfClones) {
529 return;
530 }
531 fType = 3;
532 // ===> create sub branches for each data member of a TClonesArray
533 //check that the contained objects class name is part of the element title
534 //This name is mandatory when reading the Tree later on and
535 //the parent class with the pointer to the TClonesArray is not available.
536 fClonesName = clOfClones->GetName();
537 fClonesClass = clOfClones;
538 TString aname;
539 aname.Form(" (%s)", clOfClones->GetName());
540 TString atitle = element->GetTitle();
541 if (!atitle.Contains(aname)) {
542 atitle += aname;
543 element->SetTitle(atitle.Data());
544 }
545 TString branchname( name );
546 if (branchname.EndsWith("."))
547 branchname.Remove(branchname.Length()-1);
548 branchname += "_";
549 SetTitle(branchname);
550 leaf->SetName(branchname);
551 leaf->SetTitle(branchname);
552 leaf->SetRange(kTRUE);
553 Unroll(name, clOfClones, clOfClones, pointer, basketsize, splitlevel+splitSTLP, 31);
557 return;
559 // -- We are an STL container element.
560 TClass* contCl = elementClass;
562 TClass* valueClass = GetCollectionProxy()->GetValueClass();
563 // Check to see if we can split the container.
564 Bool_t cansplit = kTRUE;
565 if (!valueClass) {
566 cansplit = kFALSE;
567 } else if ((valueClass == TString::Class()) || (valueClass == TClass::GetClass("string"))) {
568 cansplit = kFALSE;
569 } else if (GetCollectionProxy()->HasPointers() && !splitSTLP ) {
570 cansplit = kFALSE;
571 } else if (!valueClass->CanSplit() && !(GetCollectionProxy()->HasPointers() && splitSTLP)) {
572 cansplit = kFALSE;
573 } else if (valueClass->GetCollectionProxy()) {
574 // -- A collection was stored in a collection, we choose not to split it.
575 // Note: Splitting it would require extending TTreeFormula
576 // to understand how to access it.
577 cansplit = kFALSE;
578 }
579 if (cansplit) {
580 // -- Do the splitting work if we are allowed to.
581 fType = 4;
582 // Create a leaf for the master branch (the counter).
583 TLeaf *leaf = new TLeafElement(this, name, fID, fStreamerType);
584 fNleaves = 1;
585 fLeaves.Add(leaf);
586 fTree->GetListOfLeaves()->Add(leaf);
587 // Check that the contained objects class name is part of the element title.
588 // This name is mandatory when reading the tree later on and
589 // the parent class with the pointer to the STL container is not available.
590 fClonesName = valueClass->GetName();
591 fClonesClass = valueClass;
592 TString aname;
593 aname.Form(" (%s)", valueClass->GetName());
594 TString atitle = element->GetTitle();
595 if (!atitle.Contains(aname)) {
596 atitle += aname;
597 element->SetTitle(atitle.Data());
598 }
599 TString branchname (name);
600 if (branchname.EndsWith("."))
601 branchname.Remove(branchname.Length()-1);
602 branchname += "_";
603 SetTitle(branchname);
604 leaf->SetName(branchname);
605 leaf->SetTitle(branchname);
606 leaf->SetRange(kTRUE);
607 // Create sub branches for each data member of an STL container.
608 Unroll(name, valueClass, valueClass, pointer, basketsize, splitlevel+splitSTLP, 41);
612 return;
613 }
614 } else if (!strchr(elemType, '*') && ((fStreamerType == TVirtualStreamerInfo::kObject) || (fStreamerType == TVirtualStreamerInfo::kAny))) {
615 // -- Create sub-branches for members that are classes.
616 //
617 // Note: This can only happen if we were called directly
618 // (usually by TClass::Bronch) because Unroll never
619 // calls us for an element of this type.
620 fType = 2;
621 TClass* clm = elementClass;
622 Int_t err = Unroll(name, clm, clm, pointer, basketsize, splitlevel+splitSTLP, 0);
623 if (err >= 0) {
624 // Return on success.
625 // FIXME: Why not on error too?
628 return;
629 }
630 }
631 }
632 }
633
634 //
635 // Create a leaf to represent this branch.
636 //
637
638 TLeaf* leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
639 leaf->SetTitle(GetTitle());
640 fNleaves = 1;
641 fLeaves.Add(leaf);
642 fTree->GetListOfLeaves()->Add(leaf);
643
644 //
645 // If we have a counter branch set it now that we have
646 // created our leaf, we cannot do it before then.
647 //
648
649 if (brOfCounter) {
650 SetBranchCount(brOfCounter);
651 }
652
655}
656
657////////////////////////////////////////////////////////////////////////////////
658/// Constructor when the branch object is a TClonesArray.
659///
660/// If splitlevel > 0 this branch in turn is split into sub branches.
661
662TBranchElement::TBranchElement(TTree *tree, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
663: TBranch()
664, fClassName("TClonesArray")
665, fParentName()
666, fInfo((TStreamerInfo*)TClonesArray::Class()->GetStreamerInfo())
667, fInit(kTRUE)
668, fInInitInfo(kFALSE)
669, fInitOffsets(kFALSE)
670, fTargetClass( fClassName )
671, fCurrentClass()
672, fParentClass()
673, fBranchClass(TClonesArray::Class())
674, fBranchID(-1)
675, fReadActionSequence(0)
676, fFillActionSequence(0)
677, fIterators(0)
678, fWriteIterators(0)
679, fPtrIterators(0)
680{
681 Init(tree, 0, bname, clones, basketsize, splitlevel, compress);
682}
683
684////////////////////////////////////////////////////////////////////////////////
685/// Constructor when the branch object is a TClonesArray.
686///
687/// If splitlevel > 0 this branch in turn is split into sub branches.
688
689TBranchElement::TBranchElement(TBranch *parent, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
690: TBranch()
691, fClassName("TClonesArray")
692, fParentName()
693, fInfo((TStreamerInfo*)TClonesArray::Class()->GetStreamerInfo())
694, fInit(kTRUE)
695, fInInitInfo(kFALSE)
696, fInitOffsets(kFALSE)
697, fTargetClass( fClassName )
698, fCurrentClass()
699, fParentClass()
700, fBranchClass(TClonesArray::Class())
701, fBranchID(-1)
702, fReadActionSequence(0)
703, fFillActionSequence(0)
704, fIterators(0)
705, fWriteIterators(0)
706, fPtrIterators(0)
707{
708 Init(parent ? parent->GetTree() : 0, parent, bname, clones, basketsize, splitlevel, compress);
709}
710
711////////////////////////////////////////////////////////////////////////////////
712/// Init when the branch object is a TClonesArray.
713///
714/// If splitlevel > 0 this branch in turn is split into sub branches.
715
716void TBranchElement::Init(TTree *tree, TBranch *parent, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
717{
718 fCollProxy = 0;
719 fSplitLevel = splitlevel;
720 fID = 0;
721 fInit = kTRUE;
722 fStreamerType = -1;
723 fType = 0;
724 fClassVersion = TClonesArray::Class()->GetClassVersion();
726 fBranchCount = 0;
727 fBranchCount2 = 0;
728 fObject = 0;
729 fOnfileObject = 0;
730 fMaximum = 0;
731 fBranchOffset = 0;
734
735 fTree = tree;
736 fMother = parent ? parent->GetMother() : this;
737 fParent = parent;
739 fFileName = "";
740
741 SetName(bname);
742 const char* name = GetName();
743
744 SetTitle(name);
745 //fClassName = fInfo->GetName();
746 fCompress = compress;
747 if (compress == -1 && fTree->GetDirectory()) {
748 TFile *bfile = fTree->GetDirectory()->GetFile();
749 if (bfile) fCompress = bfile->GetCompressionSettings();
750 }
751
752 if (basketsize < 100) basketsize = 100;
753 fBasketSize = basketsize;
757
758 for (Int_t i=0;i<fMaxBaskets;i++) {
759 fBasketBytes[i] = 0;
760 fBasketEntry[i] = 0;
761 fBasketSeek[i] = 0;
762 }
763
764 // Reset the bit kAutoDelete to specify that when reading
765 // the object should not be deleted before calling the streamer.
767
768 // create sub branches if requested by splitlevel
769 if (splitlevel%TTree::kSplitCollectionOfPointers > 0) {
770 TClass* clonesClass = clones->GetClass();
771 if (!clonesClass) {
772 Error("Init","Missing class object of the TClonesArray %s\n",clones->GetName());
773 return;
774 }
775 fType = 3;
776 // ===> Create a leafcount
777 TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
778 fNleaves = 1;
779 fLeaves.Add(leaf);
780 fTree->GetListOfLeaves()->Add(leaf);
781 // ===> create sub branches for each data member of a TClonesArray
782 fClonesName = clonesClass->GetName();
783 fClonesClass = clonesClass;
784 TString branchname( name );
785 if (branchname[branchname.Length()-1]=='.') {
786 branchname.Remove(branchname.Length()-1);
787 }
788 branchname += "_";
789 SetTitle(branchname);
790 leaf->SetName(branchname);
791 leaf->SetTitle(branchname);
792 Unroll(name, clonesClass, clonesClass, 0, basketsize, splitlevel, 31);
796 return;
797 }
798
799 if (!clones->GetClass() || CanSelfReference(clones->GetClass())) {
801 }
802 TLeaf *leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
803 leaf->SetTitle(GetTitle());
804 fNleaves = 1;
805 fLeaves.Add(leaf);
806 fTree->GetListOfLeaves()->Add(leaf);
807
810}
811
812////////////////////////////////////////////////////////////////////////////////
813/// Constructor when the branch object is an STL collection.
814///
815/// If splitlevel > 0 this branch in turn is split into sub branches.
816
817TBranchElement::TBranchElement(TTree *tree, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
818: TBranch()
819, fClassName(cont->GetCollectionClass()->GetName())
820, fParentName()
821, fInit(kTRUE)
822, fInInitInfo(kFALSE)
823, fInitOffsets(kFALSE)
824, fTargetClass( fClassName )
825, fCurrentClass()
826, fParentClass()
827, fBranchClass(cont->GetCollectionClass())
828, fBranchID(-1)
829, fReadActionSequence(0)
830, fFillActionSequence(0)
831, fIterators(0)
832, fWriteIterators(0)
833, fPtrIterators(0)
834{
835 Init(tree, 0, bname, cont, basketsize, splitlevel, compress);
836}
837
838////////////////////////////////////////////////////////////////////////////////
839/// Constructor when the branch object is an STL collection.
840///
841/// If splitlevel > 0 this branch in turn is split into sub branches.
842
843TBranchElement::TBranchElement(TBranch *parent, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
844: TBranch()
845, fClassName(cont->GetCollectionClass()->GetName())
846, fParentName()
847, fInit(kTRUE)
848, fInInitInfo(kFALSE)
849, fInitOffsets(kFALSE)
850, fTargetClass( fClassName )
851, fCurrentClass()
852, fParentClass()
853, fBranchClass(cont->GetCollectionClass())
854, fBranchID(-1)
855, fReadActionSequence(0)
856, fFillActionSequence(0)
857, fIterators(0)
858, fWriteIterators(0)
859, fPtrIterators(0)
860{
861 Init(parent ? parent->GetTree() : 0, parent, bname, cont, basketsize, splitlevel, compress);
862}
863
864////////////////////////////////////////////////////////////////////////////////
865/// Init when the branch object is an STL collection.
866///
867/// If splitlevel > 0 this branch in turn is split into sub branches.
868
869void TBranchElement::Init(TTree *tree, TBranch *parent, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
870{
871 fCollProxy = cont->Generate();
872 TString name( bname );
873 if (name[name.Length()-1]=='.') {
874 name.Remove(name.Length()-1);
875 }
877 fSplitLevel = splitlevel;
878 fInfo = 0;
879 fID = -1;
880 fInit = kTRUE;
881 fStreamerType = -1; // TVirtualStreamerInfo::kSTLp;
882 fType = 0;
885 fBranchCount = 0;
886 fBranchCount2 = 0;
887 fObject = 0;
888 fOnfileObject = 0;
889 fMaximum = 0;
890 fBranchOffset = 0;
891
892 //Must be set here so that write actions will be properly matched to the ReadLeavesPtr
893 fSTLtype = cont->GetCollectionType();
894 if (fSTLtype < 0) {
896 }
897
898 fTree = tree;
899 fMother = parent ? parent->GetMother() : this;
900 fParent = parent;
902 fFileName = "";
903
904 SetName(name);
905 SetTitle(name);
906 //fClassName = fBranchClass.GetClass()->GetName();
907 fCompress = compress;
908 if ((compress == -1) && fTree->GetDirectory()) {
909 TFile* bfile = fTree->GetDirectory()->GetFile();
910 if (bfile) {
912 }
913 }
914
915 if (basketsize < 100) {
916 basketsize = 100;
917 }
918 fBasketSize = basketsize;
919
923
924 for (Int_t i = 0; i < fMaxBaskets; ++i) {
925 fBasketBytes[i] = 0;
926 fBasketEntry[i] = 0;
927 fBasketSeek[i] = 0;
928 }
929
930 // Reset the bit kAutoDelete to specify that, when reading,
931 // the object should not be deleted before calling the streamer.
933
934 // create sub branches if requested by splitlevel
936 (cont->HasPointers() && splitlevel > TTree::kSplitCollectionOfPointers && cont->GetValueClass() && cont->GetValueClass()->CanSplit() ) )
937 {
938 fType = 4;
939 // ===> Create a leafcount
940 TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
941 fNleaves = 1;
942 fLeaves.Add(leaf);
943 fTree->GetListOfLeaves()->Add(leaf);
944 // ===> create sub branches for each data member of an STL container value class
945 TClass* valueClass = cont->GetValueClass();
946 if (!valueClass) {
947 return;
948 }
949 fClonesName = valueClass->GetName();
950 fClonesClass = valueClass;
951 TString branchname( name );
952 branchname += "_";
953 SetTitle(branchname);
954 leaf->SetName(branchname);
955 leaf->SetTitle(branchname);
956 Unroll(name, valueClass, valueClass, 0, basketsize, splitlevel, 41);
960 return;
961 }
962
963 TLeaf *leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
964 leaf->SetTitle(GetTitle());
965 fNleaves = 1;
966 fLeaves.Add(leaf);
967 fTree->GetListOfLeaves()->Add(leaf);
970}
971
972////////////////////////////////////////////////////////////////////////////////
973/// Destructor.
974
976{
977 // Release any allocated I/O buffers.
979 delete fOnfileObject;
980 fOnfileObject = 0;
981 }
982 ResetAddress();
983
984 delete[] fBranchOffset;
985 fBranchOffset = 0;
986
987 fInfo = 0;
988 fBranchCount2 = 0;
989 fBranchCount = 0;
990
991 if (fType == 4 || fType == 0) {
992 // Only the top level TBranchElement containing an STL container,
993 // owns the collectionproxy.
994 delete fCollProxy;
995 }
996 fCollProxy = 0;
997
998 delete fReadActionSequence;
999 delete fFillActionSequence;
1000 delete fIterators;
1001 delete fWriteIterators;
1002 delete fPtrIterators;
1003}
1004
1005//
1006// This function is located here to allow inlining by the optimizer.
1007//
1008////////////////////////////////////////////////////////////////////////////////
1009/// Get streamer info for the branch class.
1010
1012{
1013 // Note: we need to find a way to reduce the complexity of
1014 // this often executed condition.
1015 if (!fInfo || (fInfo && (!fInit || !fInfo->IsCompiled()))) {
1016 const_cast<TBranchElement*>(this)->InitInfo();
1017 }
1018 return fInfo;
1019}
1020
1021////////////////////////////////////////////////////////////////////////////////
1022/// Get streamer info for the branch class.
1023
1025{
1026 return GetInfoImp();
1027}
1028
1029////////////////////////////////////////////////////////////////////////////////
1030/// Browse the branch content.
1031
1033{
1034 Int_t nbranches = fBranches.GetEntriesFast();
1035 if (nbranches > 0) {
1036 TList persistentBranches;
1037 TBranch* branch=0;
1038 TIter iB(&fBranches);
1039 while((branch=(TBranch*)iB())) {
1040 if (branch->IsFolder()) persistentBranches.Add(branch);
1041 else {
1042 // only show branches corresponding to persistent members
1043 TClass* cl=0;
1044 if (strlen(GetClonesName()))
1045 // this works both for top level branches and for sub-branches,
1046 // as GetClonesName() is properly updated for sub-branches
1047 cl=fClonesClass;
1048 else {
1050
1051 // check if we're in a sub-branch of this class
1052 // we can only find out asking the streamer given our ID
1053 TStreamerElement *element=0;
1054 TClass* clsub=0;
1055 if (fID>=0 && GetInfoImp()
1056 && GetInfoImp()->IsCompiled()
1057 && ((element=GetInfoImp()->GetElement(fID)))
1058 && ((clsub=element->GetClassPointer())))
1059 cl=clsub;
1060 }
1061 if (cl) {
1062 TString strMember=branch->GetName();
1063 Size_t mempos=strMember.Last('.');
1064 if (mempos!=kNPOS)
1065 strMember.Remove(0, (Int_t)mempos+1);
1066 mempos=strMember.First('[');
1067 if (mempos!=kNPOS)
1068 strMember.Remove((Int_t)mempos);
1069 TDataMember* m=cl->GetDataMember(strMember);
1070 if (!m || m->IsPersistent()) persistentBranches.Add(branch);
1071 } else persistentBranches.Add(branch);
1072 } // branch if not a folder
1073 }
1074 persistentBranches.Browse(b);
1075 // add all public const methods without params
1076 if (GetBrowsables() && GetBrowsables()->GetSize())
1078 } else {
1079 if (GetBrowsables() && GetBrowsables()->GetSize()) {
1081 return;
1082 }
1083 // Get the name and strip any extra brackets
1084 // in order to get the full arrays.
1085 TString slash("/");
1086 TString escapedSlash("\\/");
1087 TString name = GetName();
1088 Int_t pos = name.First('[');
1089 if (pos != kNPOS) {
1090 name.Remove(pos);
1091 }
1092 TString mothername;
1093 if (GetMother()) {
1094 mothername = GetMother()->GetName();
1095 pos = mothername.First('[');
1096 if (pos != kNPOS) {
1097 mothername.Remove(pos);
1098 }
1099 Int_t len = mothername.Length();
1100 if (len) {
1101 if (mothername(len-1) != '.') {
1102 // We do not know for sure whether the mother's name is
1103 // already preprended. So we need to check:
1104 // a) it is prepended
1105 // b) it is NOT the name of a daughter (i.e. mothername.mothername exist)
1106 TString doublename = mothername;
1107 doublename.Append(".");
1108 Int_t isthere = (name.Index(doublename) == 0);
1109 if (!isthere) {
1110 name.Prepend(doublename);
1111 } else {
1112 if (GetMother()->FindBranch(mothername)) {
1113 doublename.Append(mothername);
1114 isthere = (name.Index(doublename) == 0);
1115 if (!isthere) {
1116 mothername.Append(".");
1117 name.Prepend(mothername);
1118 }
1119 } else {
1120 // Nothing to do because the mother's name is
1121 // already in the name.
1122 }
1123 }
1124 } else {
1125 // If the mother's name end with a dot then
1126 // the daughter probably already contains the mother's name
1127 if (name.Index(mothername) == kNPOS) {
1128 name.Prepend(mothername);
1129 }
1130 }
1131 }
1132 }
1133 name.ReplaceAll(slash, escapedSlash);
1134 GetTree()->Draw(name, "", b ? b->GetDrawOption() : "");
1135 if (gPad) {
1136 gPad->Update();
1137 }
1138 }
1139}
1140
1141////////////////////////////////////////////////////////////////////////////////
1142/// Set branch and leaf name and title in the case of a container sub-branch.
1143
1145{
1146 TString branchname;
1147
1148 Int_t nbranches = fBranches.GetEntriesFast();
1149
1150 TString indexname(name);
1151 if (indexname[indexname.Length()-1]=='.') {
1152 indexname.Remove(indexname.Length()-1);
1153 }
1154 indexname += "_";
1155
1156 for (Int_t i = 0; i < nbranches; ++i) {
1158 if (!bre)
1159 continue;
1160 if (fType == 3) {
1161 bre->SetType(31);
1162 } else if (fType == 4) {
1163 bre->SetType(41);
1164 } else {
1165 Error("BuildTitle", "This cannot happen, fType of parent is not 3 or 4!");
1166 }
1168 bre->BuildTitle(name);
1169 const char* fin = strrchr(bre->GetTitle(), '.');
1170 if (fin == 0) {
1171 continue;
1172 }
1173 // The branch counter for a sub-branch of a container is the container master branch.
1174 bre->SetBranchCount(this);
1175 TLeafElement* lf = (TLeafElement*) bre->GetListOfLeaves()->At(0);
1176 // If branch name is of the form fTracks.fCovar[3][4], then
1177 // set the title to fCovar[fTracks_].
1178 branchname = fin+1;
1179 Ssiz_t dim = branchname.First('[');
1180 if (dim>=0) {
1181 branchname.Remove(dim);
1182 }
1183 branchname += TString::Format("[%s]", indexname.Data());
1184 bre->SetTitle(branchname);
1185 if (lf) {
1186 lf->SetTitle(branchname);
1187 }
1188 // Is there a secondary branchcount?
1189 //
1190 // fBranchCount2 points to the secondary branchcount
1191 // in case a TClonesArray element itself has a branchcount.
1192 //
1193 // Example: In Event class with TClonesArray fTracks of Track objects.
1194 // if the Track object has two members
1195 // Int_t fNpoint;
1196 // Float_t *fPoints; //[fNpoint]
1197 // In this case the TBranchElement fTracks.fPoints has
1198 // -its primary branchcount pointing to the branch fTracks
1199 // -its secondary branchcount pointing to fTracks.fNpoint
1200 Int_t stype = bre->GetStreamerType();
1201 // FIXME: Should 60 be included here?
1202 if ((stype > 40) && (stype < 61)) {
1203 TString name2 (bre->GetName());
1204 Ssiz_t bn = name2.Last('.');
1205 if (bn<0) {
1206 continue;
1207 }
1209 name2.Remove(bn+1);
1210 if (el) name2 += el->GetCountName();
1212 bre->SetBranchCount2(bc2);
1213 }
1214 bre->SetReadLeavesPtr();
1215 bre->SetFillLeavesPtr();
1216 }
1217}
1218
1219////////////////////////////////////////////////////////////////////////////////
1220/// Loop on all leaves of this branch to fill the basket buffer.
1221///
1222/// The function returns the number of bytes committed to the
1223/// individual branches. If a write error occurs, the number of
1224/// bytes returned is -1. If no data are written, because, e.g.,
1225/// the branch is disabled, the number of bytes returned is 0.
1226///
1227/// Note: We not not use any member functions from TLeafElement!
1228
1230{
1231 Int_t nbytes = 0;
1232 Int_t nwrite = 0;
1233 Int_t nerror = 0;
1234 Int_t nbranches = fBranches.GetEntriesFast();
1235
1237
1238 //
1239 // If we are a top-level branch, update addresses.
1240 //
1241
1242 if (fID < 0) {
1243 if (!fObject) {
1244 Error("Fill", "attempt to fill branch %s while address is not set", GetName());
1245 return 0;
1246 }
1247 }
1248
1249 //
1250 // If the tree has a TRefTable, set the current branch if
1251 // branch is not a basic type.
1252 //
1253
1254 // FIXME: This test probably needs to be extended past 10.
1255 if ((fType >= -1) && (fType < 10)) {
1256 TBranchRef* bref = fTree->GetBranchRef();
1257 if (bref) {
1258 fBranchID = bref->SetParent(this, fBranchID);
1259 }
1260 }
1261
1262 if (!nbranches) {
1263 // No sub-branches.
1264 if (!TestBit(kDoNotProcess)) {
1265 nwrite = TBranch::FillImpl(imtHelper);
1266 if (nwrite < 0) {
1267 Error("Fill", "Failed filling branch:%s, nbytes=%d", GetName(), nwrite);
1268 ++nerror;
1269 } else {
1270 nbytes += nwrite;
1271 }
1272 }
1273 } else {
1274 // We have sub-branches.
1275 if (fType == 3 || fType == 4) {
1276 // TClonesArray or STL container counter
1277 nwrite = TBranch::FillImpl(imtHelper);
1278 if (nwrite < 0) {
1279 Error("Fill", "Failed filling branch:%s, nbytes=%d", GetName(), nwrite);
1280 ++nerror;
1281 } else {
1282 nbytes += nwrite;
1283 }
1284 } else {
1285 ++fEntries;
1286 }
1287 for (Int_t i = 0; i < nbranches; ++i) {
1288 TBranchElement* branch = (TBranchElement*) fBranches[i];
1289 if (!branch->TestBit(kDoNotProcess)) {
1290 nwrite = branch->FillImpl(imtHelper);
1291 if (nwrite < 0) {
1292 Error("Fill", "Failed filling branch:%s.%s, nbytes=%d", GetName(), branch->GetName(), nwrite);
1293 nerror++;
1294 } else {
1295 nbytes += nwrite;
1296 }
1297 }
1298 }
1299 }
1300
1301 if (fTree->Debug() > 0) {
1302 // Debugging.
1303 Long64_t entry = fEntries;
1304 if ((entry >= fTree->GetDebugMin()) && (entry <= fTree->GetDebugMax())) {
1305 printf("Fill: %lld, branch=%s, nbytes=%d\n", entry, GetName(), nbytes);
1306 }
1307 }
1308
1309 if (nerror != 0) {
1310 return -1;
1311 }
1312
1313 return nbytes;
1314}
1315
1316////////////////////////////////////////////////////////////////////////////////
1317/// Write leaves into i/o buffers for this branch.
1318/// For the case where the branch is set in MakeClass mode (decomposed object).
1319
1321{
1323
1324 //
1325 // Silently do nothing if we have no user i/o buffer.
1326 //
1327
1328 if (!fObject) {
1329 return;
1330 }
1331
1332 // -- TClonesArray top-level branch. Write out number of entries, sub-branch writes the entries themselves.
1333 if(fType == 3) {
1334 // fClonesClass can not be zero since we are of type 3, see TBranchElement::Init
1336 if (!si) {
1337 Error("FillLeaves", "Cannot get streamer info for branch '%s' class '%s'", GetName(), fClonesClass->GetName());
1338 return;
1339 }
1340 b.ForceWriteInfo(si,kFALSE);
1341 Int_t* nptr = (Int_t*) fAddress;
1342 b << *nptr;
1343 } else if (fType == 31) {
1344 // -- TClonesArray sub-branch. Write out the entries in the TClonesArray.
1345 // -- A MakeClass() tree, we must use fAddress instead of fObject.
1346 if (!fAddress) {
1347 // FIXME: Enable this message.
1348 //Error("FillLeaves", "Branch address not set for branch '%s'!", GetName());
1349 return;
1350 }
1351 Int_t atype = fStreamerType;
1352 if (atype > 54) {
1353 // Note: We are not supporting kObjectp, kAny, kObjectp,
1354 // kObjectP, kTString, kTObject, kTNamed, kAnyp,
1355 // kAnyP, kSTLp, kSTL, kSTLstring, kStreamer,
1356 // kStreamLoop here, nor pointers to varying length
1357 // arrays of them either.
1358 // Nor do we support pointers to varying length
1359 // arrays of kBits, kLong64, kULong64, nor kBool.
1360 return;
1361 }
1362 Int_t* nn = (Int_t*) fBranchCount->GetAddress();
1363 if (!nn) {
1364 Error("FillLeaves", "The branch counter address was zero!");
1365 return;
1366 }
1367 Int_t n = *nn;
1368 if (atype > 40) {
1369 // Note: We are not supporting pointer to varying length array.
1370 Error("FillLeaves", "Clonesa: %s, n=%d, sorry not supported yet", GetName(), n);
1371 return;
1372 }
1373 if (atype > 20) {
1374 atype -= 20;
1376 n = n * leaf->GetLenStatic();
1377 }
1378 switch (atype) {
1379 // Note: Type 0 is a base class and cannot happen here, see Unroll().
1380 case TVirtualStreamerInfo::kChar /* 1 */: { b.WriteFastArray((Char_t*) fAddress, n); break; }
1381 case TVirtualStreamerInfo::kShort /* 2 */: { b.WriteFastArray((Short_t*) fAddress, n); break; }
1382 case TVirtualStreamerInfo::kInt /* 3 */: { b.WriteFastArray((Int_t*) fAddress, n); break; }
1383 case TVirtualStreamerInfo::kLong /* 4 */: { b.WriteFastArray((Long_t*) fAddress, n); break; }
1384 case TVirtualStreamerInfo::kFloat /* 5 */: { b.WriteFastArray((Float_t*) fAddress, n); break; }
1385 case TVirtualStreamerInfo::kCounter /* 6 */: { b.WriteFastArray((Int_t*) fAddress, n); break; }
1386 // FIXME: We do nothing with type 7 (TVirtualStreamerInfo::kCharStar, char*) here!
1387 case TVirtualStreamerInfo::kDouble /* 8 */: { b.WriteFastArray((Double_t*) fAddress, n); break; }
1388 case TVirtualStreamerInfo::kDouble32 /* 9 */: {
1390 // coverity[returned_null] structurally si->fComp (used in GetElem) can not be null.
1391 TStreamerElement* se = si->GetElement(fID);
1392 Double_t* xx = (Double_t*) fAddress;
1393 for (Int_t ii = 0; ii < n; ++ii) {
1394 b.WriteDouble32(&(xx[ii]),se);
1395 }
1396 break;
1397 }
1398 case TVirtualStreamerInfo::kFloat16 /* 19 */: {
1400 // coverity[dereference] structurally si can not be null.
1402 Float_t* xx = (Float_t*) fAddress;
1403 for (Int_t ii = 0; ii < n; ++ii) {
1404 b.WriteFloat16(&(xx[ii]),se);
1405 }
1406 break;
1407 }
1408 // Note: Type 10 is unused for now.
1409 case TVirtualStreamerInfo::kUChar /* 11 */: { b.WriteFastArray((UChar_t*) fAddress, n); break; }
1410 case TVirtualStreamerInfo::kUShort /* 12 */: { b.WriteFastArray((UShort_t*) fAddress, n); break; }
1411 case TVirtualStreamerInfo::kUInt /* 13 */: { b.WriteFastArray((UInt_t*) fAddress, n); break; }
1412 case TVirtualStreamerInfo::kULong /* 14 */: { b.WriteFastArray((ULong_t*) fAddress, n); break; }
1413 // FIXME: This is wrong!!! TVirtualStreamerInfo::kBits is a variable length type.
1414 case TVirtualStreamerInfo::kBits /* 15 */: { b.WriteFastArray((UInt_t*) fAddress, n); break; }
1415 case TVirtualStreamerInfo::kLong64 /* 16 */: { b.WriteFastArray((Long64_t*) fAddress, n); break; }
1416 case TVirtualStreamerInfo::kULong64 /* 17 */: { b.WriteFastArray((ULong64_t*) fAddress, n); break; }
1417 case TVirtualStreamerInfo::kBool /* 18 */: { b.WriteFastArray((Bool_t*) fAddress, n); break; }
1418 }
1419 }
1420}
1421
1422////////////////////////////////////////////////////////////////////////////////
1423/// Write leaves into i/o buffers for this branch.
1424/// Case of a collection (fType == 4).
1425
1427{
1428 // -- STL container top-level branch. Write out number of entries, sub-branch writes the entries themselves.
1430
1431 //
1432 // Silently do nothing if we have no user i/o buffer.
1433 //
1434
1435 if (!fObject) {
1436 return;
1437 }
1438
1440 Int_t n = 0;
1441 // We are in a block so the helper pops as soon as possible.
1443 n = proxy->Size();
1444
1445 if (n > fMaximum) {
1446 fMaximum = n;
1447 }
1448 b << n;
1449
1452 } else {
1453 //NOTE: this does not work for not vectors since the CreateIterators expects a TGenCollectionProxy::TStaging as its argument!
1454 //NOTE: and those not work in general yet, since the TStaging object is neither created nor passed.
1455 // We need to review how to avoid the need for a TStaging during the writing.
1458 } else {
1460 }
1461 }
1462
1463}
1464
1465////////////////////////////////////////////////////////////////////////////////
1466/// Write leaves into i/o buffers for this branch.
1467/// Case of a data member within a collection (fType == 41).
1468
1470{
1472
1473 //
1474 // Silently do nothing if we have no user i/o buffer.
1475 //
1476
1477 if (!fObject) {
1478 return;
1479 }
1480
1481 // FIXME: This wont work if a pointer to vector is split!
1483 // Note: We cannot pop the proxy here because we need it for the i/o.
1485 if (!si) {
1486 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1487 return;
1488 }
1489
1491 R__ASSERT(0!=iter);
1492 b.ApplySequenceVecPtr(*fFillActionSequence,iter->fBegin,iter->fEnd);
1493}
1494
1495////////////////////////////////////////////////////////////////////////////////
1496/// Write leaves into i/o buffers for this branch.
1497/// Case of a data member within a collection (fType == 41).
1498
1500{
1502
1503 //
1504 // Silently do nothing if we have no user i/o buffer.
1505 //
1506
1507 if (!fObject) {
1508 return;
1509 }
1510
1511 // FIXME: This wont work if a pointer to vector is split!
1513
1514 // Note: We cannot pop the proxy here because we need it for the i/o.
1516 if (!si) {
1517 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1518 return;
1519 }
1520
1522 b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);
1523
1524}
1525
1526////////////////////////////////////////////////////////////////////////////////
1527/// Write leaves into i/o buffers for this branch.
1528/// Case of a data member within a collection (fType == 41).
1529
1531{
1533
1534 //
1535 // Silently do nothing if we have no user i/o buffer.
1536 //
1537
1538 if (!fObject) {
1539 return;
1540 }
1541
1542 // FIXME: This wont work if a pointer to vector is split!
1544 // Note: We cannot pop the proxy here because we need it for the i/o.
1546 if (!si) {
1547 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1548 return;
1549 }
1550
1552 R__ASSERT(0!=iter);
1553 b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);
1554
1555}
1556
1557////////////////////////////////////////////////////////////////////////////////
1558/// Write leaves into i/o buffers for this branch.
1559/// Case of a data member within a collection (fType == 41).
1560
1562{
1564
1565 //
1566 // Silently do nothing if we have no user i/o buffer.
1567 //
1568
1569 if (!fObject) {
1570 return;
1571 }
1572
1573 // FIXME: This wont work if a pointer to vector is split!
1575 // Note: We cannot pop the proxy here because we need it for the i/o.
1577 if (!si) {
1578 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1579 return;
1580 }
1581
1583 R__ASSERT(0!=iter);
1584 b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);
1585
1586}
1587
1588////////////////////////////////////////////////////////////////////////////////
1589/// Write leaves into i/o buffers for this branch.
1590/// Case of a TClonesArray (fType == 3).
1591
1593{
1594 // -- TClonesArray top-level branch. Write out number of entries, sub-branch writes the entries themselves.
1596
1597 //
1598 // Silently do nothing if we have no user i/o buffer.
1599 //
1600
1601 if (!fObject) {
1602 return;
1603 }
1604
1605 TClonesArray* clones = (TClonesArray*) fObject;
1606 Int_t n = clones->GetEntriesFast();
1607 if (n > fMaximum) {
1608 fMaximum = n;
1609 }
1610 b << n;
1611}
1612
1613////////////////////////////////////////////////////////////////////////////////
1614/// Write leaves into i/o buffers for this branch.
1615/// Case of a data member within a TClonesArray (fType == 31).
1616
1618{
1620
1621 //
1622 // Silently do nothing if we have no user i/o buffer.
1623 //
1624
1625 if (!fObject) {
1626 return;
1627 }
1628
1629 TClonesArray* clones = (TClonesArray*) fObject;
1630 Int_t n = clones->GetEntriesFast();
1632 if (!si) {
1633 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1634 return;
1635 }
1636
1637 char **arr = (char **)clones->GetObjectRef(0);
1638 char **end = arr + n;
1639 b.ApplySequenceVecPtr(*fFillActionSequence,arr,end);
1640}
1641
1642////////////////////////////////////////////////////////////////////////////////
1643/// Write leaves into i/o buffers for this branch.
1644/// Case of a non TObject, non collection class with a custom streamer
1645
1647{
1649
1650 //
1651 // Silently do nothing if we have no user i/o buffer.
1652 //
1653
1654 if (!fObject) {
1655 return;
1656 }
1657
1658 //
1659 // Remember tobjects written to the buffer so that
1660 // pointers are handled correctly later.
1661
1662 if (TestBit(kBranchObject)) {
1663 b.MapObject((TObject*) fObject);
1664 } else if (TestBit(kBranchAny)) {
1665 b.MapObject(fObject, fBranchClass);
1666 }
1667
1669}
1670
1671////////////////////////////////////////////////////////////////////////////////
1672/// Write leaves into i/o buffers for this branch.
1673/// For split-class branch, base class branch, data member branch, or top-level branch.
1674/// which do have a branch count and are not a counter.
1675
1677{
1679 /*
1680 ValidateAddress();
1681
1682 //
1683 // Silently do nothing if we have no user i/o buffer.
1684 //
1685
1686 if (!fObject) {
1687 return;
1688 }
1689 */
1690}
1691
1692////////////////////////////////////////////////////////////////////////////////
1693/// Write leaves into i/o buffers for this branch.
1694/// For split-class branch, base class branch, data member branch, or top-level branch.
1695/// which do not have a branch count and are a counter.
1696
1698{
1700
1701 //
1702 // Silently do nothing if we have no user i/o buffer.
1703 //
1704
1705 if (!fObject) {
1706 return;
1707 }
1708 // -- Top-level, data member, base class, or split class branch.
1709 // A non-split top-level branch (0, and fID == -1)), a non-split object (0, and fID > -1), or a base class (1), or a split (non-TClonesArray, non-STL container) object (2). Write out the object.
1710 // Note: A split top-level branch (0, and fID == -2) should not happen here, see Fill().
1711 // FIXME: What happens with a split base class branch,
1712 // or a split class branch???
1713 TStreamerInfo* si = GetInfoImp();
1714 if (!si) {
1715 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1716 return;
1717 }
1718 // Since info is not null, fFillActionSequence is not null either.
1719 b.ApplySequence(*fFillActionSequence, fObject);
1720 // Int_t n = si->WriteBufferAux(b, &fObject, fID, 1, 0, 0);
1721
1722 Int_t n = *(Int_t*)(fObject + si->TStreamerInfo::GetElementOffset(fID)); // or GetInfoImp()->GetTypedValue<Int_t>(&fObject, fID, j, -1);
1723 if (n > fMaximum) {
1724 fMaximum = n;
1725 }
1726
1727}
1728
1729////////////////////////////////////////////////////////////////////////////////
1730/// Write leaves into i/o buffers for this branch.
1731/// For split-class branch, base class branch, data member branch, or top-level branch.
1732/// which do not have a branch count and are not a counter.
1733
1735{
1737
1738 //
1739 // Silently do nothing if we have no user i/o buffer.
1740 //
1741
1742 if (!fObject) {
1743 return;
1744 }
1745
1746 if (TestBit(kBranchObject)) {
1747 b.MapObject((TObject*) fObject);
1748 } else if (TestBit(kBranchAny)) {
1749 b.MapObject(fObject, fBranchClass);
1750 }
1751
1752 // -- Top-level, data member, base class, or split class branch.
1753 // A non-split top-level branch (0, and fID == -1)), a non-split object (0, and fID > -1), or a base class (1), or a split (non-TClonesArray, non-STL container) object (2). Write out the object.
1754 // Note: A split top-level branch (0, and fID == -2) should not happen here, see Fill().
1755 // FIXME: What happens with a split base class branch,
1756 // or a split class branch???
1757 TStreamerInfo* si = GetInfoImp();
1758 if (!si) {
1759 Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
1760 return;
1761 }
1762 // Since info is not null, fFillActionSequence is not null either.
1763 b.ApplySequence(*fFillActionSequence, fObject);
1764
1765}
1766
1767////////////////////////////////////////////////////////////////////////////////
1768/// Remove trailing dimensions and make sure
1769/// there is a trailing dot.
1770
1771static void R__CleanName(std::string &name)
1772{
1773 if (name[name.length()-1]==']') {
1774 std::size_t dim = name.find_first_of("[");
1775 if (dim != std::string::npos) {
1776 name.erase(dim);
1777 }
1778 }
1779 if (name[name.size()-1] != '.') {
1780 name += '.';
1781 }
1782}
1783
1784////////////////////////////////////////////////////////////////////////////////
1785/// Find the immediate sub-branch with passed name.
1786
1788{
1789 // The default behavior of TBranch::FindBranch is sometimes
1790 // incorrect if this branch represent a base class, since
1791 // the base class name might or might not be in the name
1792 // of the sub-branches and might or might not be in the
1793 // name being passed.
1794
1795 if (fID >= 0) {
1797 TStreamerElement* se = si->GetElement(fID);
1798 if (se && se->IsBase()) {
1799 // We allow the user to pass only the last dotted component of the name.
1800 UInt_t len = strlen(name);
1801 std::string longnm;
1802 longnm.reserve(fName.Length()+len+3); // Enough space of fName + name + dots
1803 longnm = fName.Data();
1804 R__CleanName(longnm);
1805 longnm += name;
1806 std::string longnm_parent;
1807 longnm_parent.reserve(fName.Length()+len+3);
1808 longnm_parent = (GetMother()->GetSubBranch(this)->GetName());
1809 R__CleanName(longnm_parent);
1810 longnm_parent += name; // Name without the base class name
1811
1812 UInt_t namelen = strlen(name);
1813
1814 TBranch* branch = 0;
1815 Int_t nbranches = fBranches.GetEntries();
1816 for(Int_t i = 0; i < nbranches; ++i) {
1817 branch = (TBranch*) fBranches.UncheckedAt(i);
1818
1819 const char *brname = branch->GetName();
1820 UInt_t brlen = strlen(brname);
1821 if (brname[brlen-1]==']') {
1822 const char *dim = strchr(brname,'[');
1823 if (dim) {
1824 brlen = dim - brname;
1825 }
1826 }
1827 if (namelen == brlen /* same effective size */
1828 && strncmp(name,brname,brlen) == 0) {
1829 return branch;
1830 }
1831 if (brlen == longnm.length()
1832 && strncmp(longnm.c_str(),brname,brlen) == 0) {
1833 return branch;
1834 }
1835 // This check is specific to base class
1836 if (brlen == longnm_parent.length()
1837 && strncmp(longnm_parent.c_str(),brname,brlen) == 0) {
1838 return branch;
1839 }
1840
1841 if (namelen>brlen && name[brlen]=='.' && strncmp(name,brname,brlen)==0) {
1842 // The prefix subbranch name match the branch name.
1843 return branch->FindBranch(name+brlen+1);
1844 }
1845 }
1846 }
1847 }
1848 TBranch *result = TBranch::FindBranch(name);
1849 if (!result) {
1850 // Look in base classes if any
1851 Int_t nbranches = fBranches.GetEntries();
1852 for(Int_t i = 0; i < nbranches; ++i) {
1853 TObject *obj = fBranches.UncheckedAt(i);
1854 if(obj->IsA() != TBranchElement :: Class() )
1855 continue;
1856 TBranchElement *br = (TBranchElement*)obj;
1857 TVirtualStreamerInfo* si = br->GetInfoImp();
1858 if (si && br->GetID() >= 0) {
1859 TStreamerElement* se = si->GetElement(br->GetID());
1860 if (se && se->IsBase()) {
1861 result = br->FindBranch(name);
1862 }
1863 }
1864 }
1865 }
1866 return result;
1867}
1868
1869////////////////////////////////////////////////////////////////////////////////
1870/// Find the leaf corresponding to the name 'searchname'.
1871
1873{
1874 TLeaf *leaf = TBranch::FindLeaf(name);
1875
1876 if (leaf==0 && GetListOfLeaves()->GetEntries()==1) {
1877 TBranch *br = GetMother()->GetSubBranch( this );
1878 if( br->IsA() != TBranchElement::Class() )
1879 return 0;
1880
1881 TBranchElement *parent = (TBranchElement*)br;
1882 if (parent==this || parent->GetID()<0 ) return 0;
1883
1884 TVirtualStreamerInfo* si = parent->GetInfoImp();
1885 TStreamerElement* se = si->GetElement(parent->GetID());
1886
1887 if (! se->IsBase() ) return 0;
1888
1889 br = GetMother()->GetSubBranch( parent );
1890 if( br->IsA() != TBranchElement::Class() )
1891 return 0;
1892
1893 TBranchElement *grand_parent = (TBranchElement*)br;
1894
1895 std::string longname( grand_parent->GetName() );
1896 R__CleanName(longname);
1897 longname += name;
1898
1899 std::string leafname( GetListOfLeaves()->At(0)->GetName() );
1900
1901 if ( longname == leafname ) {
1902 return (TLeaf*)GetListOfLeaves()->At(0);
1903 }
1904 }
1905 return leaf;
1906}
1907
1908////////////////////////////////////////////////////////////////////////////////
1909/// Get the branch address.
1910///
1911/// If we are *not* owned by a MakeClass() tree:
1912///
1913/// - If we are a top-level branch, return a pointer
1914/// - to the pointer to our object.
1915///
1916/// If we are *not* a top-level branch, return a pointer
1917/// to our object.
1918///
1919/// If we are owned by a MakeClass() tree:
1920///
1921/// - Return a pointer to our object.
1922
1924{
1926 return fAddress;
1927}
1928
1929
1930// For a mother branch of type 3 or 4, find the 'correct' StreamerInfo for the
1931// content of the collection by find a sub-branch corresponding to a direct data member
1932// of the containee class (valueClass)
1933// Default to the current StreamerInfo if none are found.
1935{
1936 TStreamerInfo *localInfo = nullptr;
1937
1938 // Search for the correct version.
1939 for(auto subbe : TRangeDynCast<TBranchElement>( branches )) {
1940 if (!subbe->fInfo)
1941 subbe->SetupInfo();
1942 if (valueClass == subbe->fInfo->GetClass()) { // Use GetInfo to provoke its creation.
1943 localInfo = subbe->fInfo;
1944 break;
1945 }
1946 }
1947 if (!localInfo) {
1948 // This is likely sub-optimal as we really should call GetFile but it is non-const.
1949 auto file = fDirectory ? fDirectory->GetFile() : nullptr;
1950 if (file && file->GetSeekInfo()) {
1951 localInfo = (TStreamerInfo*)file->GetStreamerInfoCache()->FindObject(valueClass->GetName());
1952 if (localInfo) {
1953 if (valueClass->IsVersioned()) {
1954 localInfo = (TStreamerInfo*)valueClass->GetStreamerInfo(localInfo->GetClassVersion());
1955 } else {
1956 localInfo = (TStreamerInfo*)valueClass->FindStreamerInfo(localInfo->GetCheckSum());
1957 if (localInfo) {
1958 // Now that we found it, we need to make sure it is initialize (Find does not initialize the StreamerInfo).
1959 localInfo = (TStreamerInfo*)valueClass->GetStreamerInfo(localInfo->GetClassVersion());
1960 }
1961 }
1962 }
1963 }
1964 }
1965 if (!localInfo)
1966 localInfo = (TStreamerInfo*)valueClass->GetStreamerInfo();
1967
1968 if (localInfo) {
1969 // See if we need any conversion.
1970 TClass *targetValueClass = fInfo->GetClass()->GetCollectionProxy()
1972 : nullptr;
1973 // For TClonesArray, the rest of the code probably does not support change in
1974 // value class, but if it does, we would have to look up the target value class
1975 // in the TClonesArray instance.
1976 // if (type == 3 && instance) targetValueClass = ((TClonesArray*)instance)->GetClass();
1977
1978 if (targetValueClass && localInfo->GetClass() != targetValueClass) {
1979 localInfo = (TStreamerInfo*)targetValueClass->GetConversionStreamerInfo(localInfo->GetClass(),
1980 localInfo->GetClassVersion());
1981 }
1982 }
1983 return localInfo;
1984}
1985
1986namespace {
1987static void GatherArtificialElements(const TObjArray &branches, TStreamerInfoActions::TIDs &ids, TString prefix, TStreamerInfo *info, Int_t offset) {
1988 size_t ndata = info->GetNelement();
1989 for (size_t i =0; i < ndata; ++i) {
1990 TStreamerElement *nextel = info->GetElement(i);
1991
1992 if (nextel->GetType() == TStreamerInfo::kCacheDelete
1993 || nextel->GetType() == TStreamerInfo::kCacheNew) {
1994 continue;
1995 }
1996
1997 TString ename = prefix + nextel->GetName();
1998
1999 if (ename[0]=='*')
2000 ename.Remove(0,1);
2001
2002 Ssiz_t pos;
2003 while ((pos = ename.Last('[')) != TString::kNPOS) {
2004 ename = ename.Remove(pos);
2005 }
2006
2007 TBranchElement *be = (TBranchElement*)branches.FindObject(ename);
2008 if (nextel->IsA() == TStreamerArtificial::Class()
2009 && be == nullptr) {
2010
2011 ids.push_back(i);
2012 ids.back().fElement = nextel;
2013 ids.back().fInfo = info;
2014 }
2015
2016 if (nextel->CannotSplit() || nextel->IsTransient() || nextel->GetOffset() == TStreamerInfo::kMissing)
2017 continue;
2018
2019 if (!be && nextel->IsBase()) {
2020 // We could be in the case of a branch created from a Folder or
2021 // a top level branch with a non-trailing dot in its name (case inadvertently confused with the folder case).
2022 // In those case, the name of the base class is *not* used to create the corresponding branch.
2023 TString subprefix(prefix);
2024 if (subprefix.Length() && subprefix[subprefix.Length()-1] == '.')
2025 subprefix.Remove(subprefix.Length()-1);
2026
2027 be = (TBranchElement*)branches.FindObject(subprefix);
2028 if (be) {
2029 // There is at least 'one' base class branch all with the same name, so let's find the
2030 // right one.
2031 TClass *expectedClass = nullptr;
2032 EDataType expectedType;
2033 if (0 != be->GetExpectedType(expectedClass,expectedType)
2034 || expectedClass != nextel->GetClassPointer())
2035 {
2036 be = nullptr;
2037 Int_t nbranches = branches.GetEntriesFast();
2038 for (Int_t bi = 0; bi < nbranches; ++bi) {
2039 TBranchElement* branch = (TBranchElement*) branches[bi];
2040 if (subprefix != branch->GetName())
2041 continue;
2042 if (0 == branch->GetExpectedType(expectedClass,expectedType)
2043 && expectedClass == nextel->GetClassPointer())
2044 {
2045 be = branch;
2046 break;
2047 }
2048 }
2049 } // else we have already found the right branch.
2050 }
2051 }
2052
2053 TClass *elementClass = nextel->GetClassPointer();
2054 if (elementClass && (!be || be->GetType() == -2)) {
2055 // Recurse on sub-objects.
2056 TStreamerInfo *nextinfo = nullptr;
2057
2058 // nextinfo_version = ....
2059 auto search = be ? be->GetListOfBranches() : &branches;
2060 TVirtualArray *onfileObject = nullptr;
2061
2062 TString subprefix;
2063 if (prefix.Length() && nextel->IsA() == TStreamerBase::Class()) {
2064 // We skip the name of the base class if there is already a prefix.
2065 // See TBranchElement::Unroll
2066 subprefix = prefix;
2067 } else {
2068 subprefix = ename + ".";
2069 }
2070 auto nbranches = search->GetEntriesFast();
2071 bool foundRelatedSplit = false;
2072 for (Int_t bi = 0; bi < nbranches; ++bi) {
2073 TBranchElement* subbe = (TBranchElement*)search->At(bi);
2074 bool matchSubPrefix = strncmp(subbe->GetFullName(), subprefix.Data(), subprefix.Length()) == 0;
2075 if (!foundRelatedSplit)
2076 foundRelatedSplit = matchSubPrefix;
2077 if (elementClass == subbe->GetInfo()->GetClass() // Use GetInfo to provoke its creation.
2078 && subbe->GetOnfileObject()
2079 && matchSubPrefix)
2080 {
2081 nextinfo = subbe->GetInfo();
2082 onfileObject = subbe->GetOnfileObject();
2083 break;
2084 }
2085 }
2086
2087 if (!foundRelatedSplit) {
2088 continue;
2089 }
2090
2091 if (!nextinfo) {
2092 nextinfo = (TStreamerInfo *)elementClass->GetStreamerInfo();
2093 if (elementClass->GetCollectionProxy() && elementClass->GetCollectionProxy()->GetValueClass()) {
2094 nextinfo = (TStreamerInfo *)elementClass->GetCollectionProxy()->GetValueClass()->GetStreamerInfo(); // NOTE: need to find the right version
2095 }
2096 }
2097 ids.emplace_back(nextinfo, offset + nextel->GetOffset());
2098 if (!onfileObject && nextinfo && nextinfo->GetNelement() && nextinfo->GetElement(0)->GetType() == TStreamerInfo::kCacheNew) {
2099 onfileObject = new TVirtualArray( info->GetElement(0)->GetClassPointer(), 1 /* is that always right? */ );
2100 ids.back().fNestedIDs->fOwnOnfileObject = kTRUE;
2101 }
2102 ids.back().fNestedIDs->fOnfileObject = onfileObject;
2103 GatherArtificialElements(branches, ids.back().fNestedIDs->fIDs, subprefix, nextinfo, offset + nextel->GetOffset());
2104 if (ids.back().fNestedIDs->fIDs.empty())
2105 ids.pop_back();
2106 }
2107 }
2108};
2109} // Anonymous namespace.
2110
2111
2112////////////////////////////////////////////////////////////////////////////////
2113/// Set the value of fInfo. This is part one of InitInfo.
2114/// To be used as:
2115/// if (!fInfo)
2116/// SetupInfo();
2117/// It would only be used within InitInfo (and its callees)
2118
2120{
2121 // We did not already have streamer info, so now we must find it.
2123
2124 //------------------------------------------------------------------------
2125 // Check if we're dealing with the name change
2126 //////////////////////////////////////////////////////////////////////////
2127
2128 TClass* targetClass = 0;
2129 if( fTargetClass.GetClassName()[0] ) {
2130 targetClass = fTargetClass;
2131 if (!targetClass && GetCollectionProxy()) {
2132 // We are in the case where the branch holds a custom collection
2133 // proxy but the dictionary is not loaded, calling
2134 // GetCollectionProxy had the side effect of creating the TClass
2135 // corresponding to this emulated collection.
2136 targetClass = fTargetClass;
2137 }
2138 if ( !targetClass ) {
2139 Error( "InitInfo", "The target class dictionary is not present!" );
2140 return;
2141 }
2142 } else {
2143 targetClass = cl;
2144 }
2145 if (cl) {
2146 //---------------------------------------------------------------------
2147 // Get the streamer info for given version
2148 ///////////////////////////////////////////////////////////////////////
2149
2150 {
2151 if ( (cl->Property() & kIsAbstract) && cl == targetClass) {
2153 if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
2154 // Our parent's class is emulated and we represent an abstract class.
2155 // and the target class has not been set explicitly.
2156 TString target = cl->GetName();
2157 target += "@@emulated";
2158 fTargetClass.SetName(target);
2159
2160 if (!fTargetClass) {
2162 }
2163 targetClass = fTargetClass;
2164 }
2165 }
2166 if( targetClass != cl ) {
2168 } else {
2170 }
2171 }
2172
2173 // FIXME: Check that the found streamer info checksum matches our branch class checksum here.
2174 // Check to see if the class code was unloaded/reloaded
2175 // since we were created.
2177 if (fCheckSum && (cl->IsForeign() || (!cl->IsLoaded() && (fClassVersion == 1) && cl->GetStreamerInfos()->At(1) && (fCheckSum != ((TVirtualStreamerInfo*) cl->GetStreamerInfos()->At(1))->GetCheckSum())))) {
2178 // Try to compensate for a class that got unloaded on us.
2179 // Search through the streamer infos by checksum
2180 // and take the first match.
2181
2182 TStreamerInfo* info;
2183 if( targetClass != cl )
2184 info = (TStreamerInfo*)targetClass->FindConversionStreamerInfo( cl, fCheckSum );
2185 else {
2187 if (info) {
2188 // Now that we found it, we need to make sure it is initialize (Find does not initialize the StreamerInfo).
2189 info = (TStreamerInfo*)cl->GetStreamerInfo(info->GetClassVersion());
2190 }
2191 }
2192 if( info ) {
2193 fInfo = info;
2194 // We no longer reset the class version so that in case the user is passing us later
2195 // the address of a class that require (another) Conversion we can find the proper
2196 // StreamerInfo.
2197 // fClassVersion = fInfo->GetClassVersion();
2198 }
2199 }
2200 }
2201}
2202
2203
2204////////////////////////////////////////////////////////////////////////////////
2205/// Init the streamer info for the branch class, try to compensate for class
2206/// code unload/reload and schema evolution.
2207
2209{
2210 if (!fInfo)
2211 SetupInfo();
2212
2213 //
2214 // Fixup cached streamer info if necessary.
2215 //
2216 // FIXME: What if the class code was unloaded/reloaded since we were cached?
2217
2218 if (fInfo) {
2219
2220 if (!fInfo->IsCompiled()) {
2221 // Streamer info has not yet been compiled.
2222
2223 Error("InitInfo","StreamerInfo is not compiled.");
2224 }
2225 // return immediately if we are called recursively.
2226 if (fInInitInfo)
2227 return;
2229 if (!fInit) {
2230 // We were read in from a file, figure out what our fID should be,
2231 // schema evolution must be considered.
2232 //
2233 // Force our fID to be the id of the first streamer element that matches our name.
2234 //
2235 auto SetOnfileObject = [this](TStreamerInfo *info) {
2236 Int_t arrlen = 1;
2237 if (fType==31 || fType==41) {
2238 TLeaf *leaf = (TLeaf*)fLeaves.At(0);
2239 if (leaf) {
2240 arrlen = leaf->GetMaximum();
2241 }
2242 }
2243 Bool_t toplevel = (fType == 3 || fType == 4 || (fType == 0 && fID == -2));
2244 Bool_t seenExisting = kFALSE;
2245
2246 fOnfileObject = new TVirtualArray( info->GetElement(0)->GetClassPointer(), arrlen );
2247 // Propagate this to all the other branches belonging to the same object.
2248 TObjArray *branches = toplevel ? GetListOfBranches() : GetMother()->GetSubBranch(this)->GetListOfBranches();
2249 Int_t nbranches = branches->GetEntriesFast();
2250 TBranchElement *lastbranch = this;
2251
2252 TClass *currentClass = fBranchClass;
2253 auto currentVersion = fClassVersion;
2254 if (toplevel) {
2255 // Note: Fragile/wrong when using conversion StreamerInfo?
2256 currentClass = info->GetClass();
2257 currentVersion = info->GetClassVersion();
2258 }
2259
2260 // First find the first branch corresponding to the same class as 'this'
2261 // branch
2262 Int_t index = branches->IndexOf(this);
2263 Int_t firstindex = 0;
2264 Int_t lastindex = nbranches - 1;
2265 if (index >= 0) {
2266 TString fullname( GetFullName() );
2267 Ssiz_t lastdot = fullname.Last('.');
2268 if (lastdot == TString::kNPOS) {
2269 // No prefix or index, thus this is a first level branch
2270 TBranchElement* subbranch = (TBranchElement*)branches->At(0);
2271 if (!subbranch->fInfo)
2272 subbranch->SetupInfo();
2273 } else {
2274 TString &thisprefix = fullname.Remove(lastdot + 1); // Mod fullname and 'rename' the variable.
2275 for(Int_t i = index - 1; i >= 0; --i) {
2276 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2277 TString subbranch_name(subbranch->GetFullName());
2278 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2279 // We moved to another data member (of the enclosing class)
2280 firstindex = i + 1;
2281 break;
2282 }
2283 if (!subbranch->fInfo)
2284 subbranch->SetupInfo();
2285 }
2286 for(Int_t i = index; i < nbranches; ++i) {
2287 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2288 TString subbranch_name(subbranch->GetFullName());
2289 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2290 lastindex = i - 1;
2291 break;
2292 }
2293 }
2294 }
2295 } else {
2296 // Case of a top level branch or 'empty node' (object marker for split sub-object)
2297 TString fullname( GetFullName() );
2298 Ssiz_t lastdot = fullname.Last('.');
2299 if (lastdot != TString::kNPOS) {
2300 TString &thisprefix = fullname.Remove(lastdot + 1); // Mod fullname and 'rename' the variable.
2301 for(Int_t i = 0; i < nbranches; ++i) {
2302 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2303 TString subbranch_name(subbranch->GetFullName());
2304 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2305 lastindex = i - 1;
2306 break;
2307 }
2308 }
2309 }
2310 }
2311 for (Int_t i = firstindex; i <= lastindex; ++i) {
2312 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2313 Bool_t match = kFALSE;
2314 if (this != subbranch) {
2315
2316 if (!subbranch->fInfo)
2317 subbranch->SetupInfo();
2318
2319 if (subbranch->fInfo == info)
2320 match = kTRUE;
2321 else if (subbranch->fInfo == nullptr && subbranch->fBranchClass == currentClass) {
2322 if (!toplevel) {
2323 if (subbranch->fCheckSum == fCheckSum)
2324 match = kTRUE;
2325 } else {
2326 if (!subbranch->fBranchClass->IsForeign() && subbranch->fClassVersion == currentVersion)
2327 match = kTRUE;
2328 else if (subbranch->fCheckSum == info->GetCheckSum()) {
2329 match = kTRUE;
2330 }
2331 }
2332 }
2333 }
2334 if (match) {
2335 if (subbranch->fOnfileObject && subbranch->fOnfileObject != fOnfileObject) {
2336 if (seenExisting) {
2337 Error("SetOnfileObject (lambda)", "2 distincts fOnfileObject are in the hierarchy of %s for type %s",
2338 toplevel ? GetName() : GetMother()->GetSubBranch(this)->GetName(), info->GetName());
2339 } else {
2340 delete fOnfileObject;
2341 fOnfileObject = subbranch->fOnfileObject;
2342 seenExisting = kTRUE;
2343 }
2344 }
2345 subbranch->fOnfileObject = fOnfileObject;
2346 lastbranch = subbranch;
2347 }
2348 }
2349 if (toplevel) {
2351 if (lastbranch != this)
2352 lastbranch->ResetBit(kOwnOnfileObj);
2353 } else {
2354 lastbranch->SetBit(kOwnOnfileObj);
2355 }
2356 };
2357 if (GetID() > -1) {
2358 // We are *not* a top-level branch.
2359 std::string s(GetName());
2360 size_t pos = s.rfind('.');
2361 if (pos != std::string::npos) {
2362 s = s.substr(pos+1);
2363 }
2364 while ((pos = s.rfind('[')) != std::string::npos) {
2365 s = s.substr(0, pos);
2366 }
2367 int offset = 0;
2368 TStreamerElement* elt = fInfo->GetStreamerElement(s.c_str(), offset);
2369 if (elt && offset!=TStreamerInfo::kMissing) {
2370 size_t ndata = fInfo->GetNelement();
2371 fNewIDs.clear();
2372 for (size_t i = 0; i < ndata; ++i) {
2373 if (fInfo->GetElement(i) == elt) {
2375 && (i+1) < ndata
2376 && s == fInfo->GetElement(i)->GetName())
2377 {
2378 // If the TStreamerElement we found is storing the information in the
2379 // cache and is a repeater, we need to use the real one (the next one).
2380 // (At least until the cache/repeat mechanism is properly handle by
2381 // ReadLeaves).
2382 // fID = i+1;
2383 fID = i;
2384 if (fType != 2) {
2386 fNewIDs.push_back(fID+1);
2387 fNewIDs.back().fElement = fInfo->GetElement(i+1);
2388 fNewIDs.back().fInfo = fInfo;
2389 } else if (fInfo->GetElement(i+1)->TestBit(TStreamerElement::kWrite)) {
2390 fNewIDs.push_back(fID+1);
2391 fNewIDs.back().fElement = fInfo->GetElement(i+1);
2392 fNewIDs.back().fInfo = fInfo;
2393 }
2394 }
2395 } else {
2396 fID = i;
2397 }
2398 if (elt->TestBit (TStreamerElement::kCache)) {
2400 }
2401 break;
2402 }
2403 }
2404 for (size_t i = fID+1+(fNewIDs.size()); i < ndata; ++i) {
2405 TStreamerElement *nextel = fInfo->GetElement(i);
2406
2407 std::string ename = nextel->GetName();
2408 if (ename[0] == '*')
2409 ename = ename.substr(1);
2410
2411 while ((pos = ename.rfind('[')) != std::string::npos) {
2412 ename = ename.substr(0, pos);
2413 }
2414
2415 if (s != ename) {
2416 // We moved on to the next set
2417 break;
2418 }
2419 // Add all (and only) the Artificial Elements that follows this StreamerInfo.
2420 // fprintf(stderr,"%s/%d[%zu] passing through %zu %s\n",GetName(),fID,fIDs.size(),i,nextel->GetName());
2421 if (fType==31||fType==41) {
2422 // The nested objects are unfolded and their branch can not be used to
2423 // execute StreamerElements of this StreamerInfo.
2424 if ((nextel->GetType() == TStreamerInfo::kObject
2425 || nextel->GetType() == TStreamerInfo::kAny)
2426 && nextel->GetClassPointer()->CanSplit())
2427 {
2428 continue;
2429 }
2430 }
2431 if (nextel->GetOffset() == TStreamerInfo::kMissing) {
2432 // This element will be 'skipped', it's TBranchElement's fObject will null
2433 // and thus can not be used to execute the artificial StreamerElements
2434 continue;
2435 }
2436 if (nextel->IsA() != TStreamerArtificial::Class()
2437 || nextel->GetType() == TStreamerInfo::kCacheDelete ) {
2438 continue;
2439 }
2440 // NOTE: We should verify that the rule's source are 'before'
2441 // or 'at' this branch.
2442 // fprintf(stderr,"%s/%d[%zu] pushd %zu %s\n",GetName(),fID,fIDs.size(),i,nextel->GetName());
2443 fNewIDs.push_back(i);
2444 fNewIDs.back().fElement = nextel;
2445 fNewIDs.back().fInfo = fInfo;
2446 }
2447 } else if (elt && offset==TStreamerInfo::kMissing) {
2448 // Still re-assign fID properly.
2449 fNewIDs.clear();
2450 size_t ndata = fInfo->GetNelement();
2451 for (size_t i = 0; i < ndata; ++i) {
2452 if (fInfo->GetElement(i) == elt) {
2453 fID = i;
2454 break;
2455 }
2456 }
2457 } else {
2458 // We have not even found the element .. this is strange :(
2459 // fNewIDs.clear();
2460 // fID = -3;
2461 // SetBit(kDoNotProcess);
2462 }
2463 if (fOnfileObject==0 && (fType==31 || fType==41 || (0 <= fType && fType <=2) ) && fInfo->GetNelement()
2465 {
2466 SetOnfileObject(fInfo);
2467 }
2468 }
2469 if (fType == 3 || fType == 4 || (fType == 0 && fID == -2) || fType == 2) {
2470 // Need to add the rule targeting transient members.
2471 TStreamerInfo *localInfo = fInfo;
2472 if (fType == 3 || fType == 4) {
2473 // Don't we have real version information?
2474 // Not unless there is a subbranch with a non-split element of the class.
2475 // Search for the correct version.
2477 }
2478
2479 TString prefix(GetFullName());
2480 if (fType == 2 && fID >= 0) {
2481 auto start = prefix.Length();
2482 if (prefix[start - 1] == '.')
2483 --start;
2484 std::string_view view(prefix.Data(), start);
2485 auto cutoff = view.find_last_of('.');
2486 if (cutoff != std::string::npos) {
2487 prefix.Remove(cutoff + 1);
2488 }
2489 }
2490 if (prefix[prefix.Length()-1] != '.') {
2491 if (fType == 3 || fType == 4 || prefix.Index('.') != TString::kNPOS) {
2492 prefix += ".";
2493 } else {
2494 prefix = "";
2495 }
2496 }
2497 fNewIDs.clear();
2498
2499 GatherArtificialElements(fBranches, fNewIDs, prefix, localInfo, 0);
2500
2501 if (!fNewIDs.empty() && fOnfileObject == nullptr && localInfo->GetElement(0)->GetType() == TStreamerInfo::kCacheNew)
2502 {
2503 SetOnfileObject(localInfo);
2504 }
2505
2506 }
2507 fInit = kTRUE;
2508
2509 // Get the action sequence we need to copy for reading.
2512 } else if (!fReadActionSequence) {
2513 // Get the action sequence we need to copy for reading.
2516 }
2520 }
2521}
2522
2523////////////////////////////////////////////////////////////////////////////////
2524/// Return the collection proxy describing the branch content, if any.
2525
2527{
2528 if (fCollProxy) {
2529 return fCollProxy;
2530 }
2531 TBranchElement* thiscast = const_cast<TBranchElement*>(this);
2532 if (fType == 4) {
2533 // STL container top-level branch.
2534 const char* className = 0;
2535 TClass* cl = nullptr;
2536 if (fID < 0) {
2537 // We are a top-level branch.
2538 if (fBranchClass.GetClass()) {
2539 cl = fBranchClass.GetClass();
2540 }
2541 } else {
2542 // We are not a top-level branch.
2543 TVirtualStreamerInfo* si = thiscast->GetInfoImp();
2544 if (fCollProxy) {
2545 // The GetInfo set fProxy for us, let's not
2546 // redo it; the value of fCollProxy is possibly
2547 // used/recorded is the actions sequences, so
2548 // if we change it here, we would need to propagate
2549 // the change.
2550 return fCollProxy;
2551 }
2552 TStreamerElement* se = si->GetElement(fID);
2553 cl = se->GetClassPointer();
2554 }
2555 if (!cl) {
2556 // The TClass was not created but we do know (since it
2557 // is used as a collection) that it 'className' was a
2558 // class, so let's create it by hand!.
2559
2560 if (fID < 0) {
2563 className = cl->GetName();
2564 } else {
2565 cl = new TClass(className, fClassVersion);
2567 className = cl->GetName();
2568 }
2569 }
2571 if (!proxy) {
2572 // humm, we must have an older file with a custom collection
2573 // let's try to work-around it.
2574 TString equiv;
2575 equiv.Form("vector<%s>",fClonesName.Data());
2576 TClass *clequiv = TClass::GetClass(equiv);
2577 proxy = clequiv->GetCollectionProxy();
2578 if (!proxy) {
2579 Fatal("GetCollectionProxy",
2580 "Can not create a Collection Proxy of any kind for the class \"%s\" needed by the branch \"%s\" of the TTree \"%s\"!",
2581 className, GetName(), GetTree()->GetName());
2582 }
2583 if (gDebug > 0) Info("GetCollectionProxy",
2584 "Fixing the collection proxy of the class \"%s\" \n"
2585 "\tneeded by the branch \"%s\" of the TTree \"%s\" to be similar to \"%s\".",
2586 className, GetName(), GetTree()->GetName(),equiv.Data());
2587 cl->CopyCollectionProxy( *proxy );
2588 }
2589 fCollProxy = proxy->Generate();
2590 fSTLtype = proxy->GetCollectionType();
2591 } else if (fType == 41) {
2592 // STL container sub-branch.
2594 }
2595 return fCollProxy;
2596}
2597
2598////////////////////////////////////////////////////////////////////////////////
2599/// Return a pointer to the current type of the data member corresponding to branch element.
2600
2602{
2603 TClass* cl = fCurrentClass;
2604 if (cl) {
2605 return cl;
2606 }
2607
2609 if (!brInfo) {
2611 R__ASSERT(cl && cl->GetCollectionProxy());
2612 fCurrentClass = cl;
2613 return cl;
2614 }
2615 TClass* motherCl = brInfo->GetClass();
2616 if (motherCl->GetCollectionProxy()) {
2617 cl = motherCl->GetCollectionProxy()->GetCollectionClass();
2618 if (cl) {
2619 fCurrentClass = cl;
2620 }
2621 return cl;
2622 }
2623 if (GetID() < 0 || GetID()>=brInfo->GetNelement()) {
2624 return 0;
2625 }
2626 TStreamerElement* currentStreamerElement = brInfo->GetElement(GetID());
2627 TDataMember* dm = (TDataMember*) motherCl->GetListOfDataMembers()->FindObject(currentStreamerElement->GetName());
2628
2629 TString newType;
2630 if (!dm) {
2631 // Either the class is not loaded or the data member is gone
2632 if (!motherCl->IsLoaded()) {
2633 TVirtualStreamerInfo* newInfo = motherCl->GetStreamerInfo();
2634 if (newInfo != brInfo) {
2635 TStreamerElement* newElems = (TStreamerElement*) newInfo->GetElements()->FindObject(currentStreamerElement->GetName());
2636 if (newElems) {
2637 if (newElems->GetClassPointer())
2638 newType = newElems->GetClassPointer()->GetName();
2639 else
2640 newType = newElems->GetTypeName();
2641 }
2642 }
2643 if (newType.Length()==0) {
2644 if (currentStreamerElement->GetClassPointer())
2645 newType = currentStreamerElement->GetClassPointer()->GetName();
2646 else
2647 newType = currentStreamerElement->GetTypeName();
2648 }
2649 }
2650 } else {
2651 newType = dm->GetTypeName();
2652 }
2653 cl = TClass::GetClass(newType);
2654 if (cl) {
2655 fCurrentClass = cl;
2656 }
2657 return cl;
2658}
2659
2660////////////////////////////////////////////////////////////////////////////////
2661/// Read all branches of a BranchElement and return total number of bytes.
2662///
2663/// - If entry = 0, then use current entry number + 1.
2664/// - If entry < 0, then reset entry number to 0.
2665///
2666/// Returns the number of bytes read from the input buffer.
2667/// - If entry does not exist, then returns 0.
2668/// - If an I/O error occurs, then returns -1.
2669///
2670/// See IMPORTANT REMARKS in TTree::GetEntry.
2671
2673{
2674 // Remember which entry we are reading.
2675 fReadEntry = entry;
2676
2677 // If our tree has a branch ref, make it remember the entry and
2678 // this branch. This allows a TRef::GetObject() call done during
2679 // the following I/O operation, for example in a custom streamer,
2680 // to search for the referenced object in the proper element of the
2681 // proper branch.
2682 TBranchRef* bref = fTree->GetBranchRef();
2683 if (R__unlikely(bref)) {
2684 R__LOCKGUARD_IMT(gROOTMutex); // Lock for parallel TTree I/O
2685 fBranchID = bref->SetParent(this, fBranchID);
2686 bref->SetRequestedEntry(entry);
2687 }
2688
2689 Int_t nbytes = 0;
2690
2691 if (R__unlikely(IsAutoDelete())) {
2694 } else {
2696 R__LOCKGUARD_IMT(gROOTMutex); // Lock for parallel TTree I/O
2698 }
2699 }
2700
2701 Int_t nbranches = fBranches.GetEntriesFast();
2702 if (nbranches) {
2703 // -- Branch has daughters.
2704 // One must always read the branch counter.
2705 // In the case when one reads consecutively twice the same entry,
2706 // the user may have cleared the TClonesArray between the GetEntry calls.
2707 if ((fType == 3) || (fType == 4)) {
2708 Int_t nb = TBranch::GetEntry(entry, getall);
2709 if (nb < 0) {
2710 return nb;
2711 }
2712 nbytes += nb;
2713 }
2714 switch(fSTLtype) {
2715 case ROOT::kSTLset:
2716 case ROOT::kSTLmultiset:
2719 case ROOT::kSTLmap:
2720 case ROOT::kSTLmultimap:
2723 break;
2724 default:
2725 ValidateAddress(); // There is no ReadLeave for this node, so we need to do the validation here.
2726 for (Int_t i = 0; i < nbranches; ++i) {
2727 TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
2728 Int_t nb = branch->GetEntry(entry, getall);
2729 if (nb < 0) {
2730 return nb;
2731 }
2732 nbytes += nb;
2733 }
2734 break;
2735 }
2737 if (fType == 3) {
2738 // Apply the unattached rules; by definition they do not need any
2739 // input from a buffer.
2741
2742 auto ndata = GetNdata();
2743
2744 TClonesArray* clones = (TClonesArray*) fObject;
2745 if (clones->IsZombie()) {
2746 return -1;
2747 }
2748 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,ndata);
2749
2750 char **arr = (char **)clones->GetObjectRef();
2751 char **end = arr + fNdata;
2752
2753 b.ApplySequenceVecPtr(*fReadActionSequence,arr,end);
2754 } else if (fType == 4) {
2755 // Apply the unattached rules; by definition they do not need any
2756 // input from a buffer.
2758
2759 auto ndata = GetNdata();
2760
2761 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,ndata);
2764
2766 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
2767 } else {
2768 // Apply the unattached rules; by definition they do not need any
2769 // input from a buffer.
2771 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
2772 b.ApplySequence(*fReadActionSequence, fObject);
2773 }
2774 }
2775 } else {
2776 // -- Terminal branch.
2777 if (fBranchCount && (fBranchCount->GetReadEntry() != entry)) {
2778 Int_t nb = fBranchCount->TBranch::GetEntry(entry, getall);
2779 if (nb < 0) {
2780 return nb;
2781 }
2782 nbytes += nb;
2783 }
2784 Int_t nb = TBranch::GetEntry(entry, getall);
2785 if (nb < 0) {
2786 return nb;
2787 }
2788 nbytes += nb;
2789 }
2790
2791 if (R__unlikely(fTree->Debug() > 0)) {
2792 if ((entry >= fTree->GetDebugMin()) && (entry <= fTree->GetDebugMax())) {
2793 Info("GetEntry", "%lld, branch=%s, nbytes=%d", entry, GetName(), nbytes);
2794 }
2795 }
2796 return nbytes;
2797}
2798
2799////////////////////////////////////////////////////////////////////////////////
2800/// Fill expectedClass and expectedType with information on the data type of the
2801/// object/values contained in this branch (and thus the type of pointers
2802/// expected to be passed to Set[Branch]Address
2803/// return 0 in case of success and > 0 in case of failure.
2804
2806{
2807 expectedClass = 0;
2808 expectedType = kOther_t;
2809
2811 if ((type == -1) || (fID == -1)) {
2812 expectedClass = fBranchClass;
2813 } else {
2814 // Case of an object data member. Here we allow for the
2815 // variable name to be omitted. Eg, for Event.root with split
2816 // level 1 or above Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
2818 if (element) {
2819 expectedClass = element->GetClassPointer();
2820 if (!expectedClass) {
2821 TDataType* data = gROOT->GetType(element->GetTypeNameBasic());
2822 if (!data) {
2823 Error("GetExpectedType", "Did not find the type number for %s", element->GetTypeNameBasic());
2824 return 1;
2825 } else {
2826 expectedType = (EDataType) data->GetType();
2827 }
2828 }
2829 } else {
2830 Error("GetExpectedType", "Did not find the type for %s",GetName());
2831 return 2;
2832 }
2833 }
2834 return 0;
2835}
2836
2837////////////////////////////////////////////////////////////////////////////////
2838/// Return the 'full' name of the branch. In particular prefix the mother's name
2839/// when it does not end in a trailing dot and thus is not part of the branch name
2841{
2842 TBranchElement* mother = static_cast<TBranchElement*>(GetMother());
2843 if (!mother || mother==this || mother->GetType() == 3 || mother->GetType() == 4) {
2844 // The parent's name is already included in the name for split TClonesArray and STL collections
2845 return fName;
2846 }
2847 TString motherName(mother->GetName());
2848 if (motherName.Length() && (motherName[motherName.Length()-1] == '.')) {
2849 return fName;
2850 }
2851 return motherName + "." + fName;
2852}
2853
2854////////////////////////////////////////////////////////////////////////////////
2855/// Return icon name depending on type of branch element.
2856
2858{
2859 if (IsFolder()) {
2860 return "TBranchElement-folder";
2861 } else {
2862 return "TBranchElement-leaf";
2863 }
2864}
2865
2866////////////////////////////////////////////////////////////////////////////////
2867/// Return whether this branch is in a mode where the object are decomposed
2868/// or not (Also known as MakeClass mode).
2869
2871{
2872 return TestBit(kDecomposedObj); // Same as TestBit(kMakeClass)
2873}
2874
2875////////////////////////////////////////////////////////////////////////////////
2876/// Return maximum count value of the branchcount if any.
2877
2879{
2880 if (fBranchCount) {
2881 return fBranchCount->GetMaximum();
2882 }
2883 return fMaximum;
2884}
2885
2886////////////////////////////////////////////////////////////////////////////////
2887/// Return a pointer to our object.
2888
2890{
2892 return fObject;
2893}
2894
2895////////////////////////////////////////////////////////////////////////////////
2896/// Return a pointer to the parent class of the branch element.
2897
2899{
2900 return fParentClass.GetClass();
2901}
2902
2903////////////////////////////////////////////////////////////////////////////////
2904/// Return type name of element in the branch.
2905
2907{
2908 if (fType == 3 || fType == 4) {
2909 return "Int_t";
2910 }
2911 // FIXME: Use symbolic constants here.
2912 if ((fStreamerType < 1) || (fStreamerType > 59)) {
2913 if (fBranchClass.GetClass()) {
2914 if (fID>=0) {
2915 return GetInfoImp()->GetElement(fID)->GetTypeName();
2916 } else {
2917 return fBranchClass.GetClass()->GetName();
2918 }
2919 } else {
2920 return 0;
2921 }
2922 }
2923 const char *types[20] = {
2924 "",
2925 "Char_t",
2926 "Short_t",
2927 "Int_t",
2928 "Long_t",
2929 "Float_t",
2930 "Int_t",
2931 "char*",
2932 "Double_t",
2933 "Double32_t",
2934 "",
2935 "UChar_t",
2936 "UShort_t",
2937 "UInt_t",
2938 "ULong_t",
2939 "UInt_t",
2940 "Long64_t",
2941 "ULong64_t",
2942 "Bool_t",
2943 "Float16_t"
2944 };
2945 Int_t itype = fStreamerType % 20;
2946 return types[itype];
2947}
2948
2949////////////////////////////////////////////////////////////////////////////////
2950
2951template Double_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;
2952template Long64_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;
2953template LongDouble_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;
2954
2955template <typename T>
2957{
2958 // -- Returns the branch value.
2959 //
2960 // If the leaf is an array, j is the index in the array.
2961 //
2962 // If leaf is an array inside a TClonesArray, len should be the length
2963 // of the array.
2964 //
2965 // If subarr is true, then len is actually the index within the sub-array.
2966 //
2967
2969
2970 Int_t prID = fID;
2971 char *object = fObject;
2972 if (TestBit(kCache)) {
2973 if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
2974 prID = fID+1;
2975 } else if (fOnfileObject) {
2976 object = fOnfileObject->GetObjectAt(0);
2977 }
2978 }
2979
2980 if (!j && fBranchCount) {
2981 Long64_t entry = fTree->GetReadEntry();
2982 // Since reloading the index, will reset the ClonesArray, let's
2983 // skip the load if we already read this entry.
2984 if (entry != fBranchCount->GetReadEntry()) {
2985 fBranchCount->TBranch::GetEntry(entry);
2986 }
2987 if (fBranchCount2 && entry != fBranchCount2->GetReadEntry()) {
2988 fBranchCount2->TBranch::GetEntry(entry);
2989 }
2990 }
2991
2992 if (TestBit(kDecomposedObj)) {
2993 if (!fAddress) {
2994 return 0;
2995 }
2996 if ((fType == 3) || (fType == 4)) {
2997 // Top-level branch of a TClonesArray.
2998 return fNdata;
2999 } else if ((fType == 31) || (fType == 41)) {
3000 // sub branch of a TClonesArray
3001 Int_t atype = fStreamerType;
3002 if (atype < 20) {
3003 atype += 20;
3004 }
3005 return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
3006 } else if (fType <= 2) {
3007 // branch in split mode
3008 // FIXME: This should probably be < 60 instead!
3009 if ((fStreamerType > 40) && (fStreamerType < 55)) {
3010 Int_t atype = fStreamerType - 20;
3011 return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
3012 } else {
3013 return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
3014 }
3015 }
3016 }
3017
3018 if (object == 0)
3019 {
3020 // We have nowhere to read the data from (probably because the data member was
3021 // 'dropped' from the current schema).
3022 return 0;
3023 }
3024
3025 if (fType == 31) {
3026 TClonesArray* clones = (TClonesArray*) object;
3027 if (subarr) {
3028 return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j, len, fOffset);
3029 }
3030 return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j/len, j%len, fOffset);
3031 } else if (fType == 41) {
3034 {
3035 if (subarr)
3036 return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);
3037
3038 return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
3039 }
3040 else
3041 {
3042 if (subarr)
3043 return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);
3044 return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
3045 }
3046 } else {
3047 if (GetInfoImp()) {
3048 return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
3049 }
3050 return 0;
3051 }
3052}
3053
3054////////////////////////////////////////////////////////////////////////////////
3055/// Returns pointer to first data element of this branch.
3056/// Currently used only for members of type character.
3057
3059{
3061
3062 Int_t prID = fID;
3063 char *object = fObject;
3064 if (TestBit(kCache)) {
3065 if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
3066 prID = fID+1;
3067 } else if (fOnfileObject) {
3068 object = fOnfileObject->GetObjectAt(0);
3069 }
3070 }
3071
3072 if (fBranchCount) {
3073 Long64_t entry = fTree->GetReadEntry();
3074 fBranchCount->TBranch::GetEntry(entry);
3075 if (fBranchCount2) fBranchCount2->TBranch::GetEntry(entry);
3076 }
3077 if (TestBit(kDecomposedObj)) {
3078 if (!fAddress) {
3079 return 0;
3080 }
3081 if (fType == 3) { //top level branch of a TClonesArray
3082 //return &fNdata;
3083 return 0;
3084 } else if (fType == 4) { //top level branch of a TClonesArray
3085 //return &fNdata;
3086 return 0;
3087 } else if (fType == 31) { // sub branch of a TClonesArray
3088 //Int_t atype = fStreamerType;
3089 //if (atype < 20) atype += 20;
3090 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3091 return 0;
3092 } else if (fType == 41) { // sub branch of a TClonesArray
3093 //Int_t atype = fStreamerType;
3094 //if (atype < 20) atype += 20;
3095 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3096 return 0;
3097 } else if (fType <= 2) { // branch in split mode
3098 // FIXME: This should probably be < 60 instead!
3099 if (fStreamerType > 40 && fStreamerType < 55) {
3100 //Int_t atype = fStreamerType - 20;
3101 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3102 return 0;
3103 } else {
3104 //return GetInfoImp()->GetValue(object, fID, j, -1);
3105 return 0;
3106 }
3107 }
3108 }
3109
3110 if (fType == 31) {
3111 return 0;
3112 } else if (fType == 41) {
3113 return 0;
3114 } else if (prID < 0) {
3115 return object;
3116 } else {
3117 //return GetInfoImp()->GetValue(object,fID,j,-1);
3118 if (!GetInfoImp() || !object) return 0;
3119 char **val = (char**)(object+GetInfoImp()->TStreamerInfo::GetElementOffset(prID));
3120 return *val;
3121 }
3122}
3123
3124////////////////////////////////////////////////////////////////////////////////
3125/// Initialize the base class subobjects offsets of our sub-branches and set fOffset if we are a container sub-branch.
3126///
3127/// Note: The offsets are zero for data members so that when
3128/// SetAddress recursively sets their address, they will get the
3129/// same address as their containing class because i/o is based
3130/// on streamer info offsets from the address of the containing
3131/// class.
3132///
3133/// Offsets are non-zero for base-class sub-branches that are
3134/// not the leftmost direct base class. They are laid out in
3135/// memory sequentially and only the leftmost direct base class
3136/// has the same address as the derived class. The streamer
3137/// offsets need to be added to the address of the base class
3138/// subobject which is not the same as the address of the
3139/// derived class for the non-leftmost direct base classes.
3140
3142{
3143 Int_t nbranches = fBranches.GetEntriesFast();
3144
3145 // See https://sft.its.cern.ch/jira/browse/ROOT-8742
3146 // and https://sft.its.cern.ch/jira/browse/ROOT-9253
3147 // As of commit e21b4f1a3b, removing this lock lead to a failure
3148 // in the test testSetAddress[Loop].
3149 // As of commit 4f8b237849, removing this lock does not lead to
3150 // a visible failure in test. This might be due to the underlying
3151 // problem (missing lock or ?) being solved somewhere else or some
3152 // other perturbation reducing the failure rate.
3153 // Having the lock here is not too costly as InitializeOffsets is
3154 // one called once in the lifetime of the TBranch.
3156
3157 if (fID < 0) {
3158 // -- We are a top-level branch. Let's mark whether we need to use MapObject.
3159 if (CanSelfReference(fBranchClass)) {
3160 if (fBranchClass.GetClass()->IsTObject()) {
3162 } else {
3164 }
3165 }
3166 }
3167 if (nbranches) {
3168 // Allocate space for the new sub-branch offsets.
3169 delete[] fBranchOffset;
3170 fBranchOffset = 0;
3171 fBranchOffset = new Int_t[nbranches];
3172 // Make sure we can instantiate our class meta info.
3173 if (!fBranchClass.GetClass()) {
3174 Warning("InitializeOffsets", "No branch class set for branch: %s", GetName());
3176 return;
3177 }
3178 // Make sure we can instantiate our class streamer info.
3179 if (!GetInfoImp()) {
3180 Warning("InitializeOffsets", "No streamer info available for branch: %s of class: %s", GetName(), fBranchClass.GetClass()->GetName());
3182 return;
3183 }
3184
3185 // Get the class we are a member of now (which is the
3186 // type of our containing subobject) and get our offset
3187 // inside of our containing subobject (our local offset).
3188 // Note: branchElem stays zero if we are a top-level branch,
3189 // we have to be careful about this later.
3190 TStreamerElement* branchElem = 0;
3191 Int_t localOffset = 0;
3192 TClass* branchClass = fBranchClass.GetClass();
3193 Bool_t renamed = kFALSE;
3194 if (fID > -1) {
3195 // -- Branch is *not* a top-level branch.
3196 // Instead of the streamer info class, we want the class of our
3197 // specific element in the streamer info. We could be a data
3198 // member of a base class or a split class, in which case our
3199 // streamer info will be for our containing sub-object, while
3200 // we are actually a different type.
3202 // Note: We tested to make sure the streamer info was available previously.
3203 if (!si->IsCompiled()) {
3204 Warning("InitializeOffsets", "Streamer info for branch: %s has no elements array!", GetName());
3206 return;
3207 }
3208 // FIXME: Check that fID is in range.
3209 branchElem = si->GetElement(fID);
3210 if (!branchElem) {
3211 Warning("InitializeOffsets", "Cannot get streamer element for branch: %s!", GetName());
3213 return;
3214 } else if (branchElem->TestBit(TStreamerElement::kRepeat)) {
3215 // If we have a repeating streamerElement, use the next
3216 // one as it actually hold the 'real' data member('s offset)
3217 if (si->GetElement(fID+1)) {
3218 branchElem = si->GetElement(fID+1);
3219 }
3220 }
3221 localOffset = branchElem->GetOffset();
3222 branchClass = branchElem->GetClassPointer();
3223 if (localOffset == TStreamerInfo::kMissing) {
3224 fObject = 0;
3225 } else {
3226 renamed = branchClass && branchElem->GetNewClass() && (branchClass != branchElem->GetNewClass());
3227 }
3228 } else {
3229 renamed = fTargetClass != fBranchClass;
3230 }
3231 if (!branchClass) {
3232 Error("InitializeOffsets", "Could not find class for branch: %s", GetName());
3234 return;
3235 }
3236
3237 //------------------------------------------------------------------------
3238 // Extract the name of the STL branch in case it has been split.
3239 //////////////////////////////////////////////////////////////////////////
3240
3241 TString stlParentName;
3242 Bool_t stlParentNameUpdated = kFALSE;
3243 if( fType == 4 )
3244 {
3245 TBranch *br = GetMother()->GetSubBranch( this );
3246 stlParentName = br->GetName();
3247 stlParentName = stlParentName.Strip( TString::kTrailing, '.' );
3248
3249 // We may ourself contain the 'Mother' branch name.
3250 // To avoid code duplication, we delegate the removal
3251 // of the mother's name to the first sub-branch loop.
3252 }
3253
3254 // Loop over our sub-branches and compute their offsets.
3255 for (Int_t subBranchIdx = 0; subBranchIdx < nbranches; ++subBranchIdx) {
3256 bool alternateElement = false;
3257
3258 fBranchOffset[subBranchIdx] = 0;
3259 TBranchElement* subBranch = dynamic_cast<TBranchElement*> (fBranches[subBranchIdx]);
3260 if (subBranch == 0) {
3261 // -- Skip sub-branches that are not TBranchElements.
3262 continue;
3263 }
3264
3265 if (renamed) {
3266 if (subBranch->fBranchClass == branchClass) {
3267 if (branchElem) subBranch->SetTargetClass(branchElem->GetNewClass()->GetName());
3268 else subBranch->SetTargetClass(fTargetClass->GetName());
3269 }
3270 }
3271
3272 TVirtualStreamerInfo* sinfo = subBranch->GetInfoImp();
3273 if (!sinfo) {
3274 Warning("InitializeOffsets", "No streamer info for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3275 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3276 continue;
3277 }
3278 if (!sinfo->IsCompiled()) {
3279 Warning("InitializeOffsets", "No elements array for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3280 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3281 continue;
3282 }
3283 // FIXME: Make sure subBranch->fID is in range.
3284 TStreamerElement* subBranchElement = sinfo->GetElement(subBranch->fID);
3285 if (!subBranchElement) {
3286 Warning("InitializeOffsets", "No streamer element for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3287 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3288 continue;
3289 } else if (subBranchElement->TestBit(TStreamerElement::kRepeat)) {
3290 // If we have a repeating streamerElement, use the next
3291 // one as it actually hold the 'real' data member('s offset)
3292 if (sinfo->GetElement(subBranch->fID+1)) {
3293 subBranchElement = sinfo->GetElement(subBranch->fID+1);
3294 }
3295 } else if (subBranchElement->TestBit(TStreamerElement::kCache)) {
3296 // We have a cached item which is not a repeated but we might still
3297 // have some Actions triggered by a rule that affect real
3298 // data member(s).
3299 if (subBranch->fReadActionSequence && subBranch->fReadActionSequence->fActions.size() > 1) {
3300 typedef TStreamerInfoActions::ActionContainer_t::iterator iterator;
3301 iterator end = subBranch->fReadActionSequence->fActions.end();
3302 for(iterator iter = subBranch->fReadActionSequence->fActions.begin();
3303 iter != end; ++iter) {
3304 TStreamerInfoActions::TConfiguration *config = iter->fConfiguration;
3305 UInt_t id = config->fElemId;
3307 if (e && !e->TestBit(TStreamerElement::kCache)) {
3308 subBranchElement = e;
3309 alternateElement = true;
3310 break;
3311 }
3312 }
3313 }
3314 }
3315
3316 localOffset = subBranchElement->GetOffset();
3317 if (localOffset == TStreamerInfo::kMissing) {
3318 subBranch->fObject = 0;
3319 }
3320 {
3321 Int_t streamerType = subBranchElement->GetType();
3322 if (streamerType > TStreamerInfo::kObject
3323 && subBranch->GetListOfBranches()->GetEntriesFast()==0
3324 && CanSelfReference(subBranchElement->GetClass()))
3325 {
3326 subBranch->SetBit(kBranchAny);
3327 } else {
3328 subBranch->ResetBit(kBranchAny);
3329 }
3330 }
3331
3332 if (subBranchElement->GetNewType()<0) {
3333 subBranch->ResetBit(kBranchAny);
3334 subBranch->ResetBit(kBranchObject);
3335 }
3336
3337 // Note: This call is expensive, do it only once.
3338 TBranch* mother = GetMother();
3339 if (!mother) {
3340 Warning("InitializeOffsets", "Branch '%s' has no mother!", GetName());
3341 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3342 continue;
3343 }
3344 TString motherName(mother->GetName());
3345 Bool_t motherDot = kFALSE;
3346 if (motherName.Length() && strchr(motherName.Data(), '.')) {
3347 motherDot = kTRUE;
3348 }
3349 Bool_t motherDotAtEnd = kFALSE;
3350 if (motherName.Length() && (motherName[motherName.Length()-1] == '.')) {
3351 motherDotAtEnd = kTRUE;
3352 }
3353
3354 Bool_t isBaseSubBranch = kFALSE;
3355 if ((subBranch->fType == 1) || (subBranchElement && subBranchElement->IsBase())) {
3356 // -- Base class sub-branch (1).
3357 //
3358 // Note: Our type will not be 1, even though we are
3359 // a base class branch, if we are not split (see the
3360 // constructor), or if we are an STL container master
3361 // branch and a base class branch at the same time
3362 // or an std::string.
3363 isBaseSubBranch = kTRUE;
3364 }
3365
3366 Bool_t isContDataMember = kFALSE;
3367 if ((subBranch->fType == 31) || (subBranch->fType == 41)) {
3368 // -- Container data member sub-branch (31 or 41).
3369 isContDataMember = kTRUE;
3370 }
3371
3372 // I am either a data member sub-branch (0), or a base class
3373 // sub-branch (1), or TClonesArray master sub-branch (3),
3374 // or an STL container master sub-branch (4), or TClonesArray
3375 // data member sub-branch (31), or an STL container data member
3376 // sub-branch (41).
3377 //
3378 // My parent branch is either a top-level branch ((0), fID==(-2,-1)),
3379 // or a base class sub-branch (1), or a split-class branch (2),
3380 // or a TClonesArray master branch (3), or an STL container
3381 // master branch (4).
3382 //
3383
3384 //
3385 // We need to extract from our name the name
3386 // of the data member which contains us, so
3387 // that we may then do a by-name lookup in the
3388 // dictionary meta info of our parent class to
3389 // get our offset in our parent class.
3390 //
3391
3392 // Get our name.
3393 TString dataName(subBranch->GetName());
3394 if (motherDotAtEnd) {
3395 // -- Remove the top-level branch name from our name.
3396 dataName.Remove(0, motherName.Length());
3397 // stlParentNameUpdated is false the first time in this loop.
3398 if (!stlParentNameUpdated && stlParentName.Length()) {
3399 stlParentName.Remove(0, motherName.Length());
3400 stlParentNameUpdated = kTRUE;
3401 }
3402 } else if (motherDot) {
3403 // -- Remove the top-level branch name from our name, folder case.
3404 //
3405 // Note: We are in the case where our mother was created
3406 // by the branch constructor which takes a folder
3407 // as an argument. The mother branch has internal
3408 // dots in its name to represent the folder hierarchy.
3409 // The TTree::Bronch() routine has handled us as a
3410 // special case, we must compensate.
3411 if ((fID < 0) && (subBranchElement->IsA() == TStreamerBase::Class())) {
3412 // -- Our name is the mother name, remove it.
3413 // Note: The test is our parent is a top-level branch
3414 // and our streamer is the base class streamer,
3415 // this matches the exact test in TTree::Bronch().
3416 if (dataName.Length() == motherName.Length()) {
3417 dataName.Remove(0, motherName.Length());
3418 // stlParentNameUpdated is false the first time in this loop.
3419 if (!stlParentNameUpdated && stlParentName.Length()) {
3420 stlParentName.Remove(0, motherName.Length());
3421 }
3422 }
3423 } else {
3424 // -- Remove the mother name and the dot.
3425 if (dataName.Length() > motherName.Length()) {
3426 dataName.Remove(0, motherName.Length() + 1);
3427 if (!stlParentNameUpdated && stlParentName.Length()) {
3428 stlParentName.Remove(0, motherName.Length());
3429 }
3430 }
3431 }
3432 }
3433 stlParentNameUpdated = kTRUE;
3434 if (isBaseSubBranch) {
3435 // -- Remove the base class name suffix from our name.
3436 // Note: The pattern is the name of the base class.
3437 TString pattern(subBranchElement->GetName());
3438 if (pattern.Length() <= dataName.Length()) {
3439 if (!strcmp(dataName.Data() + (dataName.Length() - pattern.Length()), pattern.Data())) {
3440 // The branch name contains the name of the base class in it.
3441 // This name is not reproduced in the sub-branches, so we need to
3442 // remove it.
3443 dataName.Remove(dataName.Length() - pattern.Length());
3444 }
3445 }
3446 // Remove any leading dot.
3447 if (dataName.Length()) {
3448 if (dataName[0] == '.') {
3449 dataName.Remove(0, 1);
3450 }
3451 }
3452 // Note: We intentionally leave any trailing dot
3453 // in our modified name here.
3454 }
3455
3456 // Get our parent branch's name.
3457 TString parentName(GetName());
3458 if (motherDotAtEnd) {
3459 // -- Remove the top-level branch name from our parent's name.
3460 parentName.Remove(0, motherName.Length());
3461 } else if (motherDot) {
3462 // -- Remove the top-level branch name from our parent's name, folder case.
3463 //
3464 // Note: We are in the case where our mother was created
3465 // by the branch constructor which takes a folder
3466 // as an argument. The mother branch has internal
3467 // dots in its name to represent the folder hierarchy.
3468 // The TTree::Bronch() routine has handled us as a
3469 // special case, we must compensate.
3470 if ((fID > -1) && (mother == mother->GetSubBranch(this)) && (branchElem->IsA() == TStreamerBase::Class())) {
3471 // -- Our parent's name is the mother name, remove it.
3472 // Note: The test is our parent's parent is a top-level branch
3473 // and our parent's streamer is the base class streamer,
3474 // this matches the exact test in TTree::Bronch().
3475 if (parentName.Length() == motherName.Length()) {
3476 parentName.Remove(0, motherName.Length());
3477 }
3478 } else {
3479 // -- Remove the mother name and the dot.
3480 if (parentName.Length() > motherName.Length()) {
3481 parentName.Remove(0, motherName.Length() + 1);
3482 }
3483 }
3484 }
3485 // FIXME: Do we need to use the other tests for a base class here?
3486 if (fType == 1) {
3487 // -- Our parent is a base class sub-branch, remove the base class name suffix from its name.
3488 if (mother != mother->GetSubBranch(this)) {
3489 // -- My parent's parent is not a top-level branch.
3490 // Remove the base class name suffix from the parent name.
3491 // Note: The pattern is the name of the base class.
3492 // coverity[var_deref_model] branchElem is non zero here since fType==1 and thus fID > -1
3493 TString pattern(branchElem->GetName());
3494 if (pattern.Length() <= parentName.Length()) {
3495 if (!strcmp(parentName.Data() + (parentName.Length() - pattern.Length()), pattern.Data())) {
3496 // The branch name contains the name of the base class in it.
3497 // This name is not reproduced in the sub-branches, so we need to
3498 // remove it.
3499 parentName.Remove(parentName.Length() - pattern.Length());
3500 }
3501 }
3502 }
3503 // Note: We intentionally leave any trailing dots
3504 // in the modified parent name here.
3505 }
3506
3507 // Remove the parent branch name part from our name,
3508 // but only if the parent branch is not a top-level branch.
3509 // FIXME: We should not assume parent name does not have length 0.
3510 if (fID > -1) {
3511 RemovePrefix(dataName, parentName);
3512 }
3513
3514 // Remove any leading dot.
3515 if (dataName.Length()) {
3516 if (dataName[0] == '.') {
3517 dataName.Remove(0, 1);
3518 }
3519 }
3520
3521 // Remove any trailing dot.
3522 if (dataName.Length()) {
3523 if (dataName[dataName.Length()-1] == '.') {
3524 dataName.Remove(dataName.Length() - 1, 1);
3525 }
3526 }
3527
3528 //
3529 // Now that we have our data member name, find our offset
3530 // in our parent class.
3531 //
3532 // Note: Our data member name can have many dots in it
3533 // if branches were elided between our parent branch
3534 // and us by Unroll().
3535 //
3536 // FIXME: This may not work if our member name is ambiguous.
3537 //
3538
3539 Int_t offset = 0;
3540 if (dataName.Length()) {
3541 // -- We have our data member name, do a lookup in the dictionary meta info of our parent class.
3542 // Get our parent class.
3543 TClass* pClass = 0;
3544 // First check whether this sub-branch is part of the 'cache' (because the data member it
3545 // represents is no longer in the current class layout.
3546 TStreamerInfo *subInfo = subBranch->GetInfoImp();
3547 //if (subInfo && subBranch->TestBit(kCache)) { // subInfo->GetElements()->At(subBranch->GetID())->TestBit(TStreamerElement::kCache)) {
3548 if (subBranchElement->TestBit(TStreamerElement::kCache)) {
3549 pClass = ((TStreamerElement*)subInfo->GetElements()->At(0))->GetClassPointer();
3550 }
3551 // FIXME: Do we need the other base class tests here?
3552 if (!pClass) {
3553 if (fType == 1) {
3554 // -- Parent branch is a base class branch.
3555 // FIXME: Is using branchElem here the right thing?
3556 pClass = branchElem->GetClassPointer();
3557 if (pClass->Property() & kIsAbstract) {
3558 // the class is abstract, let see if the
3559
3561 if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
3562 // Our parent's class is emulated and we represent an abstract class.
3563 // and the target class has not been set explicitly.
3564 TString target = pClass->GetName();
3565 target += "@@emulated";
3566
3567 pClass = TClass::GetClass(target);
3568 }
3569 }
3570 } else {
3571 // -- Parent branch is *not* a base class branch.
3572 // FIXME: This sometimes returns a null pointer.
3573 pClass = subBranch->GetParentClass();
3574 }
3575 }
3576 if (!pClass) {
3577 // -- No parent class, fix it.
3578 // FIXME: This is probably wrong!
3579 // Assume parent class is our parent branch's clones class or value class.
3580 if (GetClonesName() && strlen(GetClonesName())) {
3581 pClass = fClonesClass;
3582 if (!pClass) {
3583 Warning("InitializeOffsets", "subBranch: '%s' has no parent class, and cannot get class for clones class: '%s'!", subBranch->GetName(), GetClonesName());
3584 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3585 continue;
3586 }
3587 Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
3588 }
3591 Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass ? pClass->GetName() : "unknown class");
3592 }
3593 if (!pClass) {
3594 // -- Still no parent class, assume our parent class is our parent branch's class.
3595 // FIXME: This is probably wrong!
3596 pClass = branchClass;
3597 // FIXME: Enable this warning!
3598 //Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
3599 }
3600 }
3601 if (renamed && pClass) {
3602 if (pClass == branchClass) {
3603 pClass = branchElem->GetNewClass();
3604 } else if (fCollProxy && pClass == branchClass->GetCollectionProxy()->GetValueClass()) {
3605 pClass = fCollProxy->GetValueClass();
3606 }
3607 }
3608
3609 //------------------------------------------------------------------
3610 // If we have the are the sub-branch of the TBranchSTL, we need
3611 // to remove it's name to get the correct real data offsets
3612 ////////////////////////////////////////////////////////////////////
3613
3614 const bool isToplevelCollection = (this == GetMother() && (fType == 3 || fType == 4));
3615 if( stlParentName.Length() && (dynamic_cast<TBranchSTL*>(fParent) || isToplevelCollection))
3616 {
3617 if( !strncmp( stlParentName.Data(), dataName.Data(), stlParentName.Length()-1 )
3618 && dataName[ stlParentName.Length() ] == '.' )
3619 dataName.Remove( 0, stlParentName.Length()+1 );
3620 }
3621
3622 // Find our offset in our parent class using
3623 // a lookup by name in the dictionary meta info
3624 // for our parent class.
3625
3626 if (alternateElement) {
3627 Ssiz_t dotpos = dataName.Last('.');
3628 Ssiz_t endpos = dataName.Length();
3629 if (dotpos != kNPOS) ++dotpos; else dotpos = 0;
3630 dataName.Replace(dotpos,endpos-dotpos,subBranchElement->GetFullName());
3631 }
3632 TRealData* rd = pClass->GetRealData(dataName);
3633 if (rd && (!rd->TestBit(TRealData::kTransient) || alternateElement)) {
3634 // -- Data member exists in the dictionary meta info, get the offset.
3635 // If we are using an alternateElement, it is the target of a rule
3636 // and might be indeed transient.
3637 offset = rd->GetThisOffset();
3638 } else if (subBranchElement->TestBit(TStreamerElement::kWholeObject)) {
3639 // We are a rule with no specific target, it applies to the whole
3640 // object, let's set the offset to zero
3641 offset = 0;
3642 } else {
3643 // -- No dictionary meta info for this data member, it must no
3644 // longer exist
3645 if (fEntries == 0) {
3646 // ... unless we creating the branch in which case
3647 // we have an internal error.
3648 if (pClass->GetListOfRealData()->GetEntries() == 0) {
3649 // We are probably missing the ShowMember, let's
3650 // just issue an error.
3651 Error("InitializeOffsets",
3652 "Could not find the real data member '%s' when constructing the branch '%s' [Likely missing ShowMember].",
3653 dataName.Data(),GetName());
3654 } else if (subInfo && subInfo->GetClassVersion()!=subInfo->GetClass()->GetClassVersion()) {
3655 // In the case where we are cloning a TTree that was created with an older version of the layout, we may not
3656 // able to find all the members
3657 Info("InitializeOffsets",
3658 "TTree created with an older schema, some data might not be copied in 'slow-cloning' mode; fast-cloning should have the correct result. '%s' is missing when constructing the branch '%s'. ",
3659 dataName.Data(),GetName());
3660 } else {
3661 // Something really bad happen.
3662 Fatal("InitializeOffsets",
3663 "Could not find the real data member '%s' when constructing the branch '%s' [Likely an internal error, please report to the developers].",
3664 dataName.Data(),GetName());
3665 }
3666 }
3667 localOffset = TStreamerInfo::kMissing;
3668 }
3669 } else {
3670 // -- We have no data member name, ok for a base class, not good otherwise.
3671 if (isBaseSubBranch) {
3672 // I am a direct base class of my parent class, my local offset is enough.
3673 } else {
3674 Warning("InitializeOffsets", "Could not find the data member name for branch '%s' with parent branch '%s', assuming offset is zero!", subBranch->GetName(), GetName());
3675 }
3676 }
3677
3678 //
3679 // Ok, do final calculations for fOffset and fBranchOffset.
3680 //
3681
3682 if (isContDataMember) {
3683 // -- Container data members set fOffset instead of fBranchOffset.
3684 // The fOffset is what should be added to the start of the entry
3685 // in the collection (i.e., its current absolute address) to find
3686 // the beginning of the data member described by the current branch.
3687 //
3688 // Compensate for the i/o routines adding our local offset later.
3689 if (subBranch->fObject == 0 && localOffset == TStreamerInfo::kMissing) {
3690 subBranch->SetMissing();
3691 // We stil need to set fBranchOffset in the case of a missing
3692 // element so that SetAddress is (as expected) not called
3693 // recursively in this case.
3694 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3695 } else {
3696 if (isBaseSubBranch) {
3697 // The value of 'offset' for a base class does not include its
3698 // 'localOffset'.
3699 subBranch->SetOffset(offset);
3700 } else {
3701 // The value of 'offset' for a regular data member does include its
3702 // 'localOffset', we need to remove it explicitly.
3703 subBranch->SetOffset(offset - localOffset);
3704 }
3705 }
3706 } else {
3707 // -- Set fBranchOffset for sub-branch.
3708 Int_t isSplit = 0 != subBranch->GetListOfBranches()->GetEntriesFast();
3709 if (subBranch->fObject == 0 && localOffset == TStreamerInfo::kMissing) {
3710 // The branch is missing
3711 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3712
3713 } else if (isSplit) {
3714 if (isBaseSubBranch) {
3715 // We are split, so we need to add in our local offset
3716 // to get our absolute address for our children.
3717 fBranchOffset[subBranchIdx] = offset + localOffset;
3718 } else {
3719 // We are split so our offset will never be
3720 // used in an i/o, so we do not have to subtract
3721 // off our local offset like below.
3722 fBranchOffset[subBranchIdx] = offset;
3723 }
3724 } else {
3725 if (isBaseSubBranch) {
3726 // We are not split, so our local offset will be
3727 // added later by the i/o routines.
3728 fBranchOffset[subBranchIdx] = offset;
3729 } else {
3730 // Compensate for the fact that the i/o routines
3731 // are going to add my local offset later.
3732 fBranchOffset[subBranchIdx] = offset - localOffset;
3733 }
3734 }
3735 }
3736 }
3737 }
3738 else {
3739 if (fID > -1) {
3740 // Branch is *not* a top-level branch.
3741 // Let's check if the target member is still present in memory
3743 fObject = 0;
3744 }
3745 }
3746 }
3747 const bool isSplitNode = (fType == 2 || fType == 1 || (fType == 0 && fID == -2)) && !fBranches.IsEmpty();
3748 if (fReadActionSequence && isSplitNode) {
3749 TBranchElement *parent = dynamic_cast<TBranchElement*>(GetMother()->GetSubBranch(this));
3750 auto index = parent->fBranches.IndexOf(this);
3751 if (index >= 0) {
3752 fReadActionSequence->AddToOffset( - parent->fBranchOffset[index] );
3753 }
3754 }
3755
3757}
3758
3759////////////////////////////////////////////////////////////////////////////////
3760/// Return kTRUE if more than one leaf, kFALSE otherwise.
3761
3763{
3764 Int_t nbranches = fBranches.GetEntriesFast();
3765 if (nbranches >= 1) {
3766 return kTRUE;
3767 }
3768 TList* browsables = const_cast<TBranchElement*>(this)->GetBrowsables();
3769 return browsables && browsables->GetSize();
3770}
3771
3772////////////////////////////////////////////////////////////////////////////////
3773/// Detect a collection written using a zero pointer in old versions of root.
3774/// In versions of ROOT older than 4.00/03, if a collection (TClonesArray
3775/// or STL container) was split but the pointer to the collection was zeroed
3776/// out, nothing was saved. Hence there is no __easy__ way to detect the
3777/// case. In newer versions, a zero is written so that a 'missing' collection
3778/// appears to be an empty collection.
3779
3781{
3782 Bool_t ismissing = kFALSE;
3784 if (basket && fTree) {
3785 Long64_t entry = fTree->GetReadEntry();
3787 Long64_t last;
3788 if (fReadBasket == fWriteBasket) {
3789 last = fEntryNumber - 1;
3790 } else {
3791 last = fBasketEntry[fReadBasket+1] - 1;
3792 }
3793 Int_t* entryOffset = basket->GetEntryOffset();
3794 Int_t bufbegin;
3795 Int_t bufnext;
3796 if (entryOffset) {
3797 bufbegin = entryOffset[entry-first];
3798
3799 if (entry < last) {
3800 bufnext = entryOffset[entry+1-first];
3801 } else {
3802 bufnext = basket->GetLast();
3803 }
3804 if (bufnext == bufbegin) {
3805 ismissing = kTRUE;
3806 } else {
3807 // fixed length buffer so this is not the case here.
3808 if (basket->GetNevBufSize() == 0) {
3809 ismissing = kTRUE;
3810 }
3811 }
3812 }
3813 }
3814 return ismissing;
3815}
3816
3817////////////////////////////////////////////////////////////////////////////////
3818/// Print branch parameters.
3819
3820static void PrintElements(const TStreamerInfo *info, const TStreamerInfoActions::TIDs &ids)
3821{
3822 for(auto &cursor : ids) {
3823 auto id = cursor.fElemID;
3824 if (id >= 0) {
3825 auto el = info->GetElement(id);
3826 if (el)
3827 el->ls();
3828 else {
3829 Error("TBranchElement::Print", "Element for id #%d not found in StreamerInfo for %s",
3830 id, info->GetName());
3831 info->ls();
3832 }
3833 } else if (cursor.fNestedIDs) {
3834 Printf(" Within subobject of type %s offset = %d", cursor.fNestedIDs->fInfo->GetName(), cursor.fNestedIDs->fOffset);
3835 PrintElements(cursor.fNestedIDs->fInfo, cursor.fNestedIDs->fIDs);
3836 }
3837 }
3838}
3839
3841{
3842 Int_t nbranches = fBranches.GetEntriesFast();
3843 if (strncmp(option,"debugAddress",strlen("debugAddress"))==0) {
3844 if (strlen(option)==strlen("debugAddress")) {
3845 Printf("%-24s %-16s %2s %4s %-16s %-16s %8s %8s %s %s\n",
3846 "Branch Name", "Streamer Class", "ID", "Type", "Class", "Parent", "pOffset", "fOffset", "fObject", "fOnfileObject");
3847 }
3848 if (strlen(GetName())>24) Printf("%-24s\n%-24s ", GetName(),"");
3849 else Printf("%-24s ", GetName());
3850
3851 TBranchElement *parent = dynamic_cast<TBranchElement*>(GetMother()->GetSubBranch(this));
3852 Int_t ind = parent ? parent->GetListOfBranches()->IndexOf(this) : -1;
3853 TVirtualStreamerInfo *info = ((TBranchElement*)this)->GetInfoImp();
3854
3855 Printf("%-16s %2d %4d %-16s %-16s %8x %8x %p %p%s\n",
3856 info ? info->GetName() : "StreamerInfo unavailable", GetID(), GetType(),
3858 (fBranchOffset&&parent && ind>=0) ? parent->fBranchOffset[ind] : 0,
3859 GetOffset(), GetObject(), fOnfileObject, TestBit(kOwnOnfileObj) ? " (owned)" : "");
3860 for (Int_t i = 0; i < nbranches; ++i) {
3861 TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
3862 subbranch->Print("debugAddressSub");
3863 }
3864 return;
3865 }
3866 if (strncmp(option,"debugInfo",strlen("debugInfo"))==0) {
3867 Printf("Branch %s uses:",GetName());
3868 if (fID>=0) {
3869 // GetInfoImp()->GetElement(fID)->ls();
3870 // for(UInt_t i=0; i< fIDs.size(); ++i) {
3871 // GetInfoImp()->GetElement(fIDs[i])->ls();
3872 // }
3873 TStreamerInfo *localInfo = GetInfoImp();
3874 if (fType == 3 || fType == 4) {
3875 // Search for the correct version.
3877 }
3878 Printf(" With elements:");
3879 if (fType != 3 && fType != 4)
3880 localInfo->GetElement(fID)->ls();
3881 PrintElements(localInfo, fNewIDs);
3882 Printf(" with read actions:");
3884 Printf(" with write actions:");
3886 } else if (!fNewIDs.empty() && GetInfoImp()) {
3887 TStreamerInfo *localInfo = GetInfoImp();
3888 if (fType == 3 || fType == 4) {
3889 // Search for the correct version.
3891 }
3892 PrintElements(localInfo, fNewIDs);
3893 Printf(" with read actions:");
3895 Printf(" with write actions:");
3897 }
3898 TString suboption = "debugInfoSub";
3899 suboption += (option+strlen("debugInfo"));
3900 for (Int_t i = 0; i < nbranches; ++i) {
3901 TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
3902 subbranch->Print(suboption);
3903 }
3904 Printf(" ");
3905 return;
3906 }
3907 if (nbranches) {
3908 if (fID == -2) {
3909 if (strcmp(GetName(),GetTitle()) == 0) {
3910 Printf("*Branch :%-66s *",GetName());
3911 } else {
3912 Printf("*Branch :%-9s : %-54s *",GetName(),GetTitle());
3913 }
3914 Printf("*Entries : %8d : BranchElement (see below) *",Int_t(fEntries));
3915 Printf("*............................................................................*");
3916 }
3917 if (fType >= 2) {
3918 TBranch::Print(option);
3919 }
3920 for (Int_t i=0;i<nbranches;i++) {
3921 TBranch *branch = (TBranch*)fBranches.At(i);
3922 branch->Print(option);
3923 }
3924 } else {
3925 TBranch::Print(option);
3926 }
3927}
3928
3929////////////////////////////////////////////////////////////////////////////////
3930/// Prints values of leaves.
3931
3933{
3935
3936 TStreamerInfo *info = GetInfoImp();
3937 Int_t prID = fID;
3938 char *object = fObject;
3939 if (TestBit(kCache)) {
3941 prID = fID+1;
3942 } else if (fOnfileObject) {
3943 object = fOnfileObject->GetObjectAt(0);
3944 }
3945 }
3946
3947 if (TestBit(kDecomposedObj)) {
3948 if (!fAddress) {
3949 return;
3950 }
3951 if (fType == 3 || fType == 4) {
3952 // TClonesArray or STL container top-level branch.
3953 printf(" %-15s = %d\n", GetName(), fNdata);
3954 return;
3955 } else if (fType == 31 || fType == 41) {
3956 // TClonesArray or STL container sub-branch.
3957 Int_t n = TMath::Min(10, fNdata);
3960 // TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kChar is
3961 // printed as a string and could print weird characters.
3962 // So we print an unsigned char instead (not perfect, but better).
3964 }
3965 if (atype > 54) {
3966 // FIXME: More logic required here (like in ReadLeaves)
3967 printf(" %-15s = %d\n", GetName(), fNdata);
3968 return;
3969 }
3970 if (fStreamerType > 20) {
3971 atype -= 20;
3973 n = n * leaf->GetLenStatic();
3974 }
3975 if (GetInfoImp()) {
3976 GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
3977 }
3978 return;
3979 } else if (fType <= 2) {
3980 // Branch in split mode.
3981 // FIXME: This should probably be < 60 instead.
3982 if ((fStreamerType > 40) && (fStreamerType < 55)) {
3983 Int_t atype = fStreamerType - 20;
3984 TBranchElement* counterElement = (TBranchElement*) fBranchCount;
3985 Int_t n = (Int_t) counterElement->GetValue(0, 0);
3986 if (GetInfoImp()) {
3987 GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
3988 }
3989 } else {
3990 if (GetInfoImp()) {
3991 GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
3992 }
3993 }
3994 return;
3995 }
3996 } else if (fType == 3) {
3997 printf(" %-15s = %d\n", GetName(), fNdata);
3998 } else if (fType == 31) {
3999 TClonesArray* clones = (TClonesArray*) object;
4000 if (GetInfoImp()) {
4001 GetInfoImp()->PrintValueClones(GetName(), clones, prID, fOffset, lenmax);
4002 }
4003 } else if (fType == 41) {
4005 if (GetInfoImp()) {
4006 GetInfoImp()->PrintValueSTL(GetName(), ((TBranchElement*) this)->GetCollectionProxy(), prID, fOffset, lenmax);
4007 }
4008 } else {
4009 if (GetInfoImp()) {
4010 GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
4011 }
4012 }
4013}
4014
4015////////////////////////////////////////////////////////////////////////////////
4016/// Unconfiguration Read Leave function.
4017
4019{
4020 Fatal("ReadLeaves","The ReadLeaves function has not been configured for %s",GetName());
4021}
4022
4023////////////////////////////////////////////////////////////////////////////////
4024/// Read leaves into i/o buffers for this branch.
4025/// For the case where the branch is set in MakeClass mode (decomposed object).
4026
4028{
4030
4031 if (fType == 3 || fType == 4) {
4032 // Top level branch of a TClonesArray.
4033 Int_t *n = (Int_t*) fAddress;
4034 b >> n[0];
4035 if ((n[0] < 0) || (n[0] > fMaximum)) {
4036 if (IsMissingCollection()) {
4037 n[0] = 0;
4038 b.SetBufferOffset(b.Length() - sizeof(n));
4039 } else {
4040 Error("ReadLeaves", "Incorrect size read for the container in %s\nThe size read is %d when the maximum is %d\nThe size is reset to 0 for this entry (%lld)", GetName(), n[0], fMaximum, GetReadEntry());
4041 n[0] = 0;
4042 }
4043 }
4044 fNdata = n[0];
4045 if (fType == 4) {
4046 Int_t nbranches = fBranches.GetEntriesFast();
4047 switch(fSTLtype) {
4048 case ROOT::kSTLset:
4049 case ROOT::kSTLmultiset:
4050 case ROOT::kSTLmap:
4051 case ROOT::kSTLmultimap:
4052 for (Int_t i=0; i<nbranches; i++) {
4053 TBranch *branch = (TBranch*)fBranches[i];
4054 Int_t nb = branch->GetEntry(GetReadEntry(), 1);
4055 if (nb < 0) {
4056 break;
4057 }
4058 }
4059 break;
4060 default:
4061 break;
4062 }
4063 }
4064 return;
4065 } else if (fType == 31 || fType == 41) { // sub branch of a TClonesArray
4067 Int_t atype = fStreamerType;
4068 // FIXME: This should probably be > 59 instead.
4069 if (atype > 54) return;
4070 if (!fAddress) {
4071 return;
4072 }
4073 Int_t n = fNdata;
4074 if (atype>40) {
4075 atype -= 40;
4076 if (!fBranchCount2) return;
4077 const char *len_where = (char*)fBranchCount2->fAddress;
4078 if (!len_where) return;
4079 Int_t len_atype = fBranchCount2->fStreamerType;
4080 Int_t length;
4081 Int_t k;
4082 Char_t isArray;
4083 for( k=0; k<n; k++) {
4084 char **where = &(((char**)fAddress)[k]);
4085 delete [] *where;
4086 *where = 0;
4087 switch(len_atype) {
4088 case 1: {length = ((Char_t*) len_where)[k]; break;}
4089 case 2: {length = ((Short_t*) len_where)[k]; break;}
4090 case 3: {length = ((Int_t*) len_where)[k]; break;}
4091 case 4: {length = ((Long_t*) len_where)[k]; break;}
4092 //case 5: {length = ((Float_t*) len_where)[k]; break;}
4093 case 6: {length = ((Int_t*) len_where)[k]; break;}
4094 //case 8: {length = ((Double_t*)len_where)[k]; break;}
4095 case 11: {length = ((UChar_t*) len_where)[k]; break;}
4096 case 12: {length = ((UShort_t*) len_where)[k]; break;}
4097 case 13: {length = ((UInt_t*) len_where)[k]; break;}
4098 case 14: {length = ((ULong_t*) len_where)[k]; break;}
4099 case 15: {length = ((UInt_t*) len_where)[k]; break;}
4100 case 16: {length = ((Long64_t*) len_where)[k]; break;}
4101 case 17: {length = ((ULong64_t*)len_where)[k]; break;}
4102 case 18: {length = ((Bool_t*) len_where)[k]; break;}
4103 default: continue;
4104 }
4105 b >> isArray;
4106 if (length <= 0) continue;
4107 if (isArray == 0) continue;
4108 switch (atype) {
4109 case 1: {*where=new char[sizeof(Char_t)*length]; b.ReadFastArray((Char_t*) *where, length); break;}
4110 case 2: {*where=new char[sizeof(Short_t)*length]; b.ReadFastArray((Short_t*) *where, length); break;}
4111 case 3: {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*) *where, length); break;}
4112 case 4: {*where=new char[sizeof(Long_t)*length]; b.ReadFastArray((Long_t*) *where, length); break;}
4113 case 5: {*where=new char[sizeof(Float_t)*length]; b.ReadFastArray((Float_t*) *where, length); break;}
4114 case 6: {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*) *where, length); break;}
4115 case 8: {*where=new char[sizeof(Double_t)*length]; b.ReadFastArray((Double_t*)*where, length); break;}
4116 case 11: {*where=new char[sizeof(UChar_t)*length]; b.ReadFastArray((UChar_t*) *where, length); break;}
4117 case 12: {*where=new char[sizeof(UShort_t)*length]; b.ReadFastArray((UShort_t*)*where, length); break;}
4118 case 13: {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*) *where, length); break;}
4119 case 14: {*where=new char[sizeof(ULong_t)*length]; b.ReadFastArray((ULong_t*) *where, length); break;}
4120 case 15: {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*) *where, length); break;}
4121 case 16: {*where=new char[sizeof(Long64_t)*length]; b.ReadFastArray((Long64_t*) *where, length); break;}
4122 case 17: {*where=new char[sizeof(ULong64_t)*length]; b.ReadFastArray((ULong64_t*)*where, length); break;}
4123 case 18: {*where=new char[sizeof(Bool_t)*length]; b.ReadFastArray((Bool_t*) *where, length); break;}
4124 }
4125 }
4126 return;
4127 }
4128 if (atype > 20) {
4129 atype -= 20;
4131 n *= leaf->GetLenStatic();
4132 }
4133 switch (atype) {
4134 case 1: {b.ReadFastArray((Char_t*) fAddress, n); break;}
4135 case 2: {b.ReadFastArray((Short_t*) fAddress, n); break;}
4136 case 3: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4137 case 4: {b.ReadFastArray((Long_t*) fAddress, n); break;}
4138 case 5: {b.ReadFastArray((Float_t*) fAddress, n); break;}
4139 case 6: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4140 case 8: {b.ReadFastArray((Double_t*)fAddress, n); break;}
4141 case 11: {b.ReadFastArray((UChar_t*) fAddress, n); break;}
4142 case 12: {b.ReadFastArray((UShort_t*)fAddress, n); break;}
4143 case 13: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4144 case 14: {b.ReadFastArray((ULong_t*) fAddress, n); break;}
4145 case 15: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4146 case 16: {b.ReadFastArray((Long64_t*)fAddress, n); break;}
4147 case 17: {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
4148 case 18: {b.ReadFastArray((Bool_t*) fAddress, n); break;}
4149 case 9: {
4152 Double_t *xx = (Double_t*) fAddress;
4153 for (Int_t ii=0;ii<n;ii++) {
4154 b.ReadDouble32(&(xx[ii]),se);
4155 }
4156 break;
4157 }
4158 case 19: {
4161 Float_t *xx = (Float_t*) fAddress;
4162 for (Int_t ii=0;ii<n;ii++) {
4163 b.ReadFloat16(&(xx[ii]),se);
4164 }
4165 break;
4166 }
4167 }
4168 return;
4169 } else if (fType <= 2) { // branch in split mode
4170 // FIXME: This should probably be < 60 instead.
4171 if (fStreamerType > 40 && fStreamerType < 55) {
4172 Int_t atype = fStreamerType - 40;
4173 Int_t n;
4174 if (fBranchCount==0) {
4175 // Missing fBranchCount. let's attempts to recover.
4176
4177 TString countname( GetName() );
4178 Ssiz_t dot = countname.Last('.');
4179 if (dot>=0) {
4180 countname.Remove(dot+1);
4181 } else {
4182 countname = "";
4183 }
4184 TString counter( GetTitle() );
4185 Ssiz_t loc = counter.Last('[');
4186 if (loc>=0) {
4187 counter.Remove(0,loc+1);
4188 }
4189 loc = counter.Last(']');
4190 if (loc>=0) {
4191 counter.Remove(loc);
4192 }
4193 countname += counter;
4195 }
4196 if (fBranchCount) {
4197 n = (Int_t)fBranchCount->GetValue(0,0);
4198 } else {
4199 Warning("ReadLeaves","Missing fBranchCount for %s. Data will not be read correctly by the MakeClass mode.",GetName());
4200 n = 0;
4201 }
4202 fNdata = n;
4203 Char_t isArray;
4204 b >> isArray;
4205 switch (atype) {
4206 case 1: {b.ReadFastArray((Char_t*) fAddress, n); break;}
4207 case 2: {b.ReadFastArray((Short_t*) fAddress, n); break;}
4208 case 3: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4209 case 4: {b.ReadFastArray((Long_t*) fAddress, n); break;}
4210 case 5: {b.ReadFastArray((Float_t*) fAddress, n); break;}
4211 case 6: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4212 case 8: {b.ReadFastArray((Double_t*)fAddress, n); break;}
4213 case 11: {b.ReadFastArray((UChar_t*) fAddress, n); break;}
4214 case 12: {b.ReadFastArray((UShort_t*)fAddress, n); break;}
4215 case 13: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4216 case 14: {b.ReadFastArray((ULong_t*) fAddress, n); break;}
4217 case 15: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4218 case 16: {b.ReadFastArray((Long64_t*) fAddress, n); break;}
4219 case 17: {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
4220 case 18: {b.ReadFastArray((Bool_t*) fAddress, n); break;}
4221 case 9: {
4224 Double_t *xx = (Double_t*) fAddress;
4225 for (Int_t ii=0;ii<n;ii++) {
4226 b.ReadDouble32(&(xx[ii]),se);
4227 }
4228 break;
4229 }
4230 case 19: {
4233 Float_t *xx = (Float_t*) fAddress;
4234 for (Int_t ii=0;ii<n;ii++) {
4235 b.ReadFloat16(&(xx[ii]),se);
4236 }
4237 break;
4238 }
4239 }
4240 } else {
4241 fNdata = 1;
4242 if (fAddress) {
4243 if (fType<0) {
4244 // Non TObject, Non collection classes with a custom streamer.
4245
4246 // if (fObject)
4248 } else {
4249 TStreamerInfo *info = GetInfoImp();
4250 if (!info) {
4251 return;
4252 }
4253 // Since info is not null, fReadActionSequence is not null either.
4254 b.ApplySequence(*fReadActionSequence, fObject);
4255 }
4257 fNdata = (Int_t) GetValue(0, 0);
4258 }
4259 } else {
4260 fNdata = 0;
4261 }
4262 }
4263 return;
4264 }
4265}
4266
4267////////////////////////////////////////////////////////////////////////////////
4268/// Read leaves into i/o buffers for this branch.
4269/// Case of a collection (fType == 4).
4270
4272{
4274 if (fObject == 0)
4275 {
4276 // We have nowhere to copy the data (probably because the data member was
4277 // 'dropped' from the current schema) so let's no copy it in a random place.
4278 return;
4279 }
4280
4281 // STL container master branch (has only the number of elements).
4282 Int_t n;
4283 b >> n;
4284 if ((n < 0) || (n > fMaximum)) {
4285 if (IsMissingCollection()) {
4286 n = 0;
4287 b.SetBufferOffset(b.Length()-sizeof(n));
4288 } else {
4289 Error("ReadLeaves", "Incorrect size read for the container in %s\n\tThe size read is %d while the maximum is %d\n\tThe size is reset to 0 for this entry (%lld)", GetName(), n, fMaximum, GetReadEntry());
4290 n = 0;
4291 }
4292 }
4293 fNdata = n;
4294
4295 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4296
4297 // Note: Proxy-helper needs to "embrace" the entire
4298 // streaming of this STL container if the container
4299 // is a set/multiset/map/multimap (what we do not
4300 // know here).
4301 // For vector/list/deque Allocate == Resize
4302 // and Commit == noop.
4303 // TODO: Exception safety a la TPushPop
4306 void* alternate = proxy->Allocate(fNdata, true);
4308 fPtrIterators->CreateIterators(alternate, proxy);
4309 } else {
4310 fIterators->CreateIterators(alternate, proxy);
4311 }
4312
4313 Int_t nbranches = fBranches.GetEntriesFast();
4314 switch (fSTLtype) {
4315 case ROOT::kSTLset:
4318 case ROOT::kSTLmultiset:
4319 case ROOT::kSTLmap:
4320 case ROOT::kSTLmultimap:
4323 for (Int_t i = 0; i < nbranches; ++i) {
4324 TBranch *branch = (TBranch*) fBranches[i];
4325 Int_t nb = branch->GetEntry(GetReadEntry(), 1);
4326 if (nb < 0) {
4327 // Give up on i/o failure.
4328 // FIXME: We need an error message here.
4329 break;
4330 }
4331 }
4332 break;
4333 default:
4334 break;
4335 }
4336 //------------------------------------------------------------------------
4337 // We have split this stuff, so we need to create the the pointers
4338 /////////////////////////////////////////////////////////////////////////////
4339
4341 {
4342 TClass *elClass = proxy->GetValueClass();
4343
4344 //--------------------------------------------------------------------
4345 // The allocation is done in this strange way because ReadLeaves
4346 // is being called many times by TTreeFormula!!!
4347 //////////////////////////////////////////////////////////////////////////
4348
4349 Int_t i = 0;
4350 // coverity[returned_null] the fNdata is check enough to prevent the use of null value of At(0)
4351 if( !fNdata || *(void**)proxy->At( 0 ) != 0 )
4352 i = fNdata;
4353
4354 for( ; i < fNdata; ++i )
4355 {
4356 void **el = (void**)proxy->At( i );
4357 // coverity[dereference] since this is a member streaming action by definition the collection contains objects and elClass is not null.
4358 *el = elClass->New();
4359 }
4360 }
4361
4362 proxy->Commit(alternate);
4363}
4364
4365////////////////////////////////////////////////////////////////////////////////
4366/// Read leaves into i/o buffers for this branch.
4367/// Case of a data member within a collection (fType == 41).
4368
4370{
4372 if (fObject == 0)
4373 {
4374 // We have nowhere to copy the data (probably because the data member was
4375 // 'dropped' from the current schema) so let's no copy it in a random place.
4376 return;
4377 }
4378
4379 // STL container sub-branch (contains the elements).
4381 if (!fNdata) {
4382 return;
4383 }
4384
4385 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4386
4387 TStreamerInfo *info = GetInfoImp();
4388 if (info == 0) return;
4389
4392
4393 // R__ASSERT(0);
4395 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
4396}
4397
4398////////////////////////////////////////////////////////////////////////////////
4399/// Read leaves into i/o buffers for this branch.
4400/// Case of a data member within a collection (fType == 41).
4401
4403{
4405 if (fObject == 0)
4406 {
4407 // We have nowhere to copy the data (probably because the data member was
4408 // 'dropped' from the current schema) so let's no copy it in a random place.
4409 return;
4410 }
4411
4412 // STL container sub-branch (contains the elements).
4414 if (!fNdata) {
4415 return;
4416 }
4417 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4418
4419 TStreamerInfo *info = GetInfoImp();
4420 if (info == 0) return;
4421
4424
4426 b.ApplySequenceVecPtr(*fReadActionSequence,iter->fBegin,iter->fEnd);
4427}
4428
4429////////////////////////////////////////////////////////////////////////////////
4430/// Read leaves into i/o buffers for this branch.
4431/// Case of a data member within a collection (fType == 41).
4432
4434{
4436 if (fObject == 0)
4437 {
4438 // We have nowhere to copy the data (probably because the data member was
4439 // 'dropped' from the current schema) so let's no copy it in a random place.
4440 return;
4441 }
4442
4443 // STL container sub-branch (contains the elements).
4445 if (!fNdata) {
4446 return;
4447 }
4448 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4449
4450 TStreamerInfo *info = GetInfoImp();
4451 if (info == 0) return;
4452 // Since info is not null, fReadActionSequence is not null either.
4453
4454 // Still calling PushPop for the legacy entries.
4457
4459 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
4460}
4461
4462////////////////////////////////////////////////////////////////////////////////
4463/// Read leaves into i/o buffers for this branch.
4464/// Case of a TClonesArray (fType == 3).
4465
4467{
4469 if (fObject == 0)
4470 {
4471 // We have nowhere to copy the data (probably because the data member was
4472 // 'dropped' from the current schema) so let's no copy it in a random place.
4473 return;
4474 }
4475
4476 // TClonesArray master branch (has only the number of elements).
4477 Int_t n;
4478 b >> n;
4479 if ((n < 0) || (n > fMaximum)) {
4480 if (IsMissingCollection()) {
4481 n = 0;
4482 b.SetBufferOffset(b.Length()-sizeof(n));
4483 } else {
4484 Error("ReadLeaves", "Incorrect size read for the container in %s\n\tThe size read is %d while the maximum is %d\n\tThe size is reset to 0 for this entry (%lld)", GetName(), n, fMaximum, GetReadEntry());
4485 n = 0;
4486 }
4487 }
4488 fNdata = n;
4489 TClonesArray* clones = (TClonesArray*) fObject;
4490 if (clones->IsZombie()) {
4491 return;
4492 }
4493 // The salient part of Clear is now 'duplicated in ExpandCreateFast (i.e. the
4494 // setting to zero of the unused slots), so we no longer need to call Clear explicitly
4495 // clones->Clear();
4496 clones->ExpandCreateFast(fNdata);
4497}
4498
4499////////////////////////////////////////////////////////////////////////////////
4500/// Read leaves into i/o buffers for this branch.
4501/// Case of a data member within a TClonesArray (fType == 31).
4502
4504{
4505 // No need to validate the address here, if we are a member of a split ClonesArray,
4506 // fID is positive
4507 // ValidateAddress();
4508
4509 if (fObject == 0)
4510 {
4511 // We have nowhere to copy the data (probably because the data member was
4512 // 'dropped' from the current schema) so let's no copy it in a random place.
4513 return;
4514 }
4515
4516 // TClonesArray sub-branch (contains the elements).
4518 TClonesArray* clones = (TClonesArray*) fObject;
4519 if (clones->IsZombie()) {
4520 return;
4521 }
4522 TStreamerInfo *info = GetInfoImp();
4523 if (info==0) return;
4524 // Since info is not null, fReadActionSequence is not null either.
4525
4526 // Note, we could (possibly) save some more, by configuring the action
4527 // based on the value of fOnfileObject rather than pushing in on a stack.
4528 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4529
4530 char **arr = (char **)clones->GetObjectRef();
4531 char **end = arr + fNdata;
4532 b.ApplySequenceVecPtr(*fReadActionSequence,arr,end);
4533}
4534
4535////////////////////////////////////////////////////////////////////////////////
4536/// Read leaves into i/o buffers for this branch.
4537/// For split-class branch, base class branch, data member branch, or top-level branch.
4538/// which do not have a branch count and are not a counter.
4539
4541{
4544
4546 if (fObject == 0)
4547 {
4548 // We have nowhere to copy the data (probably because the data member was
4549 // 'dropped' from the current schema) so let's no copy it in a random place.
4550 return;
4551 }
4552
4553 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4554 // If not a TClonesArray or STL container master branch
4555 // or sub-branch and branch inherits from tobject,
4556 // then register with the buffer so that pointers are
4557 // handled properly.
4558 if (TestBit(kBranchObject)) {
4559 b.MapObject((TObject*) fObject);
4560 } else if (TestBit(kBranchAny)) {
4561 b.MapObject(fObject, fBranchClass);
4562 }
4563
4564 fNdata = 1;
4565 TStreamerInfo *info = GetInfoImp();
4566 if (!info) {
4567 return;
4568 }
4569 // Since info is not null, fReadActionSequence is not null either.
4570 b.ApplySequence(*fReadActionSequence, fObject);
4571}
4572
4573////////////////////////////////////////////////////////////////////////////////
4574/// Read leaves into i/o buffers for this branch.
4575/// For split-class branch, base class branch, data member branch, or top-level branch.
4576/// which do have a branch count and are not a counter.
4577
4579{
4581
4583 if (fObject == 0)
4584 {
4585 // We have nowhere to copy the data (probably because the data member was
4586 // 'dropped' from the current schema) so let's no copy it in a random place.
4587 return;
4588 }
4589
4590 // If not a TClonesArray or STL container master branch
4591 // or sub-branch and branch inherits from tobject,
4592 // then register with the buffer so that pointers are
4593 // handled properly.
4594 if (TestBit(kBranchObject)) {
4595 b.MapObject((TObject*) fObject);
4596 } else if (TestBit(kBranchAny)) {
4597 b.MapObject(fObject, fBranchClass);
4598 }
4599
4600 fNdata = (Int_t) fBranchCount->GetValue(0, 0);
4601 TStreamerInfo *info = GetInfoImp();
4602 if (!info) {
4603 return;
4604 }
4605 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1); // Here we have a single object that contains a variable size C-style array.
4606 // Since info is not null, fReadActionSequence is not null either.
4607 b.ApplySequence(*fReadActionSequence, fObject);
4608}
4609
4610////////////////////////////////////////////////////////////////////////////////
4611/// Read leaves into i/o buffers for this branch.
4612/// For split-class branch, base class branch, data member branch, or top-level branch.
4613/// which do not have a branch count and are a counter.
4614
4616{
4618 if (fObject == 0)
4619 {
4620 // We have nowhere to copy the data (probably because the data member was
4621 // 'dropped' from the current schema) so let's no copy it in a random place.
4622 return;
4623 }
4624
4625 // If not a TClonesArray or STL container master branch
4626 // or sub-branch and branch inherits from tobject,
4627 // then register with the buffer so that pointers are
4628 // handled properly.
4629 if (TestBit(kBranchObject)) {
4630 b.MapObject((TObject*) fObject);
4631 } else if (TestBit(kBranchAny)) {
4632 b.MapObject(fObject, fBranchClass);
4633 }
4634
4635 TStreamerInfo *info = GetInfoImp();
4636 if (!info) {
4637 return;
4638 }
4639
4640 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4641
4642 // Since info is not null, fReadActionSequence is not null either.
4643 b.ApplySequence(*fReadActionSequence, fObject);
4644 fNdata = (Int_t) GetValue(0, 0);
4645}
4646
4647////////////////////////////////////////////////////////////////////////////////
4648/// Read leaves into i/o buffers for this branch.
4649/// Non TObject, Non collection classes with a custom streamer.
4650
4652{
4654 if (fObject == 0)
4655 {
4656 // We have nowhere to copy the data (probably because the data member was
4657 // 'dropped' from the current schema) so let's no copy it in a random place.
4658 return;
4659 }
4660
4661 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4663}
4664
4665////////////////////////////////////////////////////////////////////////////////
4666/// Unconfiguration Fill Leave function.
4667
4669{
4670 Fatal("FillLeaves","The FillLeaves function has not been configured for %s",GetName());
4671}
4672
4673////////////////////////////////////////////////////////////////////////////////
4674/// Delete any object we may have allocated on a previous call to SetAddress.
4675
4677{
4678 if (fObject && TestBit(kDeleteObject)) {
4679 if (IsAutoDelete() && fAddress != (char*)&fObject) {
4680 *((char**) fAddress) = 0;
4681 }
4683 if (fType == 3) {
4684 // -- We are a TClonesArray master branch.
4685 TClonesArray::Class()->Destructor(fObject);
4686 fObject = 0;
4689 // -- We are a pointer to a TClonesArray.
4690 // We must zero the pointer in the object.
4691 *((char**) fAddress) = 0;
4692 }