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