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 = nullptr;
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 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 false;
115 }
116 }
117 const static TClassRef stringClass("std::string");
118 if (cl == stringClass || cl == TString::Class()) {
119 return false;
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 true;
125 }
126 return false;
127 }
128}
129
130////////////////////////////////////////////////////////////////////////////////
131/// Default and I/O constructor.
132
134: TBranch()
135, fClassName()
136, fParentName()
137, fClonesName()
138, fCollProxy(nullptr)
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(nullptr)
148, fBranchCount2(nullptr)
149, fInfo(nullptr)
150, fObject(nullptr)
151, fOnfileObject(nullptr)
152, fInit(false)
153, fInInitInfo(false)
154, fInitOffsets(false)
155, fTargetClass()
156, fCurrentClass()
157, fParentClass()
158, fBranchClass()
159, fClonesClass()
160, fBranchOffset(nullptr)
161, fBranchID(-1)
162, fReadActionSequence(nullptr)
163, fFillActionSequence(nullptr)
164, fIterators(nullptr)
165, fWriteIterators(nullptr)
166, fPtrIterators(nullptr)
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(nullptr)
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(nullptr)
193, fBranchCount2(nullptr)
194, fInfo(sinfo)
195, fObject(nullptr)
196, fOnfileObject(nullptr)
197, fInit(true)
198, fInInitInfo(false)
199, fInitOffsets(false)
200, fTargetClass(fClassName)
201, fCurrentClass()
202, fParentClass()
203, fBranchClass(sinfo->GetClass())
204, fClonesClass()
205, fBranchOffset(nullptr)
206, fBranchID(-1)
207, fReadActionSequence(nullptr)
208, fFillActionSequence(nullptr)
209, fIterators(nullptr)
210, fWriteIterators(nullptr)
211, fPtrIterators(nullptr)
212{
213 if (tree) {
214 ROOT::TIOFeatures features = tree->GetIOFeatures();
215 SetIOFeatures(features);
216 }
217 Init(tree, nullptr, 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(nullptr)
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(nullptr)
240, fBranchCount2(nullptr)
241, fInfo(sinfo)
242, fObject(nullptr)
243, fOnfileObject(nullptr)
244, fInit(true)
245, fInInitInfo(false)
246, fInitOffsets(false)
247, fTargetClass( fClassName )
248, fCurrentClass()
249, fParentClass()
250, fBranchClass(sinfo->GetClass())
251, fClonesClass()
252, fBranchOffset(nullptr)
253, fBranchID(-1)
254, fReadActionSequence(nullptr)
255, fFillActionSequence(nullptr)
256, fIterators(nullptr)
257, fWriteIterators(nullptr)
258, fPtrIterators(nullptr)
259{
260 ROOT::TIOFeatures features = parent->GetIOFeatures();
261 SetIOFeatures(features);
262 Init(parent ? parent->GetTree() : nullptr, 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 == nullptr) 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
290 SetAutoDelete(false);
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 = nullptr;
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 hasCustomStreamer = false;
365 bool 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 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(true);
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 cansplit = true;
565 if (!valueClass) {
566 cansplit = false;
567 } else if ((valueClass == TString::Class()) || (valueClass == TClass::GetClass("string"))) {
568 cansplit = false;
569 } else if (GetCollectionProxy()->HasPointers() && !splitSTLP ) {
570 cansplit = false;
571 } else if (!valueClass->CanSplit() && !(GetCollectionProxy()->HasPointers() && splitSTLP)) {
572 cansplit = false;
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 = false;
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(true);
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(true)
668, fInInitInfo(false)
669, fInitOffsets(false)
670, fTargetClass( fClassName )
671, fCurrentClass()
672, fParentClass()
673, fBranchClass(TClonesArray::Class())
674, fBranchID(-1)
675, fReadActionSequence(nullptr)
676, fFillActionSequence(nullptr)
677, fIterators(nullptr)
678, fWriteIterators(nullptr)
679, fPtrIterators(nullptr)
680{
681 Init(tree, nullptr, 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(true)
695, fInInitInfo(false)
696, fInitOffsets(false)
697, fTargetClass( fClassName )
698, fCurrentClass()
699, fParentClass()
700, fBranchClass(TClonesArray::Class())
701, fBranchID(-1)
702, fReadActionSequence(nullptr)
703, fFillActionSequence(nullptr)
704, fIterators(nullptr)
705, fWriteIterators(nullptr)
706, fPtrIterators(nullptr)
707{
708 Init(parent ? parent->GetTree() : nullptr, 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 = nullptr;
719 fSplitLevel = splitlevel;
720 fID = 0;
721 fInit = true;
722 fStreamerType = -1;
723 fType = 0;
726 fBranchCount = nullptr;
727 fBranchCount2 = nullptr;
728 fObject = nullptr;
729 fOnfileObject = nullptr;
730 fMaximum = 0;
731 fBranchOffset = nullptr;
733 fInitOffsets = false;
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.
766 SetAutoDelete(false);
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, nullptr, 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(true)
822, fInInitInfo(false)
823, fInitOffsets(false)
824, fTargetClass( fClassName )
825, fCurrentClass()
826, fParentClass()
827, fBranchClass(cont->GetCollectionClass())
828, fBranchID(-1)
829, fReadActionSequence(nullptr)
830, fFillActionSequence(nullptr)
831, fIterators(nullptr)
832, fWriteIterators(nullptr)
833, fPtrIterators(nullptr)
834{
835 Init(tree, nullptr, 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(true)
848, fInInitInfo(false)
849, fInitOffsets(false)
850, fTargetClass( fClassName )
851, fCurrentClass()
852, fParentClass()
853, fBranchClass(cont->GetCollectionClass())
854, fBranchID(-1)
855, fReadActionSequence(nullptr)
856, fFillActionSequence(nullptr)
857, fIterators(nullptr)
858, fWriteIterators(nullptr)
859, fPtrIterators(nullptr)
860{
861 Init(parent ? parent->GetTree() : nullptr, 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 }
876 fInitOffsets = false;
877 fSplitLevel = splitlevel;
878 fInfo = nullptr;
879 fID = -1;
880 fInit = true;
881 fStreamerType = -1; // TVirtualStreamerInfo::kSTLp;
882 fType = 0;
885 fBranchCount = nullptr;
886 fBranchCount2 = nullptr;
887 fObject = nullptr;
888 fOnfileObject = nullptr;
889 fMaximum = 0;
890 fBranchOffset = nullptr;
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.
932 SetAutoDelete(false);
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, nullptr, 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 = nullptr;
981 }
982 ResetAddress();
983
984 delete[] fBranchOffset;
985 fBranchOffset = nullptr;
986
987 fInfo = nullptr;
988 fBranchCount2 = nullptr;
989 fBranchCount = nullptr;
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 = nullptr;
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=nullptr;
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=nullptr;
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=nullptr;
1054 TClass* clsub=nullptr;
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 == nullptr) {
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,false);
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*) 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(nullptr!=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(nullptr!=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(nullptr!=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(nullptr);
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 = nullptr;
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 }
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==nullptr && GetListOfLeaves()->GetEntries()==1) {
1877 TBranch *br = GetMother()->GetSubBranch( this );
1878 if( br->IsA() != TBranchElement::Class() )
1879 return nullptr;
1880
1881 TBranchElement *parent = (TBranchElement*)br;
1882 if (parent==this || parent->GetID()<0 ) return nullptr;
1883
1884 TVirtualStreamerInfo* si = parent->GetInfoImp();
1885 TStreamerElement* se = si->GetElement(parent->GetID());
1886
1887 if (! se->IsBase() ) return nullptr;
1888
1889 br = GetMother()->GetSubBranch( parent );
1890 if( br->IsA() != TBranchElement::Class() )
1891 return nullptr;
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 {
1987void 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 = true;
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 = nullptr;
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", "Branch '%s': missing dictionary for target class '%s'!",
2141 return;
2142 }
2143 } else {
2144 targetClass = cl;
2145 }
2146 if (cl) {
2147 //---------------------------------------------------------------------
2148 // Get the streamer info for given version
2149 ///////////////////////////////////////////////////////////////////////
2150
2151 {
2152 if ( (cl->Property() & kIsAbstract) && cl == targetClass) {
2154 if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
2155 // Our parent's class is emulated and we represent an abstract class.
2156 // and the target class has not been set explicitly.
2157 TString target = cl->GetName();
2158 target += "@@emulated";
2160
2161 if (!fTargetClass) {
2163 }
2164 targetClass = fTargetClass;
2165 }
2166 }
2167 if( targetClass != cl ) {
2169 } else {
2171 }
2172 }
2173
2174 // FIXME: Check that the found streamer info checksum matches our branch class checksum here.
2175 // Check to see if the class code was unloaded/reloaded
2176 // since we were created.
2178 if (fCheckSum && (cl->IsForeign() || (!cl->IsLoaded() && (fClassVersion == 1) && cl->GetStreamerInfos()->At(1) && (fCheckSum != ((TVirtualStreamerInfo*) cl->GetStreamerInfos()->At(1))->GetCheckSum())))) {
2179 // Try to compensate for a class that got unloaded on us.
2180 // Search through the streamer infos by checksum
2181 // and take the first match.
2182
2183 TStreamerInfo* info;
2184 if( targetClass != cl )
2185 info = (TStreamerInfo*)targetClass->FindConversionStreamerInfo( cl, fCheckSum );
2186 else {
2188 if (info) {
2189 // Now that we found it, we need to make sure it is initialize (Find does not initialize the StreamerInfo).
2190 info = (TStreamerInfo*)cl->GetStreamerInfo(info->GetClassVersion());
2191 }
2192 }
2193 if( info ) {
2194 fInfo = info;
2195 // We no longer reset the class version so that in case the user is passing us later
2196 // the address of a class that require (another) Conversion we can find the proper
2197 // StreamerInfo.
2198 // fClassVersion = fInfo->GetClassVersion();
2199 }
2200 }
2201 }
2202}
2203
2204
2205////////////////////////////////////////////////////////////////////////////////
2206/// Init the streamer info for the branch class, try to compensate for class
2207/// code unload/reload and schema evolution.
2208
2210{
2211 if (!fInfo)
2212 SetupInfo();
2213
2214 //
2215 // Fixup cached streamer info if necessary.
2216 //
2217 // FIXME: What if the class code was unloaded/reloaded since we were cached?
2218
2219 if (fInfo) {
2220
2221 if (!fInfo->IsCompiled()) {
2222 // Streamer info has not yet been compiled.
2223
2224 Error("InitInfo","StreamerInfo is not compiled.");
2225 }
2226 // return immediately if we are called recursively.
2227 if (fInInitInfo)
2228 return;
2229 fInInitInfo = true;
2230 if (!fInit) {
2231 // We were read in from a file, figure out what our fID should be,
2232 // schema evolution must be considered.
2233 //
2234 // Force our fID to be the id of the first streamer element that matches our name.
2235 //
2236 auto SetOnfileObject = [this](TStreamerInfo *info) {
2237 Int_t arrlen = 1;
2238 if (fType==31 || fType==41) {
2239 TLeaf *leaf = (TLeaf*)fLeaves.At(0);
2240 if (leaf) {
2241 arrlen = leaf->GetMaximum();
2242 }
2243 }
2244 bool toplevel = (fType == 3 || fType == 4 || (fType == 0 && fID == -2));
2245 bool seenExisting = false;
2246
2247 fOnfileObject = new TVirtualArray( info->GetElement(0)->GetClassPointer(), arrlen );
2248 // Propagate this to all the other branches belonging to the same object.
2249 TObjArray *branches = toplevel ? GetListOfBranches() : GetMother()->GetSubBranch(this)->GetListOfBranches();
2250 Int_t nbranches = branches->GetEntriesFast();
2251 TBranchElement *lastbranch = this;
2252
2253 TClass *currentClass = fBranchClass;
2254 auto currentVersion = fClassVersion;
2255 if (toplevel) {
2256 // Note: Fragile/wrong when using conversion StreamerInfo?
2257 currentClass = info->GetClass();
2258 currentVersion = info->GetClassVersion();
2259 }
2260
2261 // First find the first branch corresponding to the same class as 'this'
2262 // branch
2263 Int_t index = branches->IndexOf(this);
2264 Int_t firstindex = 0;
2265 Int_t lastindex = nbranches - 1;
2266 if (index >= 0) {
2267 TString fullname( GetFullName() );
2268 Ssiz_t lastdot = fullname.Last('.');
2269 if (lastdot == TString::kNPOS) {
2270 // No prefix or index, thus this is a first level branch
2271 TBranchElement* subbranch = (TBranchElement*)branches->At(0);
2272 if (!subbranch->fInfo)
2273 subbranch->SetupInfo();
2274 } else {
2275 TString &thisprefix = fullname.Remove(lastdot + 1); // Mod fullname and 'rename' the variable.
2276 for(Int_t i = index - 1; i >= 0; --i) {
2277 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2278 TString subbranch_name(subbranch->GetFullName());
2279 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2280 // We moved to another data member (of the enclosing class)
2281 firstindex = i + 1;
2282 break;
2283 }
2284 if (!subbranch->fInfo)
2285 subbranch->SetupInfo();
2286 }
2287 for(Int_t i = index; i < nbranches; ++i) {
2288 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2289 TString subbranch_name(subbranch->GetFullName());
2290 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2291 lastindex = i - 1;
2292 break;
2293 }
2294 }
2295 }
2296 } else {
2297 // Case of a top level branch or 'empty node' (object marker for split sub-object)
2298 TString fullname( GetFullName() );
2299 Ssiz_t lastdot = fullname.Last('.');
2300 if (lastdot != TString::kNPOS) {
2301 TString &thisprefix = fullname.Remove(lastdot + 1); // Mod fullname and 'rename' the variable.
2302 for(Int_t i = 0; i < nbranches; ++i) {
2303 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2304 TString subbranch_name(subbranch->GetFullName());
2305 if ( ! subbranch_name.BeginsWith(thisprefix)) {
2306 lastindex = i - 1;
2307 break;
2308 }
2309 }
2310 }
2311 }
2312 for (Int_t i = firstindex; i <= lastindex; ++i) {
2313 TBranchElement* subbranch = (TBranchElement*)branches->At(i);
2314 bool match = false;
2315 if (this != subbranch) {
2316
2317 if (!subbranch->fInfo)
2318 subbranch->SetupInfo();
2319
2320 if (subbranch->fInfo == info)
2321 match = true;
2322 else if (subbranch->fInfo == nullptr && subbranch->fBranchClass == currentClass) {
2323 if (!toplevel) {
2324 if (subbranch->fCheckSum == fCheckSum)
2325 match = true;
2326 } else {
2327 if (!subbranch->fBranchClass->IsForeign() && subbranch->fClassVersion == currentVersion)
2328 match = true;
2329 else if (subbranch->fCheckSum == info->GetCheckSum()) {
2330 match = true;
2331 }
2332 }
2333 }
2334 }
2335 if (match) {
2336 if (subbranch->fOnfileObject && subbranch->fOnfileObject != fOnfileObject) {
2337 if (seenExisting) {
2338 Error("SetOnfileObject (lambda)", "2 distincts fOnfileObject are in the hierarchy of %s for type %s",
2339 toplevel ? GetName() : GetMother()->GetSubBranch(this)->GetName(), info->GetName());
2340 } else {
2341 delete fOnfileObject;
2342 fOnfileObject = subbranch->fOnfileObject;
2343 seenExisting = true;
2344 }
2345 }
2346 subbranch->fOnfileObject = fOnfileObject;
2347 lastbranch = subbranch;
2348 }
2349 }
2350 if (toplevel) {
2352 if (lastbranch != this)
2353 lastbranch->ResetBit(kOwnOnfileObj);
2354 } else {
2355 lastbranch->SetBit(kOwnOnfileObj);
2356 }
2357 };
2358 if (GetID() > -1) {
2359 // We are *not* a top-level branch.
2360 std::string s(GetName());
2361 size_t pos = s.rfind('.');
2362 if (pos != std::string::npos) {
2363 s = s.substr(pos+1);
2364 }
2365 while ((pos = s.rfind('[')) != std::string::npos) {
2366 s = s.substr(0, pos);
2367 }
2368 int offset = 0;
2369 TStreamerElement* elt = fInfo->GetStreamerElement(s.c_str(), offset);
2370 if (elt && offset!=TStreamerInfo::kMissing) {
2371 size_t ndata = fInfo->GetNelement();
2372 fNewIDs.clear();
2373 for (size_t i = 0; i < ndata; ++i) {
2374 if (fInfo->GetElement(i) == elt) {
2376 && (i+1) < ndata
2377 && s == fInfo->GetElement(i)->GetName())
2378 {
2379 // If the TStreamerElement we found is storing the information in the
2380 // cache and is a repeater, we need to use the real one (the next one).
2381 // (At least until the cache/repeat mechanism is properly handle by
2382 // ReadLeaves).
2383 // fID = i+1;
2384 fID = i;
2385 if (fType != 2) {
2387 fNewIDs.push_back(fID+1);
2388 fNewIDs.back().fElement = fInfo->GetElement(i+1);
2389 fNewIDs.back().fInfo = fInfo;
2390 } else if (fInfo->GetElement(i+1)->TestBit(TStreamerElement::kWrite)) {
2391 fNewIDs.push_back(fID+1);
2392 fNewIDs.back().fElement = fInfo->GetElement(i+1);
2393 fNewIDs.back().fInfo = fInfo;
2394 }
2395 }
2396 } else {
2397 fID = i;
2398 }
2399 if (elt->TestBit (TStreamerElement::kCache)) {
2401 }
2402 break;
2403 }
2404 }
2405 for (size_t i = fID+1+(fNewIDs.size()); i < ndata; ++i) {
2406 TStreamerElement *nextel = fInfo->GetElement(i);
2407
2408 std::string ename = nextel->GetName();
2409 if (ename[0] == '*')
2410 ename = ename.substr(1);
2411
2412 while ((pos = ename.rfind('[')) != std::string::npos) {
2413 ename = ename.substr(0, pos);
2414 }
2415
2416 if (s != ename) {
2417 // We moved on to the next set
2418 break;
2419 }
2420 // Add all (and only) the Artificial Elements that follows this StreamerInfo.
2421 // fprintf(stderr,"%s/%d[%zu] passing through %zu %s\n",GetName(),fID,fIDs.size(),i,nextel->GetName());
2422 if (fType==31||fType==41) {
2423 // The nested objects are unfolded and their branch can not be used to
2424 // execute StreamerElements of this StreamerInfo.
2425 if ((nextel->GetType() == TStreamerInfo::kObject
2426 || nextel->GetType() == TStreamerInfo::kAny)
2427 && nextel->GetClassPointer()->CanSplit())
2428 {
2429 continue;
2430 }
2431 }
2432 if (nextel->GetOffset() == TStreamerInfo::kMissing) {
2433 // This element will be 'skipped', it's TBranchElement's fObject will null
2434 // and thus can not be used to execute the artificial StreamerElements
2435 continue;
2436 }
2437 if (nextel->IsA() != TStreamerArtificial::Class()
2438 || nextel->GetType() == TStreamerInfo::kCacheDelete ) {
2439 continue;
2440 }
2441 // NOTE: We should verify that the rule's source are 'before'
2442 // or 'at' this branch.
2443 // fprintf(stderr,"%s/%d[%zu] pushd %zu %s\n",GetName(),fID,fIDs.size(),i,nextel->GetName());
2444 fNewIDs.push_back(i);
2445 fNewIDs.back().fElement = nextel;
2446 fNewIDs.back().fInfo = fInfo;
2447 }
2448 } else if (elt && offset==TStreamerInfo::kMissing) {
2449 // Still re-assign fID properly.
2450 fNewIDs.clear();
2451 size_t ndata = fInfo->GetNelement();
2452 for (size_t i = 0; i < ndata; ++i) {
2453 if (fInfo->GetElement(i) == elt) {
2454 fID = i;
2455 break;
2456 }
2457 }
2458 } else {
2459 // We have not even found the element .. this is strange :(
2460 // fNewIDs.clear();
2461 // fID = -3;
2462 // SetBit(kDoNotProcess);
2463 }
2464 if (fOnfileObject==nullptr && (fType==31 || fType==41 || (0 <= fType && fType <=2) ) && fInfo->GetNelement()
2466 {
2467 SetOnfileObject(fInfo);
2468 }
2469 }
2470 if (fType == 3 || fType == 4 || (fType == 0 && fID == -2) || fType == 2) {
2471 // Need to add the rule targeting transient members.
2472 TStreamerInfo *localInfo = fInfo;
2473 if (fType == 3 || fType == 4) {
2474 // Don't we have real version information?
2475 // Not unless there is a subbranch with a non-split element of the class.
2476 // Search for the correct version.
2478 }
2479
2480 TString prefix(GetFullName());
2481 if (fType == 2 && fID >= 0) {
2482 auto start = prefix.Length();
2483 if (prefix[start - 1] == '.')
2484 --start;
2485 std::string_view view(prefix.Data(), start);
2486 auto cutoff = view.find_last_of('.');
2487 if (cutoff != std::string::npos) {
2488 prefix.Remove(cutoff + 1);
2489 }
2490 }
2491 if (prefix[prefix.Length()-1] != '.') {
2492 if (fType == 3 || fType == 4 || prefix.Index('.') != TString::kNPOS) {
2493 prefix += ".";
2494 } else {
2495 prefix = "";
2496 }
2497 }
2498 fNewIDs.clear();
2499
2500 GatherArtificialElements(fBranches, fNewIDs, prefix, localInfo, 0);
2501
2502 if (!fNewIDs.empty() && fOnfileObject == nullptr && localInfo->GetElement(0)->GetType() == TStreamerInfo::kCacheNew)
2503 {
2504 SetOnfileObject(localInfo);
2505 }
2506
2507 }
2508 fInit = true;
2509
2510 // Get the action sequence we need to copy for reading.
2513 } else if (!fReadActionSequence) {
2514 // Get the action sequence we need to copy for reading.
2517 }
2520 fInInitInfo = false;
2521 }
2522}
2523
2524////////////////////////////////////////////////////////////////////////////////
2525/// Return the collection proxy describing the branch content, if any.
2526
2528{
2529 if (fCollProxy) {
2530 return fCollProxy;
2531 }
2532 TBranchElement* thiscast = const_cast<TBranchElement*>(this);
2533 if (fType == 4) {
2534 // STL container top-level branch.
2535 const char* className = nullptr;
2536 TClass* cl = nullptr;
2537 if (fID < 0) {
2538 // We are a top-level branch.
2539 if (fBranchClass.GetClass()) {
2540 cl = fBranchClass.GetClass();
2541 }
2542 } else {
2543 // We are not a top-level branch.
2544 TVirtualStreamerInfo* si = thiscast->GetInfoImp();
2545 if (fCollProxy) {
2546 // The GetInfo set fProxy for us, let's not
2547 // redo it; the value of fCollProxy is possibly
2548 // used/recorded is the actions sequences, so
2549 // if we change it here, we would need to propagate
2550 // the change.
2551 return fCollProxy;
2552 }
2553 TStreamerElement* se = si->GetElement(fID);
2554 cl = se->GetClassPointer();
2555 }
2556 if (!cl) {
2557 // The TClass was not created but we do know (since it
2558 // is used as a collection) that it 'className' was a
2559 // class, so let's create it by hand!.
2560
2561 if (fID < 0) {
2564 className = cl->GetName();
2565 } else {
2566 cl = new TClass(className, fClassVersion);
2568 className = cl->GetName();
2569 }
2570 }
2572 if (!proxy) {
2573 // humm, we must have an older file with a custom collection
2574 // let's try to work-around it.
2575 TString equiv;
2576 equiv.Form("vector<%s>",fClonesName.Data());
2577 TClass *clequiv = TClass::GetClass(equiv);
2578 proxy = clequiv->GetCollectionProxy();
2579 if (!proxy) {
2580 Fatal("GetCollectionProxy",
2581 "Can not create a Collection Proxy of any kind for the class \"%s\" needed by the branch \"%s\" of the TTree \"%s\"!",
2582 className, GetName(), GetTree()->GetName());
2583 }
2584 if (gDebug > 0) Info("GetCollectionProxy",
2585 "Fixing the collection proxy of the class \"%s\" \n"
2586 "\tneeded by the branch \"%s\" of the TTree \"%s\" to be similar to \"%s\".",
2587 className, GetName(), GetTree()->GetName(),equiv.Data());
2588 cl->CopyCollectionProxy( *proxy );
2589 }
2590 fCollProxy = proxy->Generate();
2591 fSTLtype = proxy->GetCollectionType();
2592 } else if (fType == 41) {
2593 // STL container sub-branch.
2595 }
2596 return fCollProxy;
2597}
2598
2599////////////////////////////////////////////////////////////////////////////////
2600/// Return a pointer to the current type of the data member corresponding to branch element.
2601
2603{
2604 TClass* cl = fCurrentClass;
2605 if (cl) {
2606 return cl;
2607 }
2608
2610 if (!brInfo) {
2612 R__ASSERT(cl && cl->GetCollectionProxy());
2613 fCurrentClass = cl;
2614 return cl;
2615 }
2616 TClass* motherCl = brInfo->GetClass();
2617 if (motherCl->GetCollectionProxy()) {
2618 cl = motherCl->GetCollectionProxy()->GetCollectionClass();
2619 if (cl) {
2620 fCurrentClass = cl;
2621 }
2622 return cl;
2623 }
2624 if (GetID() < 0 || GetID()>=brInfo->GetNelement()) {
2625 return nullptr;
2626 }
2627 TStreamerElement* currentStreamerElement = brInfo->GetElement(GetID());
2628 TDataMember* dm = (TDataMember*) motherCl->GetListOfDataMembers()->FindObject(currentStreamerElement->GetName());
2629
2630 TString newType;
2631 if (!dm) {
2632 // Either the class is not loaded or the data member is gone
2633 if (!motherCl->IsLoaded()) {
2634 TVirtualStreamerInfo* newInfo = motherCl->GetStreamerInfo();
2635 if (newInfo != brInfo) {
2636 TStreamerElement* newElems = (TStreamerElement*) newInfo->GetElements()->FindObject(currentStreamerElement->GetName());
2637 if (newElems) {
2638 if (newElems->GetClassPointer())
2639 newType = newElems->GetClassPointer()->GetName();
2640 else
2641 newType = newElems->GetTypeName();
2642 }
2643 }
2644 if (newType.Length()==0) {
2645 if (currentStreamerElement->GetClassPointer())
2646 newType = currentStreamerElement->GetClassPointer()->GetName();
2647 else
2648 newType = currentStreamerElement->GetTypeName();
2649 }
2650 }
2651 } else {
2652 newType = dm->GetTypeName();
2653 }
2654 cl = TClass::GetClass(newType);
2655 if (cl) {
2656 fCurrentClass = cl;
2657 }
2658 return cl;
2659}
2660
2661////////////////////////////////////////////////////////////////////////////////
2662/// Read all branches of a BranchElement and return total number of bytes.
2663///
2664/// - If entry = 0, then use current entry number + 1.
2665/// - If entry < 0, then reset entry number to 0.
2666///
2667/// Returns the number of bytes read from the input buffer.
2668/// - If entry does not exist, then returns 0.
2669/// - If an I/O error occurs, then returns -1.
2670///
2671/// See IMPORTANT REMARKS in TTree::GetEntry.
2672
2674{
2675 // Remember which entry we are reading.
2676 fReadEntry = entry;
2677
2678 // If our tree has a branch ref, make it remember the entry and
2679 // this branch. This allows a TRef::GetObject() call done during
2680 // the following I/O operation, for example in a custom streamer,
2681 // to search for the referenced object in the proper element of the
2682 // proper branch.
2683 TBranchRef* bref = fTree->GetBranchRef();
2684 if (R__unlikely(bref)) {
2685 R__LOCKGUARD_IMT(gROOTMutex); // Lock for parallel TTree I/O
2686 fBranchID = bref->SetParent(this, fBranchID);
2687 bref->SetRequestedEntry(entry);
2688 }
2689
2690 Int_t nbytes = 0;
2691
2692 if (R__unlikely(IsAutoDelete())) {
2695 } else {
2697 R__LOCKGUARD_IMT(gROOTMutex); // Lock for parallel TTree I/O
2699 }
2700 }
2701
2702 Int_t nbranches = fBranches.GetEntriesFast();
2703 if (nbranches) {
2704 // -- Branch has daughters.
2705 // One must always read the branch counter.
2706 // In the case when one reads consecutively twice the same entry,
2707 // the user may have cleared the TClonesArray between the GetEntry calls.
2708 if ((fType == 3) || (fType == 4)) {
2709 Int_t nb = TBranch::GetEntry(entry, getall);
2710 if (nb < 0) {
2711 return nb;
2712 }
2713 nbytes += nb;
2714 }
2715 switch(fSTLtype) {
2716 case ROOT::kSTLset:
2717 case ROOT::kSTLmultiset:
2720 case ROOT::kSTLmap:
2721 case ROOT::kSTLmultimap:
2724 break;
2725 default:
2726 ValidateAddress(); // There is no ReadLeave for this node, so we need to do the validation here.
2727 for (Int_t i = 0; i < nbranches; ++i) {
2728 TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
2729 Int_t nb = branch->GetEntry(entry, getall);
2730 if (nb < 0) {
2731 return nb;
2732 }
2733 nbytes += nb;
2734 }
2735 break;
2736 }
2738 if (fType == 3) {
2739 // Apply the unattached rules; by definition they do not need any
2740 // input from a buffer.
2742
2743 auto ndata = GetNdata();
2744
2745 TClonesArray* clones = (TClonesArray*) fObject;
2746 if (clones->IsZombie()) {
2747 return -1;
2748 }
2749 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,ndata);
2750
2751 char **arr = (char **)clones->GetObjectRef();
2752 char **end = arr + fNdata;
2753
2754 b.ApplySequenceVecPtr(*fReadActionSequence,arr,end);
2755 } else if (fType == 4) {
2756 // Apply the unattached rules; by definition they do not need any
2757 // input from a buffer.
2759
2760 auto ndata = GetNdata();
2761
2762 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,ndata);
2765
2767 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
2768 } else {
2769 // Apply the unattached rules; by definition they do not need any
2770 // input from a buffer.
2772 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
2773 b.ApplySequence(*fReadActionSequence, fObject);
2774 }
2775 }
2776 } else {
2777 // -- Terminal branch.
2778 if (fBranchCount && (fBranchCount->GetReadEntry() != entry)) {
2779 Int_t nb = fBranchCount->TBranch::GetEntry(entry, getall);
2780 if (nb < 0) {
2781 return nb;
2782 }
2783 nbytes += nb;
2784 }
2785 Int_t nb = TBranch::GetEntry(entry, getall);
2786 if (nb < 0) {
2787 return nb;
2788 }
2789 nbytes += nb;
2790 }
2791
2792 if (R__unlikely(fTree->Debug() > 0)) {
2793 if ((entry >= fTree->GetDebugMin()) && (entry <= fTree->GetDebugMax())) {
2794 Info("GetEntry", "%lld, branch=%s, nbytes=%d", entry, GetName(), nbytes);
2795 }
2796 }
2797 return nbytes;
2798}
2799
2800////////////////////////////////////////////////////////////////////////////////
2801/// Fill expectedClass and expectedType with information on the data type of the
2802/// object/values contained in this branch (and thus the type of pointers
2803/// expected to be passed to Set[Branch]Address
2804/// return 0 in case of success and > 0 in case of failure.
2805
2807{
2808 expectedClass = nullptr;
2809 expectedType = kOther_t;
2810
2812 if ((type == -1) || (fID == -1)) {
2813 expectedClass = fBranchClass;
2814 } else {
2815 // Case of an object data member. Here we allow for the
2816 // variable name to be omitted. Eg, for Event.root with split
2817 // level 1 or above Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
2819 if (element) {
2820 expectedClass = element->GetClassPointer();
2821 if (!expectedClass) {
2822 TDataType* data = gROOT->GetType(element->GetTypeNameBasic());
2823 if (!data) {
2824 Error("GetExpectedType", "Did not find the type number for %s", element->GetTypeNameBasic());
2825 return 1;
2826 } else {
2827 expectedType = (EDataType) data->GetType();
2828 }
2829 }
2830 } else {
2831 Error("GetExpectedType", "Did not find the type for %s",GetName());
2832 return 2;
2833 }
2834 }
2835 return 0;
2836}
2837
2838////////////////////////////////////////////////////////////////////////////////
2839/// Return the 'full' name of the branch. In particular prefix the mother's name
2840/// when it does not end in a trailing dot and thus is not part of the branch name
2842{
2843 TBranchElement* mother = static_cast<TBranchElement*>(GetMother());
2844 if (!mother || mother==this || mother->GetType() == 3 || mother->GetType() == 4) {
2845 // The parent's name is already included in the name for split TClonesArray and STL collections
2846 return fName;
2847 }
2848
2849 return TBranch::GetFullName();
2850}
2851
2852////////////////////////////////////////////////////////////////////////////////
2853/// Return icon name depending on type of branch element.
2854
2856{
2857 if (IsFolder()) {
2858 return "TBranchElement-folder";
2859 } else {
2860 return "TBranchElement-leaf";
2861 }
2862}
2863
2864////////////////////////////////////////////////////////////////////////////////
2865/// Return whether this branch is in a mode where the object are decomposed
2866/// or not (Also known as MakeClass mode).
2867
2869{
2870 return TestBit(kDecomposedObj); // Same as TestBit(kMakeClass)
2871}
2872
2873////////////////////////////////////////////////////////////////////////////////
2874/// Return maximum count value of the branchcount if any.
2875
2877{
2878 if (fBranchCount) {
2879 return fBranchCount->GetMaximum();
2880 }
2881 return fMaximum;
2882}
2883
2884////////////////////////////////////////////////////////////////////////////////
2885/// Return a pointer to our object.
2886
2888{
2890 return fObject;
2891}
2892
2893////////////////////////////////////////////////////////////////////////////////
2894/// Return a pointer to the parent class of the branch element.
2895
2897{
2898 return fParentClass.GetClass();
2899}
2900
2901////////////////////////////////////////////////////////////////////////////////
2902/// Return type name of element in the branch.
2903
2905{
2906 if (fType == 3 || fType == 4) {
2907 return "Int_t";
2908 }
2909 // FIXME: Use symbolic constants here.
2910 if ((fStreamerType < 1) || (fStreamerType > 59)) {
2911 if (fBranchClass.GetClass()) {
2912 if (fID>=0) {
2913 return GetInfoImp()->GetElement(fID)->GetTypeName();
2914 } else {
2915 return fBranchClass.GetClass()->GetName();
2916 }
2917 } else {
2918 return nullptr;
2919 }
2920 }
2921 const char *types[20] = {
2922 "",
2923 "Char_t",
2924 "Short_t",
2925 "Int_t",
2926 "Long_t",
2927 "Float_t",
2928 "Int_t",
2929 "char*",
2930 "Double_t",
2931 "Double32_t",
2932 "",
2933 "UChar_t",
2934 "UShort_t",
2935 "UInt_t",
2936 "ULong_t",
2937 "UInt_t",
2938 "Long64_t",
2939 "ULong64_t",
2940 "Bool_t",
2941 "Float16_t"
2942 };
2943 Int_t itype = fStreamerType % 20;
2944 return types[itype];
2945}
2946
2947////////////////////////////////////////////////////////////////////////////////
2948
2949template Double_t TBranchElement::GetTypedValue(Int_t j, Int_t len, bool subarr) const;
2950template Long64_t TBranchElement::GetTypedValue(Int_t j, Int_t len, bool subarr) const;
2951template LongDouble_t TBranchElement::GetTypedValue(Int_t j, Int_t len, bool subarr) const;
2952
2953template <typename T>
2955{
2956 // -- Returns the branch value.
2957 //
2958 // If the leaf is an array, j is the index in the array.
2959 //
2960 // If leaf is an array inside a TClonesArray, len should be the length
2961 // of the array.
2962 //
2963 // If subarr is true, then len is actually the index within the sub-array.
2964 //
2965
2967
2968 Int_t prID = fID;
2969 char *object = fObject;
2970 if (TestBit(kCache)) {
2971 if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
2972 prID = fID+1;
2973 } else if (fOnfileObject) {
2974 object = fOnfileObject->GetObjectAt(0);
2975 }
2976 }
2977
2978 if (!j && fBranchCount) {
2979 Long64_t entry = fTree->GetReadEntry();
2980 // Since reloading the index, will reset the ClonesArray, let's
2981 // skip the load if we already read this entry.
2982 if (entry != fBranchCount->GetReadEntry()) {
2983 fBranchCount->TBranch::GetEntry(entry);
2984 }
2985 if (fBranchCount2 && entry != fBranchCount2->GetReadEntry()) {
2986 fBranchCount2->TBranch::GetEntry(entry);
2987 }
2988 }
2989
2990 if (TestBit(kDecomposedObj)) {
2991 if (!fAddress) {
2992 return 0;
2993 }
2994 if ((fType == 3) || (fType == 4)) {
2995 // Top-level branch of a TClonesArray.
2996 return fNdata;
2997 } else if ((fType == 31) || (fType == 41)) {
2998 // sub branch of a TClonesArray
2999 Int_t atype = fStreamerType;
3000 if (atype < 20) {
3001 atype += 20;
3002 }
3003 return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
3004 } else if (fType <= 2) {
3005 // branch in split mode
3006 // FIXME: This should probably be < 60 instead!
3007 if ((fStreamerType > 40) && (fStreamerType < 55)) {
3008 Int_t atype = fStreamerType - 20;
3009 return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
3010 } else {
3011 return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
3012 }
3013 }
3014 }
3015
3016 if (object == nullptr)
3017 {
3018 // We have nowhere to read the data from (probably because the data member was
3019 // 'dropped' from the current schema).
3020 return 0;
3021 }
3022
3023 if (fType == 31) {
3024 TClonesArray* clones = (TClonesArray*) object;
3025 if (subarr) {
3026 return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j, len, fOffset);
3027 }
3028 return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j/len, j%len, fOffset);
3029 } else if (fType == 41) {
3032 {
3033 if (subarr)
3034 return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);
3035
3036 return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
3037 }
3038 else
3039 {
3040 if (subarr)
3041 return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);
3042 return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
3043 }
3044 } else {
3045 if (GetInfoImp()) {
3046 return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
3047 }
3048 return 0;
3049 }
3050}
3051
3052////////////////////////////////////////////////////////////////////////////////
3053/// Returns pointer to first data element of this branch.
3054/// Currently used only for members of type character.
3055
3057{
3059
3060 Int_t prID = fID;
3061 char *object = fObject;
3062 if (TestBit(kCache)) {
3063 if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
3064 prID = fID+1;
3065 } else if (fOnfileObject) {
3066 object = fOnfileObject->GetObjectAt(0);
3067 }
3068 }
3069
3070 if (fBranchCount) {
3071 Long64_t entry = fTree->GetReadEntry();
3072 fBranchCount->TBranch::GetEntry(entry);
3073 if (fBranchCount2) fBranchCount2->TBranch::GetEntry(entry);
3074 }
3075 if (TestBit(kDecomposedObj)) {
3076 if (!fAddress) {
3077 return nullptr;
3078 }
3079 if (fType == 3) { //top level branch of a TClonesArray
3080 //return &fNdata;
3081 return nullptr;
3082 } else if (fType == 4) { //top level branch of a TClonesArray
3083 //return &fNdata;
3084 return nullptr;
3085 } else if (fType == 31) { // sub branch of a TClonesArray
3086 //Int_t atype = fStreamerType;
3087 //if (atype < 20) atype += 20;
3088 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3089 return nullptr;
3090 } else if (fType == 41) { // sub branch of a TClonesArray
3091 //Int_t atype = fStreamerType;
3092 //if (atype < 20) atype += 20;
3093 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3094 return nullptr;
3095 } else if (fType <= 2) { // branch in split mode
3096 // FIXME: This should probably be < 60 instead!
3097 if (fStreamerType > 40 && fStreamerType < 55) {
3098 //Int_t atype = fStreamerType - 20;
3099 //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
3100 return nullptr;
3101 } else {
3102 //return GetInfoImp()->GetValue(object, fID, j, -1);
3103 return nullptr;
3104 }
3105 }
3106 }
3107
3108 if (fType == 31) {
3109 return nullptr;
3110 } else if (fType == 41) {
3111 return nullptr;
3112 } else if (prID < 0) {
3113 return object;
3114 } else {
3115 //return GetInfoImp()->GetValue(object,fID,j,-1);
3116 if (!GetInfoImp() || !object) return nullptr;
3117 char **val = (char**)(object+GetInfoImp()->TStreamerInfo::GetElementOffset(prID));
3118 return *val;
3119 }
3120}
3121
3122////////////////////////////////////////////////////////////////////////////////
3123/// Initialize the base class subobjects offsets of our sub-branches and set fOffset if we are a container sub-branch.
3124///
3125/// Note: The offsets are zero for data members so that when
3126/// SetAddress recursively sets their address, they will get the
3127/// same address as their containing class because i/o is based
3128/// on streamer info offsets from the address of the containing
3129/// class.
3130///
3131/// Offsets are non-zero for base-class sub-branches that are
3132/// not the leftmost direct base class. They are laid out in
3133/// memory sequentially and only the leftmost direct base class
3134/// has the same address as the derived class. The streamer
3135/// offsets need to be added to the address of the base class
3136/// subobject which is not the same as the address of the
3137/// derived class for the non-leftmost direct base classes.
3138
3140{
3141 Int_t nbranches = fBranches.GetEntriesFast();
3142
3143 // See https://sft.its.cern.ch/jira/browse/ROOT-8742
3144 // and https://sft.its.cern.ch/jira/browse/ROOT-9253
3145 // As of commit e21b4f1a3b, removing this lock lead to a failure
3146 // in the test testSetAddress[Loop].
3147 // As of commit 4f8b237849, removing this lock does not lead to
3148 // a visible failure in test. This might be due to the underlying
3149 // problem (missing lock or ?) being solved somewhere else or some
3150 // other perturbation reducing the failure rate.
3151 // Having the lock here is not too costly as InitializeOffsets is
3152 // one called once in the lifetime of the TBranch.
3154
3155 if (fID < 0) {
3156 // -- We are a top-level branch. Let's mark whether we need to use MapObject.
3157 if (CanSelfReference(fBranchClass)) {
3158 if (fBranchClass.GetClass()->IsTObject()) {
3160 } else {
3162 }
3163 }
3164 }
3165 if (nbranches) {
3166 // Allocate space for the new sub-branch offsets.
3167 delete[] fBranchOffset;
3168 fBranchOffset = nullptr;
3169 fBranchOffset = new Int_t[nbranches];
3170 // Make sure we can instantiate our class meta info.
3171 if (!fBranchClass.GetClass()) {
3172 Warning("InitializeOffsets", "No branch class set for branch: %s", GetName());
3173 fInitOffsets = true;
3174 return;
3175 }
3176 // Make sure we can instantiate our class streamer info.
3177 if (!GetInfoImp()) {
3178 Warning("InitializeOffsets", "No streamer info available for branch: %s of class: %s", GetName(), fBranchClass.GetClass()->GetName());
3179 fInitOffsets = true;
3180 return;
3181 }
3182
3183 // Get the class we are a member of now (which is the
3184 // type of our containing subobject) and get our offset
3185 // inside of our containing subobject (our local offset).
3186 // Note: branchElem stays zero if we are a top-level branch,
3187 // we have to be careful about this later.
3188 TStreamerElement* branchElem = nullptr;
3189 Int_t localOffset = 0;
3190 TClass* branchClass = fBranchClass.GetClass();
3191 bool renamed = false;
3192 if (fID > -1) {
3193 // -- Branch is *not* a top-level branch.
3194 // Instead of the streamer info class, we want the class of our
3195 // specific element in the streamer info. We could be a data
3196 // member of a base class or a split class, in which case our
3197 // streamer info will be for our containing sub-object, while
3198 // we are actually a different type.
3200 // Note: We tested to make sure the streamer info was available previously.
3201 if (!si->IsCompiled()) {
3202 Warning("InitializeOffsets", "Streamer info for branch: %s has no elements array!", GetName());
3203 fInitOffsets = true;
3204 return;
3205 }
3206 // FIXME: Check that fID is in range.
3207 branchElem = si->GetElement(fID);
3208 if (!branchElem) {
3209 Warning("InitializeOffsets", "Cannot get streamer element for branch: %s!", GetName());
3210 fInitOffsets = true;
3211 return;
3212 } else if (branchElem->TestBit(TStreamerElement::kRepeat)) {
3213 // If we have a repeating streamerElement, use the next
3214 // one as it actually hold the 'real' data member('s offset)
3215 if (si->GetElement(fID+1)) {
3216 branchElem = si->GetElement(fID+1);
3217 }
3218 }
3219 localOffset = branchElem->GetOffset();
3220 branchClass = branchElem->GetClassPointer();
3221 if (localOffset == TStreamerInfo::kMissing) {
3222 fObject = nullptr;
3223 } else {
3224 renamed = branchClass && branchElem->GetNewClass() && (branchClass != branchElem->GetNewClass());
3225 }
3226 } else {
3227 renamed = fTargetClass != fBranchClass;
3228 }
3229 if (!branchClass) {
3230 Error("InitializeOffsets", "Could not find class for branch: %s", GetName());
3231 fInitOffsets = true;
3232 return;
3233 }
3234
3235 //------------------------------------------------------------------------
3236 // Extract the name of the STL branch in case it has been split.
3237 //////////////////////////////////////////////////////////////////////////
3238
3239 TString stlParentName;
3240 bool stlParentNameUpdated = false;
3241 if( fType == 4 )
3242 {
3243 TBranch *br = GetMother()->GetSubBranch( this );
3244 stlParentName = br->GetName();
3245 stlParentName = stlParentName.Strip( TString::kTrailing, '.' );
3246
3247 // We may ourself contain the 'Mother' branch name.
3248 // To avoid code duplication, we delegate the removal
3249 // of the mother's name to the first sub-branch loop.
3250 }
3251
3252 // Loop over our sub-branches and compute their offsets.
3253 for (Int_t subBranchIdx = 0; subBranchIdx < nbranches; ++subBranchIdx) {
3254 bool alternateElement = false;
3255
3256 fBranchOffset[subBranchIdx] = 0;
3257 TBranchElement* subBranch = dynamic_cast<TBranchElement*> (fBranches[subBranchIdx]);
3258 if (subBranch == nullptr) {
3259 // -- Skip sub-branches that are not TBranchElements.
3260 continue;
3261 }
3262
3263 if (renamed) {
3264 if (subBranch->fBranchClass == branchClass) {
3265 if (branchElem) subBranch->SetTargetClass(branchElem->GetNewClass()->GetName());
3266 else subBranch->SetTargetClass(fTargetClass->GetName());
3267 }
3268 }
3269
3270 TVirtualStreamerInfo* sinfo = subBranch->GetInfoImp();
3271 if (!sinfo) {
3272 Warning("InitializeOffsets", "No streamer info for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3273 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3274 continue;
3275 }
3276 if (!sinfo->IsCompiled()) {
3277 Warning("InitializeOffsets", "No elements array for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3278 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3279 continue;
3280 }
3281 // FIXME: Make sure subBranch->fID is in range.
3282 TStreamerElement* subBranchElement = sinfo->GetElement(subBranch->fID);
3283 if (!subBranchElement) {
3284 Warning("InitializeOffsets", "No streamer element for branch: %s subbranch: %s", GetName(), subBranch->GetName());
3285 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3286 continue;
3287 } else if (subBranchElement->TestBit(TStreamerElement::kRepeat)) {
3288 // If we have a repeating streamerElement, use the next
3289 // one as it actually hold the 'real' data member('s offset)
3290 if (sinfo->GetElement(subBranch->fID+1)) {
3291 subBranchElement = sinfo->GetElement(subBranch->fID+1);
3292 }
3293 } else if (subBranchElement->TestBit(TStreamerElement::kCache)) {
3294 // We have a cached item which is not a repeated but we might still
3295 // have some Actions triggered by a rule that affect real
3296 // data member(s).
3297 if (subBranch->fReadActionSequence && subBranch->fReadActionSequence->fActions.size() > 1) {
3298 typedef TStreamerInfoActions::ActionContainer_t::iterator iterator;
3299 iterator end = subBranch->fReadActionSequence->fActions.end();
3300 for(iterator iter = subBranch->fReadActionSequence->fActions.begin();
3301 iter != end; ++iter) {
3302 TStreamerInfoActions::TConfiguration *config = iter->fConfiguration;
3303 UInt_t id = config->fElemId;
3305 if (e && !e->TestBit(TStreamerElement::kCache)) {
3306 subBranchElement = e;
3307 alternateElement = true;
3308 break;
3309 }
3310 }
3311 }
3312 }
3313
3314 localOffset = subBranchElement->GetOffset();
3315 if (localOffset == TStreamerInfo::kMissing) {
3316 subBranch->fObject = nullptr;
3317 }
3318 {
3319 Int_t streamerType = subBranchElement->GetType();
3320 if (streamerType > TStreamerInfo::kObject
3321 && subBranch->GetListOfBranches()->GetEntriesFast()==0
3322 && CanSelfReference(subBranchElement->GetClass()))
3323 {
3324 subBranch->SetBit(kBranchAny);
3325 } else {
3326 subBranch->ResetBit(kBranchAny);
3327 }
3328 }
3329
3330 if (subBranchElement->GetNewType()<0) {
3331 subBranch->ResetBit(kBranchAny);
3332 subBranch->ResetBit(kBranchObject);
3333 }
3334
3335 // Note: This call is expensive, do it only once.
3336 TBranch* mother = GetMother();
3337 if (!mother) {
3338 Warning("InitializeOffsets", "Branch '%s' has no mother!", GetName());
3339 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3340 continue;
3341 }
3342 TString motherName(mother->GetName());
3343 bool motherDot = false;
3344 if (motherName.Length() && strchr(motherName.Data(), '.')) {
3345 motherDot = true;
3346 }
3347 bool motherDotAtEnd = false;
3348 if (motherName.Length() && (motherName[motherName.Length()-1] == '.')) {
3349 motherDotAtEnd = true;
3350 }
3351
3352 bool isBaseSubBranch = false;
3353 if ((subBranch->fType == 1) || (subBranchElement && subBranchElement->IsBase())) {
3354 // -- Base class sub-branch (1).
3355 //
3356 // Note: Our type will not be 1, even though we are
3357 // a base class branch, if we are not split (see the
3358 // constructor), or if we are an STL container master
3359 // branch and a base class branch at the same time
3360 // or an std::string.
3361 isBaseSubBranch = true;
3362 }
3363
3364 bool isContDataMember = false;
3365 if ((subBranch->fType == 31) || (subBranch->fType == 41)) {
3366 // -- Container data member sub-branch (31 or 41).
3367 isContDataMember = true;
3368 }
3369
3370 // I am either a data member sub-branch (0), or a base class
3371 // sub-branch (1), or TClonesArray master sub-branch (3),
3372 // or an STL container master sub-branch (4), or TClonesArray
3373 // data member sub-branch (31), or an STL container data member
3374 // sub-branch (41).
3375 //
3376 // My parent branch is either a top-level branch ((0), fID==(-2,-1)),
3377 // or a base class sub-branch (1), or a split-class branch (2),
3378 // or a TClonesArray master branch (3), or an STL container
3379 // master branch (4).
3380 //
3381
3382 //
3383 // We need to extract from our name the name
3384 // of the data member which contains us, so
3385 // that we may then do a by-name lookup in the
3386 // dictionary meta info of our parent class to
3387 // get our offset in our parent class.
3388 //
3389
3390 // Get our name.
3391 TString dataName(subBranch->GetName());
3392 if (motherDotAtEnd) {
3393 // -- Remove the top-level branch name from our name.
3394 dataName.Remove(0, motherName.Length());
3395 // stlParentNameUpdated is false the first time in this loop.
3396 if (!stlParentNameUpdated && stlParentName.Length()) {
3397 stlParentName.Remove(0, motherName.Length());
3398 stlParentNameUpdated = true;
3399 }
3400 } else if (motherDot) {
3401 // -- Remove the top-level branch name from our name, folder case.
3402 //
3403 // Note: We are in the case where our mother was created
3404 // by the branch constructor which takes a folder
3405 // as an argument. The mother branch has internal
3406 // dots in its name to represent the folder hierarchy.
3407 // The TTree::Bronch() routine has handled us as a
3408 // special case, we must compensate.
3409 if ((fID < 0) && (subBranchElement->IsA() == TStreamerBase::Class())) {
3410 // -- Our name is the mother name, remove it.
3411 // Note: The test is our parent is a top-level branch
3412 // and our streamer is the base class streamer,
3413 // this matches the exact test in TTree::Bronch().
3414 if (dataName.Length() == motherName.Length()) {
3415 dataName.Remove(0, motherName.Length());
3416 // stlParentNameUpdated is false the first time in this loop.
3417 if (!stlParentNameUpdated && stlParentName.Length()) {
3418 stlParentName.Remove(0, motherName.Length());
3419 }
3420 }
3421 } else {
3422 // -- Remove the mother name and the dot.
3423 if (dataName.Length() > motherName.Length()) {
3424 dataName.Remove(0, motherName.Length() + 1);
3425 if (!stlParentNameUpdated && stlParentName.Length()) {
3426 stlParentName.Remove(0, motherName.Length());
3427 }
3428 }
3429 }
3430 }
3431 stlParentNameUpdated = true;
3432 if (isBaseSubBranch) {
3433 // -- Remove the base class name suffix from our name.
3434 // Note: The pattern is the name of the base class.
3435 TString pattern(subBranchElement->GetName());
3436 if (pattern.Length() <= dataName.Length()) {
3437 if (!strcmp(dataName.Data() + (dataName.Length() - pattern.Length()), pattern.Data())) {
3438 // The branch name contains the name of the base class in it.
3439 // This name is not reproduced in the sub-branches, so we need to
3440 // remove it.
3441 dataName.Remove(dataName.Length() - pattern.Length());
3442 }
3443 }
3444 // Remove any leading dot.
3445 if (dataName.Length()) {
3446 if (dataName[0] == '.') {
3447 dataName.Remove(0, 1);
3448 }
3449 }
3450 // Note: We intentionally leave any trailing dot
3451 // in our modified name here.
3452 }
3453
3454 // Get our parent branch's name.
3455 TString parentName(GetName());
3456 if (motherDotAtEnd) {
3457 // -- Remove the top-level branch name from our parent's name.
3458 parentName.Remove(0, motherName.Length());
3459 } else if (motherDot) {
3460 // -- Remove the top-level branch name from our parent's name, folder case.
3461 //
3462 // Note: We are in the case where our mother was created
3463 // by the branch constructor which takes a folder
3464 // as an argument. The mother branch has internal
3465 // dots in its name to represent the folder hierarchy.
3466 // The TTree::Bronch() routine has handled us as a
3467 // special case, we must compensate.
3468 if ((fID > -1) && (mother == mother->GetSubBranch(this)) && (branchElem->IsA() == TStreamerBase::Class())) {
3469 // -- Our parent's name is the mother name, remove it.
3470 // Note: The test is our parent's parent is a top-level branch
3471 // and our parent's streamer is the base class streamer,
3472 // this matches the exact test in TTree::Bronch().
3473 if (parentName.Length() == motherName.Length()) {
3474 parentName.Remove(0, motherName.Length());
3475 }
3476 } else {
3477 // -- Remove the mother name and the dot.
3478 if (parentName.Length() > motherName.Length()) {
3479 parentName.Remove(0, motherName.Length() + 1);
3480 }
3481 }
3482 }
3483 // FIXME: Do we need to use the other tests for a base class here?
3484 if (fType == 1) {
3485 // -- Our parent is a base class sub-branch, remove the base class name suffix from its name.
3486 if (mother != mother->GetSubBranch(this)) {
3487 // -- My parent's parent is not a top-level branch.
3488 // Remove the base class name suffix from the parent name.
3489 // Note: The pattern is the name of the base class.
3490 // coverity[var_deref_model] branchElem is non zero here since fType==1 and thus fID > -1
3491 TString pattern(branchElem->GetName());
3492 if (pattern.Length() <= parentName.Length()) {
3493 if (!strcmp(parentName.Data() + (parentName.Length() - pattern.Length()), pattern.Data())) {
3494 // The branch name contains the name of the base class in it.
3495 // This name is not reproduced in the sub-branches, so we need to
3496 // remove it.
3497 parentName.Remove(parentName.Length() - pattern.Length());
3498 }
3499 }
3500 }
3501 // Note: We intentionally leave any trailing dots
3502 // in the modified parent name here.
3503 }
3504
3505 // Remove the parent branch name part from our name,
3506 // but only if the parent branch is not a top-level branch.
3507 // FIXME: We should not assume parent name does not have length 0.
3508 if (fID > -1) {
3509 RemovePrefix(dataName, parentName);
3510 }
3511
3512 // Remove any leading dot.
3513 if (dataName.Length()) {
3514 if (dataName[0] == '.') {
3515 dataName.Remove(0, 1);
3516 }
3517 }
3518
3519 // Remove any trailing dot.
3520 if (dataName.Length()) {
3521 if (dataName[dataName.Length()-1] == '.') {
3522 dataName.Remove(dataName.Length() - 1, 1);
3523 }
3524 }
3525
3526 //
3527 // Now that we have our data member name, find our offset
3528 // in our parent class.
3529 //
3530 // Note: Our data member name can have many dots in it
3531 // if branches were elided between our parent branch
3532 // and us by Unroll().
3533 //
3534 // FIXME: This may not work if our member name is ambiguous.
3535 //
3536
3537 Int_t offset = 0;
3538 if (dataName.Length()) {
3539 // -- We have our data member name, do a lookup in the dictionary meta info of our parent class.
3540 // Get our parent class.
3541 TClass* pClass = nullptr;
3542 // First check whether this sub-branch is part of the 'cache' (because the data member it
3543 // represents is no longer in the current class layout.
3544 TStreamerInfo *subInfo = subBranch->GetInfoImp();
3545 //if (subInfo && subBranch->TestBit(kCache)) { // subInfo->GetElements()->At(subBranch->GetID())->TestBit(TStreamerElement::kCache)) {
3546 if (subBranchElement->TestBit(TStreamerElement::kCache)) {
3547 pClass = ((TStreamerElement*)subInfo->GetElements()->At(0))->GetClassPointer();
3548 }
3549 // FIXME: Do we need the other base class tests here?
3550 if (!pClass) {
3551 if (fType == 1) {
3552 // -- Parent branch is a base class branch.
3553 // FIXME: Is using branchElem here the right thing?
3554 pClass = branchElem->GetClassPointer();
3555 if (pClass->Property() & kIsAbstract) {
3556 // the class is abstract, let see if the
3557
3559 if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
3560 // Our parent's class is emulated and we represent an abstract class.
3561 // and the target class has not been set explicitly.
3562 TString target = pClass->GetName();
3563 target += "@@emulated";
3564
3565 pClass = TClass::GetClass(target);
3566 }
3567 }
3568 } else {
3569 // -- Parent branch is *not* a base class branch.
3570 // FIXME: This sometimes returns a null pointer.
3571 pClass = subBranch->GetParentClass();
3572 }
3573 }
3574 if (!pClass) {
3575 // -- No parent class, fix it.
3576 // FIXME: This is probably wrong!
3577 // Assume parent class is our parent branch's clones class or value class.
3578 if (GetClonesName() && strlen(GetClonesName())) {
3579 pClass = fClonesClass;
3580 if (!pClass) {
3581 Warning("InitializeOffsets", "subBranch: '%s' has no parent class, and cannot get class for clones class: '%s'!", subBranch->GetName(), GetClonesName());
3582 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3583 continue;
3584 }
3585 Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
3586 }
3589 Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass ? pClass->GetName() : "unknown class");
3590 }
3591 if (!pClass) {
3592 // -- Still no parent class, assume our parent class is our parent branch's class.
3593 // FIXME: This is probably wrong!
3594 pClass = branchClass;
3595 // FIXME: Enable this warning!
3596 //Warning("InitializeOffsets", "subBranch: '%s' has no parent class! Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
3597 }
3598 }
3599 if (renamed && pClass) {
3600 if (pClass == branchClass) {
3601 pClass = branchElem->GetNewClass();
3602 } else if (fCollProxy && pClass == branchClass->GetCollectionProxy()->GetValueClass()) {
3603 pClass = fCollProxy->GetValueClass();
3604 }
3605 }
3606
3607 //------------------------------------------------------------------
3608 // If we have the are the sub-branch of the TBranchSTL, we need
3609 // to remove it's name to get the correct real data offsets
3610 ////////////////////////////////////////////////////////////////////
3611
3612 const bool isToplevelCollection = (this == GetMother() && (fType == 3 || fType == 4));
3613 if( stlParentName.Length() && (dynamic_cast<TBranchSTL*>(fParent) || isToplevelCollection))
3614 {
3615 if( !strncmp( stlParentName.Data(), dataName.Data(), stlParentName.Length()-1 )
3616 && dataName[ stlParentName.Length() ] == '.' )
3617 dataName.Remove( 0, stlParentName.Length()+1 );
3618 }
3619
3620 // Find our offset in our parent class using
3621 // a lookup by name in the dictionary meta info
3622 // for our parent class.
3623
3624 if (alternateElement) {
3625 Ssiz_t dotpos = dataName.Last('.');
3626 Ssiz_t endpos = dataName.Length();
3627 if (dotpos != kNPOS) ++dotpos; else dotpos = 0;
3628 dataName.Replace(dotpos,endpos-dotpos,subBranchElement->GetFullName());
3629 }
3630 TRealData* rd = pClass->GetRealData(dataName);
3631 if (rd && (!rd->TestBit(TRealData::kTransient) || alternateElement)) {
3632 // -- Data member exists in the dictionary meta info, get the offset.
3633 // If we are using an alternateElement, it is the target of a rule
3634 // and might be indeed transient.
3635 offset = rd->GetThisOffset();
3636 } else if (subBranchElement->TestBit(TStreamerElement::kWholeObject)) {
3637 // We are a rule with no specific target, it applies to the whole
3638 // object, let's set the offset to zero
3639 offset = 0;
3640 } else {
3641 // -- No dictionary meta info for this data member, it must no
3642 // longer exist
3643 if (fEntries == 0) {
3644 // ... unless we creating the branch in which case
3645 // we have an internal error.
3646 if (pClass->GetListOfRealData()->GetEntries() == 0) {
3647 // We are probably missing the ShowMember, let's
3648 // just issue an error.
3649 Error("InitializeOffsets",
3650 "Could not find the real data member '%s' when constructing the branch '%s' [Likely missing ShowMember].",
3651 dataName.Data(),GetName());
3652 } else if (subInfo && subInfo->GetClassVersion()!=subInfo->GetClass()->GetClassVersion()) {
3653 // In the case where we are cloning a TTree that was created with an older version of the layout, we may not
3654 // able to find all the members
3655 Info("InitializeOffsets",
3656 "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'. ",
3657 dataName.Data(),GetName());
3658 } else {
3659 // Something really bad happen.
3660 Fatal("InitializeOffsets",
3661 "Could not find the real data member '%s' when constructing the branch '%s' [Likely an internal error, please report to the developers].",
3662 dataName.Data(),GetName());
3663 }
3664 }
3665 localOffset = TStreamerInfo::kMissing;
3666 }
3667 } else {
3668 // -- We have no data member name, ok for a base class, not good otherwise.
3669 if (isBaseSubBranch) {
3670 // I am a direct base class of my parent class, my local offset is enough.
3671 } else {
3672 Warning("InitializeOffsets", "Could not find the data member name for branch '%s' with parent branch '%s', assuming offset is zero!", subBranch->GetName(), GetName());
3673 }
3674 }
3675
3676 //
3677 // Ok, do final calculations for fOffset and fBranchOffset.
3678 //
3679
3680 if (isContDataMember) {
3681 // -- Container data members set fOffset instead of fBranchOffset.
3682 // The fOffset is what should be added to the start of the entry
3683 // in the collection (i.e., its current absolute address) to find
3684 // the beginning of the data member described by the current branch.
3685 //
3686 // Compensate for the i/o routines adding our local offset later.
3687 if (subBranch->fObject == nullptr && localOffset == TStreamerInfo::kMissing) {
3688 subBranch->SetMissing();
3689 // We stil need to set fBranchOffset in the case of a missing
3690 // element so that SetAddress is (as expected) not called
3691 // recursively in this case.
3692 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3693 } else {
3694 if (isBaseSubBranch) {
3695 // The value of 'offset' for a base class does not include its
3696 // 'localOffset'.
3697 subBranch->SetOffset(offset);
3698 } else {
3699 // The value of 'offset' for a regular data member does include its
3700 // 'localOffset', we need to remove it explicitly.
3701 subBranch->SetOffset(offset - localOffset);
3702 }
3703 }
3704 } else {
3705 // -- Set fBranchOffset for sub-branch.
3706 Int_t isSplit = 0 != subBranch->GetListOfBranches()->GetEntriesFast();
3707 if (subBranch->fObject == nullptr && localOffset == TStreamerInfo::kMissing) {
3708 // The branch is missing
3709 fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
3710
3711 } else if (isSplit) {
3712 if (isBaseSubBranch) {
3713 // We are split, so we need to add in our local offset
3714 // to get our absolute address for our children.
3715 fBranchOffset[subBranchIdx] = offset + localOffset;
3716 } else {
3717 // We are split so our offset will never be
3718 // used in an i/o, so we do not have to subtract
3719 // off our local offset like below.
3720 fBranchOffset[subBranchIdx] = offset;
3721 }
3722 } else {
3723 if (isBaseSubBranch) {
3724 // We are not split, so our local offset will be
3725 // added later by the i/o routines.
3726 fBranchOffset[subBranchIdx] = offset;
3727 } else {
3728 // Compensate for the fact that the i/o routines
3729 // are going to add my local offset later.
3730 fBranchOffset[subBranchIdx] = offset - localOffset;
3731 }
3732 }
3733 }
3734 }
3735 }
3736 else {
3737 if (fID > -1) {
3738 // Branch is *not* a top-level branch.
3739 // Let's check if the target member is still present in memory
3741 fObject = nullptr;
3742 }
3743 }
3744 }
3745 const bool isSplitNode = (fType == 2 || fType == 1 || (fType == 0 && fID == -2)) && !fBranches.IsEmpty();
3746 if (fReadActionSequence && isSplitNode) {
3747 TBranchElement *parent = dynamic_cast<TBranchElement*>(GetMother()->GetSubBranch(this));
3748 auto index = parent->fBranches.IndexOf(this);
3749 if (index >= 0) {
3751 }
3752 }
3753
3754 fInitOffsets = true;
3755}
3756
3757////////////////////////////////////////////////////////////////////////////////
3758/// Return true if more than one leaf, false otherwise.
3759
3761{
3762 Int_t nbranches = fBranches.GetEntriesFast();
3763 if (nbranches >= 1) {
3764 return true;
3765 }
3766 TList* browsables = const_cast<TBranchElement*>(this)->GetBrowsables();
3767 return browsables && browsables->GetSize();
3768}
3769
3770////////////////////////////////////////////////////////////////////////////////
3771/// Detect a collection written using a zero pointer in old versions of root.
3772/// In versions of ROOT older than 4.00/03, if a collection (TClonesArray
3773/// or STL container) was split but the pointer to the collection was zeroed
3774/// out, nothing was saved. Hence there is no __easy__ way to detect the
3775/// case. In newer versions, a zero is written so that a 'missing' collection
3776/// appears to be an empty collection.
3777
3779{
3780 bool ismissing = false;
3782 if (basket && fTree) {
3783 Long64_t entry = fTree->GetReadEntry();
3785 Long64_t last;
3786 if (fReadBasket == fWriteBasket) {
3787 last = fEntryNumber - 1;
3788 } else {
3789 last = fBasketEntry[fReadBasket+1] - 1;
3790 }
3791 Int_t* entryOffset = basket->GetEntryOffset();
3792 Int_t bufbegin;
3793 Int_t bufnext;
3794 if (entryOffset) {
3795 bufbegin = entryOffset[entry-first];
3796
3797 if (entry < last) {
3798 bufnext = entryOffset[entry+1-first];
3799 } else {
3800 bufnext = basket->GetLast();
3801 }
3802 if (bufnext == bufbegin) {
3803 ismissing = true;
3804 } else {
3805 // fixed length buffer so this is not the case here.
3806 if (basket->GetNevBufSize() == 0) {
3807 ismissing = true;
3808 }
3809 }
3810 }
3811 }
3812 return ismissing;
3813}
3814
3815////////////////////////////////////////////////////////////////////////////////
3816/// Print branch parameters.
3817
3818static void PrintElements(const TStreamerInfo *info, const TStreamerInfoActions::TIDs &ids)
3819{
3820 for(auto &cursor : ids) {
3821 auto id = cursor.fElemID;
3822 if (id >= 0) {
3823 auto el = info->GetElement(id);
3824 if (el)
3825 el->ls();
3826 else {
3827 Error("TBranchElement::Print", "Element for id #%d not found in StreamerInfo for %s",
3828 id, info->GetName());
3829 info->ls();
3830 }
3831 } else if (cursor.fNestedIDs) {
3832 Printf(" Within subobject of type %s offset = %d", cursor.fNestedIDs->fInfo->GetName(), cursor.fNestedIDs->fOffset);
3833 PrintElements(cursor.fNestedIDs->fInfo, cursor.fNestedIDs->fIDs);
3834 }
3835 }
3836}
3837
3839{
3840 Int_t nbranches = fBranches.GetEntriesFast();
3841 if (strncmp(option,"debugAddress",strlen("debugAddress"))==0) {
3842 if (strlen(option)==strlen("debugAddress")) {
3843 Printf("%-24s %-16s %2s %4s %-16s %-16s %8s %8s %s %s\n",
3844 "Branch Name", "Streamer Class", "ID", "Type", "Class", "Parent", "pOffset", "fOffset", "fObject", "fOnfileObject");
3845 }
3846 if (strlen(GetName())>24) Printf("%-24s\n%-24s ", GetName(),"");
3847 else Printf("%-24s ", GetName());
3848
3849 TBranchElement *parent = dynamic_cast<TBranchElement*>(GetMother()->GetSubBranch(this));
3850 Int_t ind = parent ? parent->GetListOfBranches()->IndexOf(this) : -1;
3851 TVirtualStreamerInfo *info = ((TBranchElement*)this)->GetInfoImp();
3852
3853 Printf("%-16s %2d %4d %-16s %-16s %8x %8x %p %p%s\n",
3854 info ? info->GetName() : "StreamerInfo unavailable", GetID(), GetType(),
3856 (fBranchOffset&&parent && ind>=0) ? parent->fBranchOffset[ind] : 0,
3857 GetOffset(), GetObject(), fOnfileObject, TestBit(kOwnOnfileObj) ? " (owned)" : "");
3858 for (Int_t i = 0; i < nbranches; ++i) {
3859 TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
3860 subbranch->Print("debugAddressSub");
3861 }
3862 return;
3863 }
3864 if (strncmp(option,"debugInfo",strlen("debugInfo"))==0) {
3865 Printf("Branch %s uses:",GetName());
3866 if (fID>=0) {
3867 // GetInfoImp()->GetElement(fID)->ls();
3868 // for(UInt_t i=0; i< fIDs.size(); ++i) {
3869 // GetInfoImp()->GetElement(fIDs[i])->ls();
3870 // }
3871 TStreamerInfo *localInfo = GetInfoImp();
3872 if (fType == 3 || fType == 4) {
3873 // Search for the correct version.
3875 }
3876 Printf(" With elements:");
3877 if (fType != 3 && fType != 4)
3878 localInfo->GetElement(fID)->ls();
3879 PrintElements(localInfo, fNewIDs);
3880 Printf(" with read actions:");
3882 Printf(" with write actions:");
3884 } else if (!fNewIDs.empty() && GetInfoImp()) {
3885 TStreamerInfo *localInfo = GetInfoImp();
3886 if (fType == 3 || fType == 4) {
3887 // Search for the correct version.
3889 }
3890 PrintElements(localInfo, fNewIDs);
3891 Printf(" with read actions:");
3893 Printf(" with write actions:");
3895 }
3896 TString suboption = "debugInfoSub";
3897 suboption += (option+strlen("debugInfo"));
3898 for (Int_t i = 0; i < nbranches; ++i) {
3899 TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
3900 subbranch->Print(suboption);
3901 }
3902 Printf(" ");
3903 return;
3904 }
3905 if (nbranches) {
3906 if (fID == -2) {
3907 if (strcmp(GetName(),GetTitle()) == 0) {
3908 Printf("*Branch :%-66s *",GetName());
3909 } else {
3910 Printf("*Branch :%-9s : %-54s *",GetName(),GetTitle());
3911 }
3912 Printf("*Entries : %8d : BranchElement (see below) *",Int_t(fEntries));
3913 Printf("*............................................................................*");
3914 }
3915 if (fType >= 2) {
3917 }
3918 for (Int_t i=0;i<nbranches;i++) {
3919 TBranch *branch = (TBranch*)fBranches.At(i);
3920 branch->Print(option);
3921 }
3922 } else {
3924 }
3925}
3926
3927////////////////////////////////////////////////////////////////////////////////
3928/// Prints values of leaves.
3929
3931{
3933
3934 TStreamerInfo *info = GetInfoImp();
3935 Int_t prID = fID;
3936 char *object = fObject;
3937 if (TestBit(kCache)) {
3939 prID = fID+1;
3940 } else if (fOnfileObject) {
3941 object = fOnfileObject->GetObjectAt(0);
3942 }
3943 }
3944
3945 if (TestBit(kDecomposedObj)) {
3946 if (!fAddress) {
3947 return;
3948 }
3949 if (fType == 3 || fType == 4) {
3950 // TClonesArray or STL container top-level branch.
3951 printf(" %-15s = %d\n", GetName(), fNdata);
3952 return;
3953 } else if (fType == 31 || fType == 41) {
3954 // TClonesArray or STL container sub-branch.
3955 Int_t n = TMath::Min(10, fNdata);
3958 // TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kChar is
3959 // printed as a string and could print weird characters.
3960 // So we print an unsigned char instead (not perfect, but better).
3962 }
3963 if (atype > 54) {
3964 // FIXME: More logic required here (like in ReadLeaves)
3965 printf(" %-15s = %d\n", GetName(), fNdata);
3966 return;
3967 }
3968 if (fStreamerType > 20) {
3969 atype -= 20;
3971 n = n * leaf->GetLenStatic();
3972 }
3973 if (GetInfoImp()) {
3974 GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
3975 }
3976 return;
3977 } else if (fType <= 2) {
3978 // Branch in split mode.
3979 // FIXME: This should probably be < 60 instead.
3980 if ((fStreamerType > 40) && (fStreamerType < 55)) {
3981 Int_t atype = fStreamerType - 20;
3982 TBranchElement* counterElement = (TBranchElement*) fBranchCount;
3983 Int_t n = (Int_t) counterElement->GetValue(0, 0);
3984 if (GetInfoImp()) {
3985 GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
3986 }
3987 } else {
3988 if (GetInfoImp()) {
3989 GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
3990 }
3991 }
3992 return;
3993 }
3994 } else if (fType == 3) {
3995 printf(" %-15s = %d\n", GetName(), fNdata);
3996 } else if (fType == 31) {
3997 TClonesArray* clones = (TClonesArray*) object;
3998 if (GetInfoImp()) {
3999 GetInfoImp()->PrintValueClones(GetName(), clones, prID, fOffset, lenmax);
4000 }
4001 } else if (fType == 41) {
4003 if (GetInfoImp()) {
4004 GetInfoImp()->PrintValueSTL(GetName(), ((TBranchElement*) this)->GetCollectionProxy(), prID, fOffset, lenmax);
4005 }
4006 } else {
4007 if (GetInfoImp()) {
4008 GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
4009 }
4010 }
4011}
4012
4013////////////////////////////////////////////////////////////////////////////////
4014/// Unconfiguration Read Leave function.
4015
4017{
4018 Fatal("ReadLeaves","The ReadLeaves function has not been configured for %s",GetName());
4019}
4020
4021////////////////////////////////////////////////////////////////////////////////
4022/// Read leaves into i/o buffers for this branch.
4023/// For the case where the branch is set in MakeClass mode (decomposed object).
4024
4026{
4028
4029 if (fType == 3 || fType == 4) {
4030 // Top level branch of a TClonesArray.
4031 Int_t *n = (Int_t*) fAddress;
4032 b >> n[0];
4033 if ((n[0] < 0) || (n[0] > fMaximum)) {
4034 if (IsMissingCollection()) {
4035 n[0] = 0;
4036 b.SetBufferOffset(b.Length() - sizeof(n));
4037 } else {
4038 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());
4039 n[0] = 0;
4040 }
4041 }
4042 fNdata = n[0];
4043 if (fType == 4) {
4044 Int_t nbranches = fBranches.GetEntriesFast();
4045 switch(fSTLtype) {
4046 case ROOT::kSTLset:
4047 case ROOT::kSTLmultiset:
4048 case ROOT::kSTLmap:
4049 case ROOT::kSTLmultimap:
4050 for (Int_t i=0; i<nbranches; i++) {
4051 TBranch *branch = (TBranch*)fBranches[i];
4052 Int_t nb = branch->GetEntry(GetReadEntry(), 1);
4053 if (nb < 0) {
4054 break;
4055 }
4056 }
4057 break;
4058 default:
4059 break;
4060 }
4061 }
4062 return;
4063 } else if (fType == 31 || fType == 41) { // sub branch of a TClonesArray
4065 Int_t atype = fStreamerType;
4066 // FIXME: This should probably be > 59 instead.
4067 if (atype > 54) return;
4068 if (!fAddress) {
4069 return;
4070 }
4071 Int_t n = fNdata;
4072 if (atype>40) {
4073 atype -= 40;
4074 if (!fBranchCount2) return;
4075 const char *len_where = (char*)fBranchCount2->fAddress;
4076 if (!len_where) return;
4077 Int_t len_atype = fBranchCount2->fStreamerType;
4078 Int_t length;
4079 Int_t k;
4080 Char_t isArray;
4081 for( k=0; k<n; k++) {
4082 char **where = &(((char**)fAddress)[k]);
4083 delete [] *where;
4084 *where = nullptr;
4085 switch(len_atype) {
4086 case 1: {length = ((Char_t*) len_where)[k]; break;}
4087 case 2: {length = ((Short_t*) len_where)[k]; break;}
4088 case 3: {length = ((Int_t*) len_where)[k]; break;}
4089 case 4: {length = ((Long_t*) len_where)[k]; break;}
4090 //case 5: {length = ((Float_t*) len_where)[k]; break;}
4091 case 6: {length = ((Int_t*) len_where)[k]; break;}
4092 //case 8: {length = ((Double_t*)len_where)[k]; break;}
4093 case 11: {length = ((UChar_t*) len_where)[k]; break;}
4094 case 12: {length = ((UShort_t*) len_where)[k]; break;}
4095 case 13: {length = ((UInt_t*) len_where)[k]; break;}
4096 case 14: {length = ((ULong_t*) len_where)[k]; break;}
4097 case 15: {length = ((UInt_t*) len_where)[k]; break;}
4098 case 16: {length = ((Long64_t*) len_where)[k]; break;}
4099 case 17: {length = ((ULong64_t*)len_where)[k]; break;}
4100 case 18: {length = ((bool*) len_where)[k]; break;}
4101 default: continue;
4102 }
4103 b >> isArray;
4104 if (length <= 0) continue;
4105 if (isArray == 0) continue;
4106 switch (atype) {
4107 case 1: {*where=new char[sizeof(Char_t)*length]; b.ReadFastArray((Char_t*) *where, length); break;}
4108 case 2: {*where=new char[sizeof(Short_t)*length]; b.ReadFastArray((Short_t*) *where, length); break;}
4109 case 3: {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*) *where, length); break;}
4110 case 4: {*where=new char[sizeof(Long_t)*length]; b.ReadFastArray((Long_t*) *where, length); break;}
4111 case 5: {*where=new char[sizeof(Float_t)*length]; b.ReadFastArray((Float_t*) *where, length); break;}
4112 case 6: {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*) *where, length); break;}
4113 case 8: {*where=new char[sizeof(Double_t)*length]; b.ReadFastArray((Double_t*)*where, length); break;}
4114 case 11: {*where=new char[sizeof(UChar_t)*length]; b.ReadFastArray((UChar_t*) *where, length); break;}
4115 case 12: {*where=new char[sizeof(UShort_t)*length]; b.ReadFastArray((UShort_t*)*where, length); break;}
4116 case 13: {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*) *where, length); break;}
4117 case 14: {*where=new char[sizeof(ULong_t)*length]; b.ReadFastArray((ULong_t*) *where, length); break;}
4118 case 15: {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*) *where, length); break;}
4119 case 16: {*where=new char[sizeof(Long64_t)*length]; b.ReadFastArray((Long64_t*) *where, length); break;}
4120 case 17: {*where=new char[sizeof(ULong64_t)*length]; b.ReadFastArray((ULong64_t*)*where, length); break;}
4121 case 18: {*where=new char[sizeof(bool)*length]; b.ReadFastArray((bool*) *where, length); break;}
4122 }
4123 }
4124 return;
4125 }
4126 if (atype > 20) {
4127 atype -= 20;
4129 n *= leaf->GetLenStatic();
4130 }
4131 switch (atype) {
4132 case 1: {b.ReadFastArray((Char_t*) fAddress, n); break;}
4133 case 2: {b.ReadFastArray((Short_t*) fAddress, n); break;}
4134 case 3: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4135 case 4: {b.ReadFastArray((Long_t*) fAddress, n); break;}
4136 case 5: {b.ReadFastArray((Float_t*) fAddress, n); break;}
4137 case 6: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4138 case 8: {b.ReadFastArray((Double_t*)fAddress, n); break;}
4139 case 11: {b.ReadFastArray((UChar_t*) fAddress, n); break;}
4140 case 12: {b.ReadFastArray((UShort_t*)fAddress, n); break;}
4141 case 13: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4142 case 14: {b.ReadFastArray((ULong_t*) fAddress, n); break;}
4143 case 15: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4144 case 16: {b.ReadFastArray((Long64_t*)fAddress, n); break;}
4145 case 17: {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
4146 case 18: {b.ReadFastArray((bool*) fAddress, n); break;}
4147 case 9: {
4150 Double_t *xx = (Double_t*) fAddress;
4151 for (Int_t ii=0;ii<n;ii++) {
4152 b.ReadDouble32(&(xx[ii]),se);
4153 }
4154 break;
4155 }
4156 case 19: {
4159 Float_t *xx = (Float_t*) fAddress;
4160 for (Int_t ii=0;ii<n;ii++) {
4161 b.ReadFloat16(&(xx[ii]),se);
4162 }
4163 break;
4164 }
4165 }
4166 return;
4167 } else if (fType <= 2) { // branch in split mode
4168 // FIXME: This should probably be < 60 instead.
4169 if (fStreamerType > 40 && fStreamerType < 55) {
4170 Int_t atype = fStreamerType - 40;
4171 Int_t n;
4172 if (fBranchCount==nullptr) {
4173 // Missing fBranchCount. let's attempts to recover.
4174
4175 TString countname( GetName() );
4176 Ssiz_t dot = countname.Last('.');
4177 if (dot>=0) {
4178 countname.Remove(dot+1);
4179 } else {
4180 countname = "";
4181 }
4182 TString counter( GetTitle() );
4183 Ssiz_t loc = counter.Last('[');
4184 if (loc>=0) {
4185 counter.Remove(0,loc+1);
4186 }
4187 loc = counter.Last(']');
4188 if (loc>=0) {
4189 counter.Remove(loc);
4190 }
4191 countname += counter;
4193 }
4194 if (fBranchCount) {
4195 n = (Int_t)fBranchCount->GetValue(0,0);
4196 } else {
4197 Warning("ReadLeaves","Missing fBranchCount for %s. Data will not be read correctly by the MakeClass mode.",GetName());
4198 n = 0;
4199 }
4200 fNdata = n;
4201 Char_t isArray;
4202 b >> isArray;
4203 switch (atype) {
4204 case 1: {b.ReadFastArray((Char_t*) fAddress, n); break;}
4205 case 2: {b.ReadFastArray((Short_t*) fAddress, n); break;}
4206 case 3: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4207 case 4: {b.ReadFastArray((Long_t*) fAddress, n); break;}
4208 case 5: {b.ReadFastArray((Float_t*) fAddress, n); break;}
4209 case 6: {b.ReadFastArray((Int_t*) fAddress, n); break;}
4210 case 8: {b.ReadFastArray((Double_t*)fAddress, n); break;}
4211 case 11: {b.ReadFastArray((UChar_t*) fAddress, n); break;}
4212 case 12: {b.ReadFastArray((UShort_t*)fAddress, n); break;}
4213 case 13: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4214 case 14: {b.ReadFastArray((ULong_t*) fAddress, n); break;}
4215 case 15: {b.ReadFastArray((UInt_t*) fAddress, n); break;}
4216 case 16: {b.ReadFastArray((Long64_t*) fAddress, n); break;}
4217 case 17: {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
4218 case 18: {b.ReadFastArray((bool*) fAddress, n); break;}
4219 case 9: {
4222 Double_t *xx = (Double_t*) fAddress;
4223 for (Int_t ii=0;ii<n;ii++) {
4224 b.ReadDouble32(&(xx[ii]),se);
4225 }
4226 break;
4227 }
4228 case 19: {
4231 Float_t *xx = (Float_t*) fAddress;
4232 for (Int_t ii=0;ii<n;ii++) {
4233 b.ReadFloat16(&(xx[ii]),se);
4234 }
4235 break;
4236 }
4237 }
4238 } else {
4239 fNdata = 1;
4240 if (fAddress) {
4241 if (fType<0) {
4242 // Non TObject, Non collection classes with a custom streamer.
4243
4244 // if (fObject)
4246 } else {
4247 TStreamerInfo *info = GetInfoImp();
4248 if (!info) {
4249 return;
4250 }
4251 // Since info is not null, fReadActionSequence is not null either.
4252 b.ApplySequence(*fReadActionSequence, fObject);
4253 }
4255 fNdata = (Int_t) GetValue(0, 0);
4256 }
4257 } else {
4258 fNdata = 0;
4259 }
4260 }
4261 return;
4262 }
4263}
4264
4265////////////////////////////////////////////////////////////////////////////////
4266/// Read leaves into i/o buffers for this branch.
4267/// Case of a collection (fType == 4).
4268
4270{
4272 if (fObject == nullptr)
4273 {
4274 // We have nowhere to copy the data (probably because the data member was
4275 // 'dropped' from the current schema) so let's no copy it in a random place.
4276 return;
4277 }
4278
4279 // STL container master branch (has only the number of elements).
4280 Int_t n;
4281 b >> n;
4282 if ((n < 0) || (n > fMaximum)) {
4283 if (IsMissingCollection()) {
4284 n = 0;
4285 b.SetBufferOffset(b.Length()-sizeof(n));
4286 } else {
4287 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());
4288 n = 0;
4289 }
4290 }
4291 fNdata = n;
4292
4293 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4294
4295 // Note: Proxy-helper needs to "embrace" the entire
4296 // streaming of this STL container if the container
4297 // is a set/multiset/map/multimap (what we do not
4298 // know here).
4299 // For vector/list/deque Allocate == Resize
4300 // and Commit == noop.
4301 // TODO: Exception safety a la TPushPop
4304 void* alternate = proxy->Allocate(fNdata, true);
4306 fPtrIterators->CreateIterators(alternate, proxy);
4307 } else {
4308 fIterators->CreateIterators(alternate, proxy);
4309 }
4310
4311 Int_t nbranches = fBranches.GetEntriesFast();
4312 switch (fSTLtype) {
4313 case ROOT::kSTLset:
4316 case ROOT::kSTLmultiset:
4317 case ROOT::kSTLmap:
4318 case ROOT::kSTLmultimap:
4321 for (Int_t i = 0; i < nbranches; ++i) {
4322 TBranch *branch = (TBranch*) fBranches[i];
4323 Int_t nb = branch->GetEntry(GetReadEntry(), 1);
4324 if (nb < 0) {
4325 // Give up on i/o failure.
4326 // FIXME: We need an error message here.
4327 break;
4328 }
4329 }
4330 break;
4331 default:
4332 break;
4333 }
4334 //------------------------------------------------------------------------
4335 // We have split this stuff, so we need to create the pointers
4336 /////////////////////////////////////////////////////////////////////////////
4337
4339 {
4340 TClass *elClass = proxy->GetValueClass();
4341
4342 //--------------------------------------------------------------------
4343 // The allocation is done in this strange way because ReadLeaves
4344 // is being called many times by TTreeFormula!!!
4345 //////////////////////////////////////////////////////////////////////////
4346
4347 Int_t i = 0;
4348 // coverity[returned_null] the fNdata is check enough to prevent the use of null value of At(0)
4349 if( !fNdata || *(void**)proxy->At( 0 ) != nullptr )
4350 i = fNdata;
4351
4352 for( ; i < fNdata; ++i )
4353 {
4354 void **el = (void**)proxy->At( i );
4355 // coverity[dereference] since this is a member streaming action by definition the collection contains objects and elClass is not null.
4356 *el = elClass->New();
4357 }
4358 }
4359
4360 proxy->Commit(alternate);
4361}
4362
4363////////////////////////////////////////////////////////////////////////////////
4364/// Read leaves into i/o buffers for this branch.
4365/// Case of a data member within a collection (fType == 41).
4366
4368{
4370 if (fObject == nullptr)
4371 {
4372 // We have nowhere to copy the data (probably because the data member was
4373 // 'dropped' from the current schema) so let's no copy it in a random place.
4374 return;
4375 }
4376
4377 // STL container sub-branch (contains the elements).
4379 if (!fNdata) {
4380 return;
4381 }
4382
4383 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4384
4385 TStreamerInfo *info = GetInfoImp();
4386 if (info == nullptr) return;
4387
4390
4391 // R__ASSERT(0);
4393 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
4394}
4395
4396////////////////////////////////////////////////////////////////////////////////
4397/// Read leaves into i/o buffers for this branch.
4398/// Case of a data member within a collection (fType == 41).
4399
4401{
4403 if (fObject == nullptr)
4404 {
4405 // We have nowhere to copy the data (probably because the data member was
4406 // 'dropped' from the current schema) so let's no copy it in a random place.
4407 return;
4408 }
4409
4410 // STL container sub-branch (contains the elements).
4412 if (!fNdata) {
4413 return;
4414 }
4415 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4416
4417 TStreamerInfo *info = GetInfoImp();
4418 if (info == nullptr) return;
4419
4422
4424 b.ApplySequenceVecPtr(*fReadActionSequence,iter->fBegin,iter->fEnd);
4425}
4426
4427////////////////////////////////////////////////////////////////////////////////
4428/// Read leaves into i/o buffers for this branch.
4429/// Case of a data member within a collection (fType == 41).
4430
4432{
4434 if (fObject == nullptr)
4435 {
4436 // We have nowhere to copy the data (probably because the data member was
4437 // 'dropped' from the current schema) so let's no copy it in a random place.
4438 return;
4439 }
4440
4441 // STL container sub-branch (contains the elements).
4443 if (!fNdata) {
4444 return;
4445 }
4446 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4447
4448 TStreamerInfo *info = GetInfoImp();
4449 if (info == nullptr) return;
4450 // Since info is not null, fReadActionSequence is not null either.
4451
4452 // Still calling PushPop for the legacy entries.
4455
4457 b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
4458}
4459
4460////////////////////////////////////////////////////////////////////////////////
4461/// Read leaves into i/o buffers for this branch.
4462/// Case of a TClonesArray (fType == 3).
4463
4465{
4467 if (fObject == nullptr)
4468 {
4469 // We have nowhere to copy the data (probably because the data member was
4470 // 'dropped' from the current schema) so let's no copy it in a random place.
4471 return;
4472 }
4473
4474 // TClonesArray master branch (has only the number of elements).
4475 Int_t n;
4476 b >> n;
4477 if ((n < 0) || (n > fMaximum)) {
4478 if (IsMissingCollection()) {
4479 n = 0;
4480 b.SetBufferOffset(b.Length()-sizeof(n));
4481 } else {
4482 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());
4483 n = 0;
4484 }
4485 }
4486 fNdata = n;
4487 TClonesArray* clones = (TClonesArray*) fObject;
4488 if (clones->IsZombie()) {
4489 return;
4490 }
4491 // The salient part of Clear is now 'duplicated in ExpandCreateFast (i.e. the
4492 // setting to zero of the unused slots), so we no longer need to call Clear explicitly
4493 // clones->Clear();
4494 clones->ExpandCreateFast(fNdata);
4495}
4496
4497////////////////////////////////////////////////////////////////////////////////
4498/// Read leaves into i/o buffers for this branch.
4499/// Case of a data member within a TClonesArray (fType == 31).
4500
4502{
4503 // No need to validate the address here, if we are a member of a split ClonesArray,
4504 // fID is positive
4505 // ValidateAddress();
4506
4507 if (fObject == nullptr)
4508 {
4509 // We have nowhere to copy the data (probably because the data member was
4510 // 'dropped' from the current schema) so let's no copy it in a random place.
4511 return;
4512 }
4513
4514 // TClonesArray sub-branch (contains the elements).
4516 TClonesArray* clones = (TClonesArray*) fObject;
4517 if (clones->IsZombie()) {
4518 return;
4519 }
4520 TStreamerInfo *info = GetInfoImp();
4521 if (info==nullptr) return;
4522 // Since info is not null, fReadActionSequence is not null either.
4523
4524 // Note, we could (possibly) save some more, by configuring the action
4525 // based on the value of fOnfileObject rather than pushing in on a stack.
4526 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);
4527
4528 char **arr = (char **)clones->GetObjectRef();
4529 char **end = arr + fNdata;
4530 b.ApplySequenceVecPtr(*fReadActionSequence,arr,end);
4531}
4532
4533////////////////////////////////////////////////////////////////////////////////
4534/// Read leaves into i/o buffers for this branch.
4535/// For split-class branch, base class branch, data member branch, or top-level branch.
4536/// which do not have a branch count and are not a counter.
4537
4539{
4540 R__ASSERT(fBranchCount==nullptr);
4542
4544 if (fObject == nullptr)
4545 {
4546 // We have nowhere to copy the data (probably because the data member was
4547 // 'dropped' from the current schema) so let's no copy it in a random place.
4548 return;
4549 }
4550
4551 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4552 // If not a TClonesArray or STL container master branch
4553 // or sub-branch and branch inherits from tobject,
4554 // then register with the buffer so that pointers are
4555 // handled properly.
4556 if (TestBit(kBranchObject)) {
4557 b.MapObject((TObject*) fObject);
4558 } else if (TestBit(kBranchAny)) {
4559 b.MapObject(fObject, fBranchClass);
4560 }
4561
4562 fNdata = 1;
4563 TStreamerInfo *info = GetInfoImp();
4564 if (!info) {
4565 return;
4566 }
4567 // Since info is not null, fReadActionSequence is not null either.
4568 b.ApplySequence(*fReadActionSequence, fObject);
4569}
4570
4571////////////////////////////////////////////////////////////////////////////////
4572/// Read leaves into i/o buffers for this branch.
4573/// For split-class branch, base class branch, data member branch, or top-level branch.
4574/// which do have a branch count and are not a counter.
4575
4577{
4579
4581 if (fObject == nullptr)
4582 {
4583 // We have nowhere to copy the data (probably because the data member was
4584 // 'dropped' from the current schema) so let's no copy it in a random place.
4585 return;
4586 }
4587
4588 // If not a TClonesArray or STL container master branch
4589 // or sub-branch and branch inherits from tobject,
4590 // then register with the buffer so that pointers are
4591 // handled properly.
4592 if (TestBit(kBranchObject)) {
4593 b.MapObject((TObject*) fObject);
4594 } else if (TestBit(kBranchAny)) {
4595 b.MapObject(fObject, fBranchClass);
4596 }
4597
4598 fNdata = (Int_t) fBranchCount->GetValue(0, 0);
4599 TStreamerInfo *info = GetInfoImp();
4600 if (!info) {
4601 return;
4602 }
4603 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1); // Here we have a single object that contains a variable size C-style array.
4604 // Since info is not null, fReadActionSequence is not null either.
4605 b.ApplySequence(*fReadActionSequence, fObject);
4606}
4607
4608////////////////////////////////////////////////////////////////////////////////
4609/// Read leaves into i/o buffers for this branch.
4610/// For split-class branch, base class branch, data member branch, or top-level branch.
4611/// which do not have a branch count and are a counter.
4612
4614{
4616 if (fObject == nullptr)
4617 {
4618 // We have nowhere to copy the data (probably because the data member was
4619 // 'dropped' from the current schema) so let's no copy it in a random place.
4620 return;
4621 }
4622
4623 // If not a TClonesArray or STL container master branch
4624 // or sub-branch and branch inherits from tobject,
4625 // then register with the buffer so that pointers are
4626 // handled properly.
4627 if (TestBit(kBranchObject)) {
4628 b.MapObject((TObject*) fObject);
4629 } else if (TestBit(kBranchAny)) {
4630 b.MapObject(fObject, fBranchClass);
4631 }
4632
4633 TStreamerInfo *info = GetInfoImp();
4634 if (!info) {
4635 return;
4636 }
4637
4638 R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
4639
4640 // Since info is not null, fReadActionSequence is not null either.
4641 b.ApplySequence(*fReadActionSequence, fObject);
4642 fNdata = (Int_t) GetValue(0, 0);
4643}
4644
4645////////////////////////////////////////////////////////////////////////////////