Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TFormLeafInfo.cxx
Go to the documentation of this file.
1// @(#)root/treeplayer:$Id$
2// Author: Philippe Canal 01/06/2004
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers and al. *
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 TFormLeafInfo
13This class is a small helper class to implement reading a data member
14on an object stored in a TTree.
15
16TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
17reading of the information. Here is the list of theses classes:
18 - TFormLeafInfo
19 - TFormLeafInfoDirect
20 - TFormLeafInfoNumerical
21 - TFormLeafInfoClones
22 - TFormLeafInfoCollection
23 - TFormLeafInfoPointer
24 - TFormLeafInfoMethod
25 - TFormLeafInfoMultiVarDim
26 - TFormLeafInfoMultiVarDimDirect
27 - TFormLeafInfoCast
28
29The following method are available from the TFormLeafInfo interface:
30
31 - AddOffset(Int_t offset, TStreamerElement* element)
32 - GetCounterValue(TLeaf* leaf) : return the size of the array pointed to.
33 - GetObjectAddress(TLeafElement* leaf) : Returns the location of the object pointed to.
34 - GetMultiplicity() : Returns info on the variability of the number of elements
35 - GetNdata(TLeaf* leaf) : Returns the number of elements
36 - GetNdata() : Used by GetNdata(TLeaf* leaf)
37 - GetValue(TLeaf *leaf, Int_t instance = 0) : Return the value
38 - GetValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value
39 - GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value of 'this' LeafInfo
40 - IsString()
41 - ReadValue(char *where, Int_t instance = 0) : Internal function to interpret the location 'where'
42 - Update() : react to the possible loading of a shared library.
43*/
44
45#include "TFormLeafInfo.h"
46
47#include "TROOT.h"
48#include "TArrayI.h"
49#include "TClonesArray.h"
50#include "TError.h"
51#include "TInterpreter.h"
52#include "TLeafObject.h"
53#include "TMethod.h"
54#include "TMethodCall.h"
55#include "TTree.h"
56#include "TVirtualCollectionProxy.h"
57#include "TClassEdit.h"
58
59
60#define INSTANTIATE_READVAL(CLASS) \
61 template Double_t CLASS::ReadValueImpl<Double_t>(char*, Int_t); \
62 template Long64_t CLASS::ReadValueImpl<Long64_t>(char*, Int_t); \
63 template LongDouble_t CLASS::ReadValueImpl<LongDouble_t>(char*, Int_t) // no semicolon
64
65
66#define INSTANTIATE_GETVAL(CLASS) \
67 template Double_t CLASS::GetValueImpl<Double_t>(TLeaf*, Int_t); \
68 template Long64_t CLASS::GetValueImpl<Long64_t>(TLeaf*, Int_t); \
69 template LongDouble_t CLASS::GetValueImpl<LongDouble_t>(TLeaf*, Int_t) // no semicolon
70
71////////////////////////////////////////////////////////////////////////////////
72/// Constructor.
73
74TFormLeafInfo::TFormLeafInfo(TClass* classptr, Longptr_t offset,
75 TStreamerElement* element) :
76 fClass(classptr),fOffset(offset),fElement(element),
77 fCounter(nullptr), fNext(nullptr),fMultiplicity(0)
78{
79 if (fClass) fClassName = fClass->GetName();
80 if (fElement) {
81 fElementName = fElement->GetName();
82 }
83}
84
85////////////////////////////////////////////////////////////////////////////////
86///Constructor.
87
88TFormLeafInfo::TFormLeafInfo(const TFormLeafInfo& orig) : TObject(orig),fClass(orig.fClass),fOffset(orig.fOffset),fElement(orig.fElement),fCounter(nullptr),fNext(nullptr),fClassName(orig.fClassName),fElementName(orig.fElementName),fMultiplicity(orig.fMultiplicity)
89{
90 // Deep copy the pointers.
91 if (orig.fCounter) fCounter = orig.fCounter->DeepCopy();
92 if (orig.fNext) fNext = orig.fNext->DeepCopy();
93}
94
95////////////////////////////////////////////////////////////////////////////////
96/// Exception safe assignment operator.
97
98TFormLeafInfo &TFormLeafInfo::operator=(const TFormLeafInfo &other)
99{
100 TFormLeafInfo tmp(other);
101 Swap(tmp);
102 return *this;
103}
104
105////////////////////////////////////////////////////////////////////////////////
106
107void TFormLeafInfo::Swap(TFormLeafInfo& other)
108{
109 std::swap(fClass,other.fClass);
110 std::swap(fOffset,other.fOffset);
111 std::swap(fElement,other.fElement);
112 std::swap(fCounter,other.fCounter);
113 std::swap(fNext,other.fNext);
114 TString tmp(fClassName);
115 fClassName = other.fClassName;
116 other.fClassName = tmp;
117
118 tmp = fElementName;
119 fElementName = other.fElementName;
120 other.fElementName = tmp;
121 std::swap(fMultiplicity,other.fMultiplicity);
122}
123
124////////////////////////////////////////////////////////////////////////////////
125/// Make a complete copy of this FormLeafInfo and all its content.
126
127TFormLeafInfo* TFormLeafInfo::DeepCopy() const
128{
129 return new TFormLeafInfo(*this);
130}
131
132////////////////////////////////////////////////////////////////////////////////
133/// Delete this object and all its content
134
135TFormLeafInfo::~TFormLeafInfo()
136{
137 delete fCounter;
138 delete fNext;
139}
140
141////////////////////////////////////////////////////////////////////////////////
142/// Increase the offset of this element. This intended to be the offset
143/// from the start of the object to which the data member belongs.
144
145void TFormLeafInfo::AddOffset(Int_t offset, TStreamerElement* element)
146{
147 fOffset += offset;
148 fElement = element;
149 if (fElement ) {
150 // fElementClassOwnerName = cl->GetName();
151 fElementName.Append(".").Append(element->GetName());
152 }
153}
154
155////////////////////////////////////////////////////////////////////////////////
156/// Return the current length of the array.
157
158Int_t TFormLeafInfo::GetArrayLength()
159{
160 Int_t len = 1;
161 if (fNext) len = fNext->GetArrayLength();
162 if (fElement) {
163 Int_t elen = fElement->GetArrayLength();
164 if (elen || fElement->IsA() == TStreamerBasicPointer::Class() )
165 len *= fElement->GetArrayLength();
166 }
167 return len;
168}
169
170////////////////////////////////////////////////////////////////////////////////
171/// Get the class of the underlying data.
172
173TClass* TFormLeafInfo::GetClass() const
174{
175 if (fNext) return fNext->GetClass();
176 if (fElement) return fElement->GetClassPointer();
177 return fClass;
178}
179
180////////////////////////////////////////////////////////////////////////////////
181/// Returns the location of the object pointed to.
182/// Modify instance if the object is part of an array.
183
184char* TFormLeafInfo::GetObjectAddress(TLeafElement* leaf, Int_t& instance)
185{
186 TBranchElement* branch = (TBranchElement*) leaf->GetBranch();
187 Int_t id = branch->GetID();
188 if (id < 0) {
189 // Branch is a top-level branch.
190 if (branch->GetTree()->GetMakeClass()) {
191 // Branch belongs to a MakeClass tree.
192 return branch->GetAddress();
193 } else {
194 return branch->GetObject();
195 }
196 }
197 TStreamerInfo* info = branch->GetInfo();
198 Int_t offset = 0;
199 if (id > -1) {
200 // Branch is *not* a top-level branch.
201 offset = info->TStreamerInfo::GetElementOffset(id);
202 }
203 char* address = nullptr;
204 // Branch is *not* a top-level branch.
205 if (branch->GetTree()->GetMakeClass()) {
206 // Branch belongs to a MakeClass tree.
207 address = (char*) branch->GetAddress();
208 } else {
209 address = (char*) branch->GetObject();
210 }
211 char* thisobj = nullptr;
212 if (!address) {
213 // FIXME: This makes no sense, if the branch address is not set, then object will not be set either.
214 thisobj = branch->GetObject();
215 } else {
216 Int_t type = -1;
217 if (id > -1) {
218 // Note this is somewhat slow
219 type = info->TStreamerInfo::GetElement(id)->GetNewType();
220 }
221 switch (type) {
222 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
223 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
224 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
225 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
226 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
227 Error("GetValuePointer", "Type (%d) not yet supported\n", type);
228 break;
229
230 case TStreamerInfo::kOffsetL + TStreamerInfo::kObject:
231 case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
232 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
233 {
234 // An array of objects.
235 Int_t index;
236 Int_t sub_instance;
237 Int_t len = GetArrayLength();
238 if (len) {
239 index = instance / len;
240 sub_instance = instance % len;
241 } else {
242 index = instance;
243 sub_instance = 0;
244 }
245 thisobj = address + offset + (index * fClass->Size());
246 instance = sub_instance;
247 break;
248 }
249
250 case TStreamerInfo::kBase:
251 case TStreamerInfo::kObject:
252 case TStreamerInfo::kTString:
253 case TStreamerInfo::kTNamed:
254 case TStreamerInfo::kTObject:
255 case TStreamerInfo::kAny:
256 case TStreamerInfo::kSTL:
257 // A single object.
258 thisobj = address + offset;
259 break;
260
261 case TStreamerInfo::kBool:
262 case TStreamerInfo::kChar:
263 case TStreamerInfo::kUChar:
264 case TStreamerInfo::kShort:
265 case TStreamerInfo::kUShort:
266 case TStreamerInfo::kInt:
267 case TStreamerInfo::kUInt:
268 case TStreamerInfo::kLong:
269 case TStreamerInfo::kULong:
270 case TStreamerInfo::kLong64:
271 case TStreamerInfo::kULong64:
272 case TStreamerInfo::kFloat:
273 case TStreamerInfo::kFloat16:
274 case TStreamerInfo::kDouble:
275 case TStreamerInfo::kDouble32:
276 case TStreamerInfo::kLegacyChar:
277 case TStreamerInfo::kCounter:
278 case TStreamerInfo::kOffsetL + TStreamerInfo::kBool:
279 case TStreamerInfo::kOffsetL + TStreamerInfo::kChar:
280 case TStreamerInfo::kOffsetL + TStreamerInfo::kUChar:
281 case TStreamerInfo::kOffsetL + TStreamerInfo::kShort:
282 case TStreamerInfo::kOffsetL + TStreamerInfo::kUShort:
283 case TStreamerInfo::kOffsetL + TStreamerInfo::kInt:
284 case TStreamerInfo::kOffsetL + TStreamerInfo::kUInt:
285 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong:
286 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong:
287 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong64:
288 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong64:
289 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat:
290 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat16:
291 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble:
292 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble32:
293 case TStreamerInfo::kOffsetL + TStreamerInfo::kLegacyChar:
294 // A simple type, or an array of a simple type.
295 thisobj = address + offset;
296 break;
297
298 default:
299 // Everything else is a pointer to something.
300 thisobj = *((char**) (address + offset));
301 break;
302 }
303 }
304 return thisobj;
305}
306
307////////////////////////////////////////////////////////////////////////////////
308/// Reminder of the meaning of fMultiplicity:
309/// - -1: Only one or 0 element per entry but contains variable length array!
310/// - 0: Only one element per entry, no variable length array
311/// - 1: loop over the elements of a variable length array
312/// - 2: loop over elements of fixed length array (nData is the same for all entry)
313
314Int_t TFormLeafInfo::GetMultiplicity()
315{
316 // Currently only TFormLeafInfoCast uses this field.
317 return fMultiplicity;
318}
319
320Int_t TFormLeafInfo::GetNdata(TLeaf* leaf)
321{
322 // Get the number of element in the entry.
323
324 GetCounterValue(leaf);
325 GetValue(leaf);
326 return GetNdata();
327}
328
329////////////////////////////////////////////////////////////////////////////////
330/// Get the number of element in the entry.
331
332Int_t TFormLeafInfo::GetNdata()
333{
334 if (fNext) return fNext->GetNdata();
335 return 1;
336}
337
338////////////////////////////////////////////////////////////////////////////////
339/// Return true if any of underlying data has a array size counter
340
341bool TFormLeafInfo::HasCounter() const
342{
343 bool result = false;
344 if (fNext) result = fNext->HasCounter();
345 return fCounter!=nullptr || result;
346}
347
348////////////////////////////////////////////////////////////////////////////////
349/// Return true if the underlying data is a string
350
351bool TFormLeafInfo::IsString() const
352{
353 if (fNext) return fNext->IsString();
354 if (!fElement) return false;
355
356 switch (fElement->GetNewType()) {
357 // basic types
358 case kChar_t:
359 // This is new in ROOT 3.02/05
360 return false;
361 case TStreamerInfo::kOffsetL + TStreamerInfo::kChar:
362 // This is new in ROOT 3.02/05
363 return true;
364 case TStreamerInfo::kCharStar:
365 return true;
366 default:
367 return false;
368 }
369}
370
371////////////////////////////////////////////////////////////////////////////////
372/// Return true if the underlying data is an integral value
373
374bool TFormLeafInfo::IsInteger() const
375{
376 if (fNext) return fNext->IsInteger();
377 if (!fElement) return false;
378
379 Int_t atype = fElement->GetNewType();
380 if (TStreamerInfo::kOffsetL < atype &&
381 atype < TStreamerInfo::kOffsetP ) {
382 atype -= TStreamerInfo::kOffsetL;
383 } else if (TStreamerInfo::kOffsetP < atype &&
384 atype < TStreamerInfo::kObject) {
385 atype -= TStreamerInfo::kOffsetP;
386 }
387
388 switch (atype) {
389 // basic types
390 case TStreamerInfo::kLegacyChar:
391 case TStreamerInfo::kBool:
392 case TStreamerInfo::kChar:
393 case TStreamerInfo::kUChar:
394 case TStreamerInfo::kShort:
395 case TStreamerInfo::kUShort:
396 case TStreamerInfo::kInt:
397 case TStreamerInfo::kUInt:
398 case TStreamerInfo::kLong:
399 case TStreamerInfo::kULong:
400 case TStreamerInfo::kLong64:
401 case TStreamerInfo::kULong64:
402 return true;
403 case TStreamerInfo::kCharStar:
404 return true; // For consistency with the leaf list method and proper axis setting
405 case TStreamerInfo::kFloat:
406 case TStreamerInfo::kFloat16:
407 case TStreamerInfo::kDouble:
408 case TStreamerInfo::kDouble32:
409 return false;
410 default:
411 return false;
412 }
413}
414
415////////////////////////////////////////////////////////////////////////////////
416/// Method for multiple variable dimensions.
417
418Int_t TFormLeafInfo::GetPrimaryIndex()
419{
420 if (fNext) return fNext->GetPrimaryIndex();
421 return -1;
422}
423
424////////////////////////////////////////////////////////////////////////////////
425/// Return the index of the dimension which varies
426/// for each elements of an enclosing array (typically a TClonesArray)
427
428Int_t TFormLeafInfo::GetVarDim()
429{
430 if (fNext) return fNext->GetVarDim();
431 else return -1;
432}
433
434////////////////////////////////////////////////////////////////////////////////
435/// Return the virtual index (for this expression) of the dimension which varies
436/// for each elements of an enclosing array (typically a TClonesArray)
437
438Int_t TFormLeafInfo::GetVirtVarDim()
439{
440 if (fNext) return fNext->GetVirtVarDim();
441 else return -1;
442}
443
444////////////////////////////////////////////////////////////////////////////////
445/// For the current entry, and the value 'index' for the main array,
446/// return the size of the secondary variable dimension of the 'array'.
447
448Int_t TFormLeafInfo::GetSize(Int_t index)
449{
450 if (fNext) return fNext->GetSize(index);
451 else return 0;
452}
453
454////////////////////////////////////////////////////////////////////////////////
455/// Total all the elements that are available for the current entry
456/// for the secondary variable dimension.
457
458Int_t TFormLeafInfo::GetSumOfSizes()
459{
460 if (fNext) return fNext->GetSumOfSizes();
461 else return 0;
462}
463
464////////////////////////////////////////////////////////////////////////////////
465/// Load the current array sizes
466
471
472////////////////////////////////////////////////////////////////////////////////
473/// Set the primary index value
474
479
480////////////////////////////////////////////////////////////////////////////////
481/// Set the primary index value
482
487
488////////////////////////////////////////////////////////////////////////////////
489/// Set the current size of the arrays
490
491void TFormLeafInfo::SetSize(Int_t index, Int_t val)
492{
493 if (fNext) fNext->SetSize(index, val);
494}
495
496////////////////////////////////////////////////////////////////////////////////
497/// Set the current sizes of the arrays
498
503
504////////////////////////////////////////////////////////////////////////////////
505/// We reloading all cached information in case the underlying class
506/// information has changed (for example when changing from the 'emulated'
507/// class to the real class.
508
509bool TFormLeafInfo::Update()
510{
511 if (fClass) {
512 TClass * new_class = TClass::GetClass(fClassName);
513 if (new_class==fClass) {
514 if (fNext) fNext->Update();
515 if (fCounter) fCounter->Update();
516 return false;
517 }
518 fClass = new_class;
519 }
520 if (fElement && fClass) {
521 TClass *cl = fClass;
522 // We have to drill down the element name within the class.
523 Int_t offset,i;
524 TStreamerElement* element;
525 char * current;
526 Int_t nchname = fElementName.Length();
527 char * work = new char[nchname+2];
528 for (i=0, current = &(work[0]), fOffset=0; i<nchname+1;i++ ) {
529 if (i==nchname || fElementName[i]=='.') {
530 // A delimiter happened let's see if what we have seen
531 // so far does point to a data member.
532 *current = '\0';
533 element = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(work,offset);
534 if (element) {
535 Int_t type = element->GetNewType();
536 if (type<60) {
537 fOffset += offset;
538 } else if (type == TStreamerInfo::kBase ||
539 type == TStreamerInfo::kAny ||
540 type == TStreamerInfo::kObject ||
541 type == TStreamerInfo::kTString ||
542 type == TStreamerInfo::kTNamed ||
543 type == TStreamerInfo::kTObject ||
544 type == TStreamerInfo::kObjectp ||
545 type == TStreamerInfo::kObjectP ||
546 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp ||
547 type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP ||
548 type == TStreamerInfo::kAnyp ||
549 type == TStreamerInfo::kAnyP ||
550 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp ||
551 type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP ||
552 type == TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp ||
553 type == TStreamerInfo::kSTL ||
554 type == TStreamerInfo::kSTLp ) {
555 fOffset += offset;
556 cl = element->GetClassPointer();
557 }
558 fElement = element;
559 current = &(work[0]);
560 }
561 } else {
562 if (i<nchname) *current++ = fElementName[i];
563 }
564 }
565 delete [] work;
566 }
567 if (fNext) fNext->Update();
568 if (fCounter) fCounter->Update();
569 return true;
570}
571
572////////////////////////////////////////////////////////////////////////////////
573/// Return the size of the underlying array for the current entry in the TTree.
574
575Int_t TFormLeafInfo::GetCounterValue(TLeaf* leaf) {
576 if (!fCounter) {
577 if (fNext && fNext->HasCounter()) {
578 char *where = (char*)GetLocalValuePointer(leaf,0);
579 return fNext->ReadCounterValue(where);
580 } else return 1;
581 }
582 return (Int_t)fCounter->GetValue(leaf);
583}
584
585////////////////////////////////////////////////////////////////////////////////
586/// Return the size of the underlying array for the current entry in the TTree.
587
588Int_t TFormLeafInfo::ReadCounterValue(char* where)
589{
590 if (!fCounter) {
591 if (fNext) {
592 char *next = (char*)GetLocalValuePointer(where,0);
593 return fNext->ReadCounterValue(next);
594 } else return 1;
595 }
596 return (Int_t)fCounter->ReadValue(where,0);
597}
598
599////////////////////////////////////////////////////////////////////////////////
600/// returns the address of the value pointed to by the
601/// TFormLeafInfo.
602
603void* TFormLeafInfo::GetLocalValuePointer(TLeaf *leaf, Int_t instance)
604{
605 char *thisobj = nullptr;
606 if (leaf->InheritsFrom(TLeafObject::Class()) ) {
607 thisobj = (char*)((TLeafObject*)leaf)->GetObject();
608 } else {
609 thisobj = GetObjectAddress((TLeafElement*)leaf, instance); // instance might be modified
610 }
611 if (!thisobj) return nullptr;
612 return GetLocalValuePointer(thisobj, instance);
613}
614
615////////////////////////////////////////////////////////////////////////////////
616/// returns the address of the value pointed to by the
617/// serie of TFormLeafInfo.
618
625
626////////////////////////////////////////////////////////////////////////////////
627/// returns the address of the value pointed to by the
628/// TFormLeafInfo.
629
630void* TFormLeafInfo::GetValuePointer(char *thisobj, Int_t instance)
631{
632 char *where = (char*)GetLocalValuePointer(thisobj,instance);
633 if (fNext) return fNext->GetValuePointer(where,instance);
634 else return where;
635}
636
637////////////////////////////////////////////////////////////////////////////////
638/// returns the address of the value pointed to by the
639/// TFormLeafInfo.
640
641void* TFormLeafInfo::GetLocalValuePointer(char *thisobj, Int_t instance)
642{
643 if (fElement==nullptr || thisobj==nullptr) return thisobj;
644
645 switch (fElement->GetNewType()) {
646 // basic types
647 case TStreamerInfo::kBool:
648 case TStreamerInfo::kChar:
649 case TStreamerInfo::kUChar:
650 case TStreamerInfo::kShort:
651 case TStreamerInfo::kUShort:
652 case TStreamerInfo::kInt:
653 case TStreamerInfo::kUInt:
654 case TStreamerInfo::kLong:
655 case TStreamerInfo::kULong:
656 case TStreamerInfo::kLong64:
657 case TStreamerInfo::kULong64:
658 case TStreamerInfo::kFloat:
659 case TStreamerInfo::kFloat16:
660 case TStreamerInfo::kDouble:
661 case TStreamerInfo::kDouble32:
662 case TStreamerInfo::kLegacyChar:
663 case TStreamerInfo::kCounter:
664 return (Int_t*)(thisobj+fOffset);
665
666 // array of basic types array[8]
667 case TStreamerInfo::kOffsetL + TStreamerInfo::kBool:
668 {bool *val = (bool*)(thisobj+fOffset); return &(val[instance]);}
669 case TStreamerInfo::kOffsetL + TStreamerInfo::kChar:
670 {Char_t *val = (Char_t*)(thisobj+fOffset); return &(val[instance]);}
671 case TStreamerInfo::kOffsetL + TStreamerInfo::kShort:
672 {Short_t *val = (Short_t*)(thisobj+fOffset); return &(val[instance]);}
673 case TStreamerInfo::kOffsetL + TStreamerInfo::kInt:
674 {Int_t *val = (Int_t*)(thisobj+fOffset); return &(val[instance]);}
675 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong:
676 {Long_t *val = (Long_t*)(thisobj+fOffset); return &(val[instance]);}
677 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong64:
678 {Long64_t *val = (Long64_t*)(thisobj+fOffset); return &(val[instance]);}
679 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat:
680 {Float_t *val = (Float_t*)(thisobj+fOffset); return &(val[instance]);}
681 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat16:
682 {Float_t *val = (Float_t*)(thisobj+fOffset); return &(val[instance]);}
683 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble:
684 {Double_t *val = (Double_t*)(thisobj+fOffset); return &(val[instance]);}
685 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble32:
686 {Double_t *val = (Double_t*)(thisobj+fOffset); return &(val[instance]);}
687 case TStreamerInfo::kOffsetL + TStreamerInfo::kUChar:
688 {UChar_t *val = (UChar_t*)(thisobj+fOffset); return &(val[instance]);}
689 case TStreamerInfo::kOffsetL + TStreamerInfo::kUShort:
690 {UShort_t *val = (UShort_t*)(thisobj+fOffset); return &(val[instance]);}
691 case TStreamerInfo::kOffsetL + TStreamerInfo::kUInt:
692 {UInt_t *val = (UInt_t*)(thisobj+fOffset); return &(val[instance]);}
693 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong:
694 {ULong_t *val = (ULong_t*)(thisobj+fOffset); return &(val[instance]);}
695 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong64:
696 {ULong64_t *val = (ULong64_t*)(thisobj+fOffset); return &(val[instance]);}
697
698#define GET_ARRAY(TYPE_t) \
699 { \
700 Int_t len, sub_instance, index; \
701 if (fNext) len = fNext->GetArrayLength(); \
702 else len = 1; \
703 if (len) { \
704 index = instance / len; \
705 sub_instance = instance % len; \
706 } else { \
707 index = instance; \
708 sub_instance = 0; \
709 } \
710 TYPE_t **val = (TYPE_t**)(thisobj+fOffset); \
711 return &((val[sub_instance])[index]); \
712 }
713
714 // pointer to an array of basic types array[n]
715 case TStreamerInfo::kOffsetP + TStreamerInfo::kBool: GET_ARRAY(bool)
716 case TStreamerInfo::kOffsetP + TStreamerInfo::kChar: GET_ARRAY(Char_t)
717 case TStreamerInfo::kOffsetP + TStreamerInfo::kShort: GET_ARRAY(Short_t)
718 case TStreamerInfo::kOffsetP + TStreamerInfo::kInt: GET_ARRAY(Int_t)
719 case TStreamerInfo::kOffsetP + TStreamerInfo::kLong: GET_ARRAY(Long_t)
720 case TStreamerInfo::kOffsetP + TStreamerInfo::kLong64: GET_ARRAY(Long64_t)
721 case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat16:
722 case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat: GET_ARRAY(Float_t)
723 case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble32:
724 case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble: GET_ARRAY(Double_t)
725 case TStreamerInfo::kOffsetP + TStreamerInfo::kUChar: GET_ARRAY(UChar_t)
726 case TStreamerInfo::kOffsetP + TStreamerInfo::kUShort: GET_ARRAY(UShort_t)
727 case TStreamerInfo::kOffsetP + TStreamerInfo::kUInt: GET_ARRAY(UInt_t)
728 case TStreamerInfo::kOffsetP + TStreamerInfo::kULong: GET_ARRAY(ULong_t)
729 case TStreamerInfo::kOffsetP + TStreamerInfo::kULong64: GET_ARRAY(ULong64_t)
730
731 case TStreamerInfo::kCharStar:
732 {char **stringp = (char**)(thisobj+fOffset); return *stringp;}
733
734 case TStreamerInfo::kObjectp:
735 case TStreamerInfo::kObjectP:
736 case TStreamerInfo::kAnyp:
737 case TStreamerInfo::kAnyP:
738 case TStreamerInfo::kSTLp:
739 {TObject **obj = (TObject**)(thisobj+fOffset); return *obj; }
740
741 case TStreamerInfo::kObject:
742 case TStreamerInfo::kTString:
743 case TStreamerInfo::kTNamed:
744 case TStreamerInfo::kTObject:
745 case TStreamerInfo::kAny:
746 case TStreamerInfo::kBase:
747 case TStreamerInfo::kSTL:
748 {TObject *obj = (TObject*)(thisobj+fOffset); return obj; }
749
750 case TStreamerInfo::kOffsetL + TStreamerInfo::kTObject:
751 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
752 case TStreamerInfo::kOffsetL + TStreamerInfo::kAny: {
753 char *loc = thisobj+fOffset;
754
755 Int_t len, index;
756 //Int_t sub_instance;
757
758 if (fNext) len = fNext->GetArrayLength();
759 else len = 1;
760 if (len) {
761 index = instance / len;
762 // sub_instance = instance % len;
763 } else {
764 index = instance;
765 // sub_instance = 0;
766 }
767
768 loc += index*fElement->GetClassPointer()->Size();
769
770 TObject *obj = (TObject*)(loc);
771 return obj;
772 }
773
774 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
775 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
776 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
777 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
778 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
779 {TObject *obj = (TObject*)(thisobj+fOffset); return obj; }
780
781 case kOther_t:
782 default: return nullptr;
783 }
784}
785
786
787////////////////////////////////////////////////////////////////////////////////
788/// Return result of a leafobject method.
789
790template <typename T>
791T TFormLeafInfo::GetValueImpl(TLeaf *leaf, Int_t instance)
792{
793 char *thisobj = nullptr;
794 if (leaf->InheritsFrom(TLeafObject::Class()) ) {
795 thisobj = (char*)((TLeafObject*)leaf)->GetObject();
796 } else {
797 thisobj = GetObjectAddress((TLeafElement*)leaf, instance); // instance might be modified
798 }
799 if (thisobj==nullptr) return 0;
800 return ReadTypedValue<T>(thisobj,instance);
801}
802
803INSTANTIATE_GETVAL(TFormLeafInfo);
804INSTANTIATE_READVAL(TFormLeafInfo);
805
806////////////////////////////////////////////////////////////////////////////////
807/// Read the value at the given memory location
808
809template <typename T>
810T TFormLeafInfo::ReadValueImpl(char *thisobj, Int_t instance)
811{
812 if ( !thisobj ) {
813 Error("ReadValue","Invalid data address: result will be wrong");
814 return 0.0; // Or should throw exception/print error ?
815 }
816 if (fNext) {
817 char *nextobj = thisobj+fOffset;
818 Int_t sub_instance = instance;
819 Int_t type = fElement->GetNewType();
820 if (type==TStreamerInfo::kOffsetL + TStreamerInfo::kObject ||
821 type==TStreamerInfo::kOffsetL + TStreamerInfo::kSTL ||
822 type==TStreamerInfo::kOffsetL + TStreamerInfo::kAny) {
823 Int_t index;
824 Int_t len = fNext->GetArrayLength();
825 if (len) {
826 index = instance / len;
827 sub_instance = instance % len;
828 } else {
829 index = instance;
830 sub_instance = 0;
831 }
832 nextobj += index*fElement->GetClassPointer()->Size();
833 }
834 return fNext->ReadTypedValue<T>(nextobj,sub_instance);
835 }
836 // return fInfo->ReadValue(thisobj+fOffset,fElement->GetNewType(),instance,1);
837 switch (fElement->GetNewType()) {
838 // basic types
839 case TStreamerInfo::kBool: return (T)(*(bool*)(thisobj+fOffset));
840 case TStreamerInfo::kChar: return (T)(*(Char_t*)(thisobj+fOffset));
841 case TStreamerInfo::kUChar: return (T)(*(UChar_t*)(thisobj+fOffset));
842 case TStreamerInfo::kShort: return (T)(*(Short_t*)(thisobj+fOffset));
843 case TStreamerInfo::kUShort: return (T)(*(UShort_t*)(thisobj+fOffset));
844 case TStreamerInfo::kInt: return (T)(*(Int_t*)(thisobj+fOffset));
845 case TStreamerInfo::kUInt: return (T)(*(UInt_t*)(thisobj+fOffset));
846 case TStreamerInfo::kLong: return (T)(*(Long_t*)(thisobj+fOffset));
847 case TStreamerInfo::kULong: return (T)(*(ULong_t*)(thisobj+fOffset));
848 case TStreamerInfo::kLong64: return (T)(*(Long64_t*)(thisobj+fOffset));
849 case TStreamerInfo::kULong64: return (T)(*(Long64_t*)(thisobj+fOffset)); //cannot cast to ULong64_t with VC++6
850 case TStreamerInfo::kFloat: return (T)(*(Float_t*)(thisobj+fOffset));
851 case TStreamerInfo::kFloat16: return (T)(*(Float_t*)(thisobj+fOffset));
852 case TStreamerInfo::kDouble: return (T)(*(Double_t*)(thisobj+fOffset));
853 case TStreamerInfo::kDouble32: return (T)(*(Double_t*)(thisobj+fOffset));
854 case TStreamerInfo::kLegacyChar: return (T)(*(char*)(thisobj+fOffset));
855 case TStreamerInfo::kCounter: return (T)(*(Int_t*)(thisobj+fOffset));
856
857 // array of basic types array[8]
858 case TStreamerInfo::kOffsetL + TStreamerInfo::kBool:
859 {bool *val = (bool*)(thisobj+fOffset); return T(val[instance]);}
860 case TStreamerInfo::kOffsetL + TStreamerInfo::kChar:
861 {Char_t *val = (Char_t*)(thisobj+fOffset); return T(val[instance]);}
862 case TStreamerInfo::kOffsetL + TStreamerInfo::kShort:
863 {Short_t *val = (Short_t*)(thisobj+fOffset); return T(val[instance]);}
864 case TStreamerInfo::kOffsetL + TStreamerInfo::kInt:
865 {Int_t *val = (Int_t*)(thisobj+fOffset); return T(val[instance]);}
866 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong:
867 {Long_t *val = (Long_t*)(thisobj+fOffset); return T(val[instance]);}
868 case TStreamerInfo::kOffsetL + TStreamerInfo::kLong64:
869 {Long64_t *val = (Long64_t*)(thisobj+fOffset); return T(val[instance]);}
870 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat16:
871 {Float_t *val = (Float_t*)(thisobj+fOffset); return T(val[instance]);}
872 case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat:
873 {Float_t *val = (Float_t*)(thisobj+fOffset); return T(val[instance]);}
874 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble:
875 {Double_t *val = (Double_t*)(thisobj+fOffset); return T(val[instance]);}
876 case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble32:
877 {Double_t *val = (Double_t*)(thisobj+fOffset); return T(val[instance]);}
878 case TStreamerInfo::kOffsetL + TStreamerInfo::kUChar:
879 {UChar_t *val = (UChar_t*)(thisobj+fOffset); return T(val[instance]);}
880 case TStreamerInfo::kOffsetL + TStreamerInfo::kUShort:
881 {UShort_t *val = (UShort_t*)(thisobj+fOffset); return T(val[instance]);}
882 case TStreamerInfo::kOffsetL + TStreamerInfo::kUInt:
883 {UInt_t *val = (UInt_t*)(thisobj+fOffset); return T(val[instance]);}
884 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong:
885 {ULong_t *val = (ULong_t*)(thisobj+fOffset); return T(val[instance]);}
886#if defined(_MSC_VER) && (_MSC_VER <= 1200)
887 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong64:
888 {Long64_t *val = (Long64_t*)(thisobj+fOffset); return T(val[instance]);}
889#else
890 case TStreamerInfo::kOffsetL + TStreamerInfo::kULong64:
891 {ULong64_t *val = (ULong64_t*)(thisobj+fOffset); return T(val[instance]);}
892#endif
893
894#define READ_ARRAY(TYPE_t) \
895 { \
896 Int_t len, sub_instance, index; \
897 len = GetArrayLength(); \
898 if (len) { \
899 index = instance / len; \
900 sub_instance = instance % len; \
901 } else { \
902 index = instance; \
903 sub_instance = 0; \
904 } \
905 TYPE_t **val =(TYPE_t**)(thisobj+fOffset); \
906 return T((val[sub_instance])[index]); \
907 }
908
909 // pointer to an array of basic types array[n]
910 case TStreamerInfo::kOffsetP + TStreamerInfo::kBool: READ_ARRAY(bool)
911 case TStreamerInfo::kOffsetP + TStreamerInfo::kChar: READ_ARRAY(Char_t)
912 case TStreamerInfo::kOffsetP + TStreamerInfo::kShort: READ_ARRAY(Short_t)
913 case TStreamerInfo::kOffsetP + TStreamerInfo::kInt: READ_ARRAY(Int_t)
914 case TStreamerInfo::kOffsetP + TStreamerInfo::kLong: READ_ARRAY(Long_t)
915 case TStreamerInfo::kOffsetP + TStreamerInfo::kLong64: READ_ARRAY(Long64_t)
916 case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat16:
917 case TStreamerInfo::kOffsetP + TStreamerInfo::kFloat: READ_ARRAY(Float_t)
918 case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble32:
919 case TStreamerInfo::kOffsetP + TStreamerInfo::kDouble: READ_ARRAY(Double_t)
920 case TStreamerInfo::kOffsetP + TStreamerInfo::kUChar: READ_ARRAY(UChar_t)
921 case TStreamerInfo::kOffsetP + TStreamerInfo::kUShort: READ_ARRAY(UShort_t)
922 case TStreamerInfo::kOffsetP + TStreamerInfo::kUInt: READ_ARRAY(UInt_t)
923 case TStreamerInfo::kOffsetP + TStreamerInfo::kULong: READ_ARRAY(ULong_t)
924#if defined(_MSC_VER) && (_MSC_VER <= 1200)
925 case TStreamerInfo::kOffsetP + TStreamerInfo::kULong64: READ_ARRAY(Long64_t)
926#else
927 case TStreamerInfo::kOffsetP + TStreamerInfo::kULong64: READ_ARRAY(ULong64_t)
928#endif
929
930 case kOther_t:
931 default: return 0;
932 }
933}
934
935////////////////////////////////////////////////////////////////////////////////
936/// \class TFormLeafInfoDirect
937/// A small helper class to implement reading a data
938/// member on an object stored in a TTree.
939
940////////////////////////////////////////////////////////////////////////////////
941/// Constructor.
942
943TFormLeafInfoDirect::TFormLeafInfoDirect(TBranchElement * from) :
944 TFormLeafInfo(from->GetInfo()->GetClass(),0,
945 from->GetInfo()->GetElement(from->GetID()))
946{
947}
948
949////////////////////////////////////////////////////////////////////////////////
950/// Copy this object and its content.
951
952TFormLeafInfo* TFormLeafInfoDirect::DeepCopy() const
953{
954 return new TFormLeafInfoDirect(*this);
955}
956
957////////////////////////////////////////////////////////////////////////////////
958/// Read the value at the given memory location
959
960Double_t TFormLeafInfoDirect::ReadValue(char * /*where*/, Int_t /*instance*/)
961{
962 Error("ReadValue","Should not be used in a TFormLeafInfoDirect");
963 return 0;
964}
965
966////////////////////////////////////////////////////////////////////////////////
967/// Return the underlying value.
968
969template <typename T>
970T TFormLeafInfoDirect::GetValueImpl(TLeaf *leaf, Int_t instance)
971{
972 return leaf->GetTypedValue<T>(instance);
973}
974
975INSTANTIATE_GETVAL(TFormLeafInfoDirect);
976
977////////////////////////////////////////////////////////////////////////////////
978/// Return the address of the underlying value.
979
980void* TFormLeafInfoDirect::GetLocalValuePointer(TLeaf *leaf, Int_t instance)
981{
982 if (leaf->IsA() != TLeafElement::Class()) {
983 return leaf->GetValuePointer();
984 } else {
985 return GetObjectAddress((TLeafElement*)leaf, instance); // instance might be modified
986 }
987}
988
989////////////////////////////////////////////////////////////////////////////////
990/// Note this should probably never be executed.
991
996
997////////////////////////////////////////////////////////////////////////////////
998/// \class TFormLeafInfoNumerical
999/// A small helper class to implement reading a numerical value inside a collection
1000
1001////////////////////////////////////////////////////////////////////////////////
1002/// Constructor.
1003
1004TFormLeafInfoNumerical::TFormLeafInfoNumerical(EDataType kind) :
1005 TFormLeafInfo(nullptr,0,nullptr),
1006 fKind(kind), fIsBool(false)
1007{
1008 fElement = new TStreamerElement("data","in collection", 0, fKind, "");
1009}
1010
1011////////////////////////////////////////////////////////////////////////////////
1012/// Construct a TFormLeafInfo for the numerical type contained in the collection.
1013
1014TFormLeafInfoNumerical::TFormLeafInfoNumerical(TVirtualCollectionProxy *collection) :
1015 TFormLeafInfo(nullptr,0,nullptr),
1016 fKind(kNoType_t), fIsBool(false)
1017{
1018 if (collection) {
1019 fKind = (EDataType)collection->GetType();
1020 if (fKind == TStreamerInfo::kOffsetL + TStreamerInfo::kChar) {
1021 // Could be a bool
1022 if (strcmp( collection->GetCollectionClass()->GetName(), "vector<bool>") == 0
1023 || strncmp( collection->GetCollectionClass()->GetName(), "bitset<", std::char_traits<char>::length("bitset<") ) ==0 ) {
1024 fIsBool = true;
1025 fKind = (EDataType)18;
1026 }
1027 }
1028 }
1029 fElement = new TStreamerElement("data","in collection", 0, fKind, "");
1030}
1031
1032////////////////////////////////////////////////////////////////////////////////
1033/// Constructor.
1034
1035TFormLeafInfoNumerical::TFormLeafInfoNumerical(const TFormLeafInfoNumerical& orig) :
1036 TFormLeafInfo(orig),
1037 fKind(orig.fKind), fIsBool(false)
1038{
1039 fElement = new TStreamerElement("data","in collection", 0, fKind, "");
1040}
1041
1042////////////////////////////////////////////////////////////////////////////////
1043/// Exception safe swap.
1044
1045void TFormLeafInfoNumerical::Swap(TFormLeafInfoNumerical& other)
1046{
1047 TFormLeafInfo::Swap(other);
1048 std::swap(fKind,other.fKind);
1049 std::swap(fIsBool,other.fIsBool);
1050}
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// Exception safe assignment operator.
1054
1061
1062////////////////////////////////////////////////////////////////////////////////
1063/// Copy the object and all its content.
1064
1065TFormLeafInfo* TFormLeafInfoNumerical::DeepCopy() const
1066{
1067 return new TFormLeafInfoNumerical(*this);
1068}
1069
1070////////////////////////////////////////////////////////////////////////////////
1071/// Destructor
1072
1077
1078////////////////////////////////////////////////////////////////////////////////
1079/// Return true if the underlying data is a string
1080
1081bool TFormLeafInfoNumerical::IsString() const
1082{
1083 if (fIsBool) return false;
1084 return TFormLeafInfo::IsString();
1085}
1086
1087////////////////////////////////////////////////////////////////////////////////
1088/// We reloading all cached information in case the underlying class
1089/// information has changed (for example when changing from the 'emulated'
1090/// class to the real class.
1091
1092bool TFormLeafInfoNumerical::Update()
1093{
1094 //R__ASSERT(fNext==0);
1095
1096 if (fCounter) return fCounter->Update();
1097 return false;
1098}
1099
1100namespace {
1101 TStreamerElement *R__GetFakeClonesElem() {
1102 static TStreamerElement gFakeClonesElem("begin","fake",0,
1103 TStreamerInfo::kAny,
1104 "TClonesArray");
1105 return &gFakeClonesElem;
1106 }
1107}
1108
1109////////////////////////////////////////////////////////////////////////////////
1110/// \class TFormLeafInfoClones
1111/// A small helper class to implement reading a data member
1112/// on a TClonesArray object stored in a TTree.
1113
1114////////////////////////////////////////////////////////////////////////////////
1115/// Constructor.
1116
1121
1122////////////////////////////////////////////////////////////////////////////////
1123/// Constructor.
1124
1130
1131////////////////////////////////////////////////////////////////////////////////
1132/// Constructor.
1133
1140
1141////////////////////////////////////////////////////////////////////////////////
1142/// Deep Copy constructor.
1143
1148
1149////////////////////////////////////////////////////////////////////////////////
1150/// Exception safe swap.
1151
1157
1158////////////////////////////////////////////////////////////////////////////////
1159/// Exception safe assignment operator
1160
1167
1168////////////////////////////////////////////////////////////////////////////////
1169/// Return the current size of the TClonesArray
1170
1171Int_t TFormLeafInfoClones::GetCounterValue(TLeaf* leaf)
1172{
1173 if (!fCounter) {
1174 TClass *clonesClass = TClonesArray::Class();
1175 Int_t c_offset = 0;
1176 TStreamerElement *counter = ((TStreamerInfo*)clonesClass->GetStreamerInfo())->GetStreamerElement("fLast",c_offset);
1177 fCounter = new TFormLeafInfo(clonesClass,c_offset,counter);
1178 }
1179 return (Int_t)fCounter->ReadValue((char*)GetLocalValuePointer(leaf)) + 1;
1180}
1181
1182////////////////////////////////////////////////////////////////////////////////
1183/// Return the current size of the TClonesArray
1184
1185Int_t TFormLeafInfoClones::ReadCounterValue(char* where)
1186{
1187 if (!fCounter) {
1188 TClass *clonesClass = TClonesArray::Class();
1189 Int_t c_offset = 0;
1190 TStreamerElement *counter = ((TStreamerInfo*)clonesClass->GetStreamerInfo())->GetStreamerElement("fLast",c_offset);
1191 fCounter = new TFormLeafInfo(clonesClass,c_offset,counter);
1192 }
1193 return (Int_t)fCounter->ReadValue(where) + 1;
1194}
1195
1196////////////////////////////////////////////////////////////////////////////////
1197/// Return the value of the underlying data member inside the
1198/// clones array.
1199
1200template <typename T>
1201T TFormLeafInfoClones::ReadValueImpl(char *where, Int_t instance)
1202{
1203 if (fNext==nullptr) return 0;
1204 Int_t len,index,sub_instance;
1205 len = fNext->GetArrayLength();
1206 if (len) {
1207 index = instance / len;
1208 sub_instance = instance % len;
1209 } else {
1210 index = instance;
1211 sub_instance = 0;
1212 }
1213 TClonesArray * clones = (TClonesArray*)where;
1214 if (!clones) return 0;
1215 // Note we take advantage of having only one physically variable
1216 // dimension:
1217 char * obj = (char*)clones->UncheckedAt(index);
1218 return fNext->ReadTypedValue<T>(obj,sub_instance);
1219}
1220
1221INSTANTIATE_GETVAL(TFormLeafInfoClones);
1222INSTANTIATE_READVAL(TFormLeafInfoClones);
1223
1224////////////////////////////////////////////////////////////////////////////////
1225/// Return the pointer to the clonesArray
1226
1227void* TFormLeafInfoClones::GetLocalValuePointer(TLeaf *leaf, Int_t /*instance*/)
1228{
1229 TClonesArray * clones;
1230 if (fTop) {
1231 if (leaf->InheritsFrom(TLeafObject::Class()) ) {
1232 clones = (TClonesArray*)((TLeafObject*)leaf)->GetObject();
1233 } else {
1234 clones = (TClonesArray*)((TBranchElement*)leaf->GetBranch())->GetObject();
1235 }
1236 } else {
1237 clones = (TClonesArray*)TFormLeafInfo::GetLocalValuePointer(leaf);
1238 }
1239 return clones;
1240}
1241
1242////////////////////////////////////////////////////////////////////////////////
1243/// Return the address of the underlying current value
1244
1249
1250////////////////////////////////////////////////////////////////////////////////
1251/// Return the value of the underlying data member inside the
1252/// clones array.
1253
1254template <typename T>
1255T TFormLeafInfoClones::GetValueImpl(TLeaf *leaf, Int_t instance)
1256{
1257 if (fNext==nullptr) return 0;
1258 Int_t len,index,sub_instance;
1259 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1260 Int_t primary = fNext->GetPrimaryIndex();
1261 if (len) {
1262 index = instance / len;
1263 sub_instance = instance % len;
1264 } else if (primary>=0) {
1265 index = primary;
1266 sub_instance = instance;
1267 } else {
1268 index = instance;
1269 sub_instance = 0;
1270 }
1271 TClonesArray *clones = (TClonesArray*)GetLocalValuePointer(leaf);
1272 if (clones==nullptr) return 0;
1273
1274 // Note we take advantage of having only one physically variable
1275 // dimension:
1276 char * obj = (char*)clones->UncheckedAt(index);
1277 return fNext->ReadTypedValue<T>(obj,sub_instance);
1278}
1279
1280////////////////////////////////////////////////////////////////////////////////
1281/// Return the pointer to the clonesArray
1282
1283void * TFormLeafInfoClones::GetValuePointer(TLeaf *leaf, Int_t instance)
1284{
1285 TClonesArray * clones = (TClonesArray*)GetLocalValuePointer(leaf);
1286 if (fNext && clones) {
1287 // Same as in TFormLeafInfoClones::GetValue
1288 Int_t len,index,sub_instance;
1289 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1290 if (len) {
1291 index = instance / len;
1292 sub_instance = instance % len;
1293 } else {
1294 index = instance;
1295 sub_instance = 0;
1296 }
1297 return fNext->GetValuePointer((char*)clones->UncheckedAt(index),
1298 sub_instance);
1299 }
1300 return clones;
1301}
1302
1303////////////////////////////////////////////////////////////////////////////////
1304/// Return the pointer to the clonesArray
1305
1306void * TFormLeafInfoClones::GetValuePointer(char *where, Int_t instance)
1307{
1308 TClonesArray * clones = (TClonesArray*) where;
1309 if (fNext) {
1310 // Same as in TFormLeafInfoClones::GetValue
1311 Int_t len,index,sub_instance;
1312 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1313 if (len) {
1314 index = instance / len;
1315 sub_instance = instance % len;
1316 } else {
1317 index = instance;
1318 sub_instance = 0;
1319 }
1320 return fNext->GetValuePointer((char*)clones->UncheckedAt(index),
1321 sub_instance);
1322 }
1323 return clones;
1324}
1325
1326////////////////////////////////////////////////////////////////////////////////
1327/// \class TFormLeafInfoCollectionObject
1328/// A small helper class to implement reading a data member
1329/// on a TClonesArray object stored in a TTree.
1330
1331////////////////////////////////////////////////////////////////////////////////
1332/// Constructor.
1333
1338
1339////////////////////////////////////////////////////////////////////////////////
1340/// Constructor.
1341
1346
1347////////////////////////////////////////////////////////////////////////////////
1348/// Exception safe swap.
1349
1355
1356////////////////////////////////////////////////////////////////////////////////
1357/// Exception safe assignment operator
1358
1365
1366////////////////////////////////////////////////////////////////////////////////
1367/// Return the current size of the TClonesArray
1368
1369Int_t TFormLeafInfoCollectionObject::GetCounterValue(TLeaf* /* leaf */)
1370{
1371 return 1;
1372}
1373
1374////////////////////////////////////////////////////////////////////////////////
1375/// Return the value of the underlying data member inside the
1376/// clones array.
1377
1378Double_t TFormLeafInfoCollectionObject::ReadValue(char * /* where */, Int_t /* instance */)
1379{
1380 R__ASSERT(0);
1381 return 0;
1382}
1383
1384////////////////////////////////////////////////////////////////////////////////
1385/// Return the pointer to the clonesArray
1386
1387void* TFormLeafInfoCollectionObject::GetLocalValuePointer(TLeaf *leaf, Int_t /*instance*/)
1388{
1389 void* collection;
1390 if (fTop) {
1391 if (leaf->InheritsFrom(TLeafObject::Class()) ) {
1392 collection = ((TLeafObject*)leaf)->GetObject();
1393 } else {
1394 collection = ((TBranchElement*)leaf->GetBranch())->GetObject();
1395 }
1396 } else {
1397 collection = TFormLeafInfo::GetLocalValuePointer(leaf);
1398 }
1399 return collection;
1400}
1401
1402////////////////////////////////////////////////////////////////////////////////
1403/// Return the address of the underlying current value
1404
1409
1410////////////////////////////////////////////////////////////////////////////////
1411/// Return the value of the underlying data member inside the
1412/// clones array.
1413
1414template <typename T>
1415T TFormLeafInfoCollectionObject::GetValueImpl(TLeaf *leaf, Int_t instance)
1416{
1417 char * obj = (char*)GetLocalValuePointer(leaf);
1418
1419 if (fNext==nullptr) return 0;
1420 return fNext->ReadTypedValue<T>(obj,instance);
1421}
1422
1423INSTANTIATE_GETVAL(TFormLeafInfoCollectionObject);
1424
1425////////////////////////////////////////////////////////////////////////////////
1426/// Return the pointer to the clonesArray
1427
1436
1437////////////////////////////////////////////////////////////////////////////////
1438/// Return the pointer to the clonesArray
1439
1440void * TFormLeafInfoCollectionObject::GetValuePointer(char *where, Int_t instance)
1441{
1442 if (fNext) {
1443 return fNext->GetValuePointer(where,instance);
1444 }
1445 return where;
1446}
1447
1448////////////////////////////////////////////////////////////////////////////////
1449/// \class TFormLeafInfoCollection
1450/// A small helper class to implement reading a data
1451/// member on a generic collection object stored in a TTree.
1452
1453////////////////////////////////////////////////////////////////////////////////
1454/// Constructor.
1455
1456TFormLeafInfoCollection::TFormLeafInfoCollection(TClass* classptr,
1457 Longptr_t offset,
1458 TStreamerElement* element,
1459 bool top) :
1460 TFormLeafInfo(classptr,offset,element),
1461 fTop(top),
1462 fCollClass( nullptr),
1463 fCollProxy( nullptr),
1464 fLocalElement( nullptr)
1465{
1466 if (element) {
1467 fCollClass = element->GetClass();
1468 } else if (classptr) {
1469 fCollClass = classptr;
1470 }
1471 if (fCollClass
1472 && fCollClass!=TClonesArray::Class()
1473 && fCollClass->GetCollectionProxy()) {
1474
1475 fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1476 fCollClassName = fCollClass->GetName();
1477 }
1478}
1479
1480////////////////////////////////////////////////////////////////////////////////
1481/// Constructor.
1482
1483TFormLeafInfoCollection::TFormLeafInfoCollection(TClass* motherclassptr,
1484 Longptr_t offset,
1485 TClass* elementclassptr,
1486 bool top) :
1487 TFormLeafInfo(motherclassptr,offset,
1488 new TStreamerElement("collection","in class",
1489 0,
1490 TStreamerInfo::kAny,
1491 elementclassptr
1492 ? elementclassptr->GetName()
1493 : ( motherclassptr
1494 ? motherclassptr->GetName()
1495 : "Unknown")
1496 ) ),
1497 fTop(top),
1498 fCollClass( nullptr),
1499 fCollProxy( nullptr) ,
1500 fLocalElement( fElement )
1501{
1502 if (elementclassptr) {
1503 fCollClass = elementclassptr;
1504 } else if (motherclassptr) {
1505 fCollClass = motherclassptr;
1506 }
1507 if (fCollClass
1508 && fCollClass!=TClonesArray::Class()
1509 && fCollClass->GetCollectionProxy())
1510 {
1511 fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1512 fCollClassName = fCollClass->GetName();
1513 }
1514}
1515
1516////////////////////////////////////////////////////////////////////////////////
1517/// Constructor.
1518
1519TFormLeafInfoCollection::TFormLeafInfoCollection() :
1520 TFormLeafInfo(),
1521 fTop(false),
1522 fCollClass( nullptr),
1523 fCollProxy( nullptr),
1524 fLocalElement( nullptr)
1525{
1526}
1527
1528////////////////////////////////////////////////////////////////////////////////
1529/// Constructor.
1530
1531TFormLeafInfoCollection::TFormLeafInfoCollection(const TFormLeafInfoCollection& orig) :
1532 TFormLeafInfo(orig),
1533 fTop( orig.fTop),
1534 fCollClass( orig.fCollClass ),
1535 fCollClassName( orig.fCollClassName ),
1536 fCollProxy( orig.fCollProxy ? orig.fCollProxy->Generate() : nullptr ),
1537 fLocalElement( nullptr ) // humm why not initialize it?
1538{
1539}
1540
1541////////////////////////////////////////////////////////////////////////////////
1542/// Exception safe swap.
1543
1544void TFormLeafInfoCollection::Swap(TFormLeafInfoCollection &other)
1545{
1546 TFormLeafInfo::Swap(other);
1547 std::swap(fTop,other.fTop);
1548 std::swap(fClass,other.fClass);
1549 std::swap(fCollClassName,other.fCollClassName);
1550 std::swap(fCollProxy,other.fCollProxy);
1551 std::swap(fLocalElement,other.fLocalElement);
1552}
1553
1554////////////////////////////////////////////////////////////////////////////////
1555/// Exception safe assignment operator.
1556
1563
1564////////////////////////////////////////////////////////////////////////////////
1565/// Destructor.
1566
1572
1573////////////////////////////////////////////////////////////////////////////////
1574/// Copy of the object and its content.
1575
1580
1581////////////////////////////////////////////////////////////////////////////////
1582/// We reloading all cached information in case the underlying class
1583/// information has changed (for example when changing from the 'emulated'
1584/// class to the real class.
1585
1586bool TFormLeafInfoCollection::Update()
1587{
1588 bool changed = false;
1589 TClass * new_class = TClass::GetClass(fCollClassName);
1590 if (new_class!=fCollClass) {
1591 delete fCollProxy; fCollProxy = nullptr;
1592 fCollClass = new_class;
1593 if (fCollClass && fCollClass->GetCollectionProxy()) {
1594 fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1595 }
1596 changed = true;
1597 }
1598 return changed || TFormLeafInfo::Update();
1599}
1600
1601////////////////////////////////////////////////////////////////////////////////
1602/// Return true if the underlying data has a array size counter
1603
1604bool TFormLeafInfoCollection::HasCounter() const
1605{
1606 return fCounter!=nullptr || fCollProxy!=nullptr;
1607}
1608
1609////////////////////////////////////////////////////////////////////////////////
1610/// Return the current size of the TClonesArray
1611
1612Int_t TFormLeafInfoCollection::GetCounterValue(TLeaf* leaf)
1613{
1614 void *ptr = GetLocalValuePointer(leaf);
1615
1616 if (fCounter) { return (Int_t)fCounter->ReadValue((char*)ptr); }
1617
1618 R__ASSERT(fCollProxy);
1619 if (ptr==nullptr) return 0;
1620 TVirtualCollectionProxy::TPushPop helper(fCollProxy, ptr);
1621 return (Int_t)fCollProxy->Size();
1622}
1623
1624////////////////////////////////////////////////////////////////////////////////
1625/// Return the size of the underlying array for the current entry in the TTree.
1626
1627Int_t TFormLeafInfoCollection::ReadCounterValue(char* where)
1628{
1629 if (fCounter) { return (Int_t)fCounter->ReadValue(where); }
1630 R__ASSERT(fCollProxy);
1631 if (where==nullptr) return 0;
1632 void *ptr = GetLocalValuePointer(where,0);
1633 TVirtualCollectionProxy::TPushPop helper(fCollProxy, ptr);
1634 return (Int_t)fCollProxy->Size();
1635}
1636
1637////////////////////////////////////////////////////////////////////////////////
1638/// Return the current size of the TClonesArray
1639
1640Int_t TFormLeafInfoCollection::GetCounterValue(TLeaf* leaf, Int_t instance)
1641{
1642 void *ptr = GetLocalValuePointer(leaf,instance);
1643 if (fCounter) {
1644 return (Int_t)fCounter->ReadValue((char*)ptr);
1645 }
1646 R__ASSERT(fCollProxy);
1647 if (ptr==nullptr) return 0;
1648 TVirtualCollectionProxy::TPushPop helper(fCollProxy, ptr);
1649 return (Int_t)fCollProxy->Size();
1650}
1651
1652////////////////////////////////////////////////////////////////////////////////
1653/// Return the value of the underlying data member inside the
1654/// clones array.
1655
1656template <typename T>
1657T TFormLeafInfoCollection::ReadValueImpl(char *where, Int_t instance)
1658{
1659 if (fNext==nullptr) return 0;
1660 UInt_t len,index,sub_instance;
1661 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1662 Int_t primary = fNext->GetPrimaryIndex();
1663 if (len) {
1664 index = instance / len;
1665 sub_instance = instance % len;
1666 } else if (primary>=0) {
1667 index = primary;
1668 sub_instance = instance;
1669 } else {
1670 index = instance;
1671 sub_instance = 0;
1672 }
1673
1674 R__ASSERT(fCollProxy);
1675 void *ptr = GetLocalValuePointer(where,instance);
1676 TVirtualCollectionProxy::TPushPop helper(fCollProxy, ptr);
1677
1678 // Note we take advantage of having only one physically variable
1679 // dimension:
1680
1681 char * obj = (char*)fCollProxy->At(index);
1682 if (fCollProxy->HasPointers()) obj = *(char**)obj;
1683 return fNext->ReadTypedValue<T>(obj,sub_instance);
1684}
1685
1686INSTANTIATE_GETVAL(TFormLeafInfoCollection);
1687INSTANTIATE_READVAL(TFormLeafInfoCollection);
1688
1689////////////////////////////////////////////////////////////////////////////////
1690/// Return the pointer to the clonesArray
1691
1692void* TFormLeafInfoCollection::GetLocalValuePointer(TLeaf *leaf, Int_t /*instance*/)
1693{
1694 void *collection;
1695 if (fTop) {
1696 if (leaf->InheritsFrom(TLeafObject::Class()) ) {
1697 collection = ((TLeafObject*)leaf)->GetObject();
1698 } else {
1699 collection = ((TBranchElement*)leaf->GetBranch())->GetObject();
1700 }
1701 } else {
1702 collection = TFormLeafInfo::GetLocalValuePointer(leaf);
1703 }
1704 return collection;
1705}
1706
1707////////////////////////////////////////////////////////////////////////////////
1708/// Return the address of the local value
1709
1714
1715////////////////////////////////////////////////////////////////////////////////
1716/// Return the value of the underlying data member inside the
1717/// clones array.
1718
1719template <typename T>
1720T TFormLeafInfoCollection::GetValueImpl(TLeaf *leaf, Int_t instance)
1721{
1722 if (fNext==nullptr) return 0;
1723 Int_t len,index,sub_instance;
1724 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1725 Int_t primary = fNext->GetPrimaryIndex();
1726 if (len) {
1727 index = instance / len;
1728 sub_instance = instance % len;
1729 } else if (primary>=0) {
1730 index = primary;
1731 sub_instance = instance;
1732 } else {
1733 index = instance;
1734 sub_instance = 0;
1735 }
1736
1737 R__ASSERT(fCollProxy);
1738 void *coll = GetLocalValuePointer(leaf);
1739 TVirtualCollectionProxy::TPushPop helper(fCollProxy,coll);
1740
1741 // Note we take advantage of having only one physically variable
1742 // dimension:
1743 char * obj = (char*)fCollProxy->At(index);
1744 if (obj==nullptr) return 0;
1745 if (fCollProxy->HasPointers()) obj = *(char**)obj;
1746 if (obj==nullptr) return 0;
1747 return fNext->ReadTypedValue<T>(obj,sub_instance);
1748}
1749
1750////////////////////////////////////////////////////////////////////////////////
1751/// Return the pointer to the clonesArray
1752
1753void * TFormLeafInfoCollection::GetValuePointer(TLeaf *leaf, Int_t instance)
1754{
1755 R__ASSERT(fCollProxy);
1756
1757 void *collection = GetLocalValuePointer(leaf);
1758
1759 if (fNext) {
1760 // Same as in TFormLeafInfoClones::GetValue
1761 Int_t len,index,sub_instance;
1762 if (fNext->fElement &&
1763 (fNext->fNext || !fNext->IsString()) ) {
1764 len = fNext->GetArrayLength();
1765 } else {
1766 len = 0;
1767 }
1768 if (len) {
1769 index = instance / len;
1770 sub_instance = instance % len;
1771 } else {
1772 index = instance;
1773 sub_instance = 0;
1774 }
1775 TVirtualCollectionProxy::TPushPop helper(fCollProxy,collection);
1776 char * obj = (char*)fCollProxy->At(index);
1777 if (fCollProxy->HasPointers()) obj = *(char**)obj;
1778 return fNext->GetValuePointer(obj,sub_instance);
1779 }
1780 return collection;
1781}
1782
1783////////////////////////////////////////////////////////////////////////////////
1784/// Return the pointer to the clonesArray
1785
1786void * TFormLeafInfoCollection::GetValuePointer(char *where, Int_t instance)
1787{
1788 R__ASSERT(fCollProxy);
1789
1790 void *collection = where;
1791
1792 if (fNext) {
1793 // Same as in TFormLeafInfoClones::GetValue
1794 Int_t len,index,sub_instance;
1795 len = (fNext->fElement==nullptr)? 0 : fNext->GetArrayLength();
1796 if (len) {
1797 index = instance / len;
1798 sub_instance = instance % len;
1799 } else {
1800 index = instance;
1801 sub_instance = 0;
1802 }
1803 TVirtualCollectionProxy::TPushPop helper(fCollProxy,collection);
1804 char * obj = (char*)fCollProxy->At(index);
1805 if (fCollProxy->HasPointers()) obj = *(char**)obj;
1806 return fNext->GetValuePointer(obj,sub_instance);
1807 }
1808 return collection;
1809}
1810
1811////////////////////////////////////////////////////////////////////////////////
1812/// \class TFormLeafInfoCollectionSize
1813/// Used to return the size of a collection
1814
1815////////////////////////////////////////////////////////////////////////////////
1816/// Constructor.
1817
1829
1830////////////////////////////////////////////////////////////////////////////////
1831/// Constructor.
1832
1845
1846////////////////////////////////////////////////////////////////////////////////
1847/// Constructor.
1848
1849TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize() :
1850 TFormLeafInfo(), fCollClass(nullptr), fCollProxy(nullptr)
1851{
1852}
1853
1854////////////////////////////////////////////////////////////////////////////////
1855/// Constructor.
1856
1857TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize(
1858 const TFormLeafInfoCollectionSize& orig) : TFormLeafInfo(),
1859 fCollClass(orig.fCollClass),
1860 fCollClassName(orig.fCollClassName),
1861 fCollProxy(orig.fCollProxy?orig.fCollProxy->Generate():nullptr)
1862{
1863}
1864
1865////////////////////////////////////////////////////////////////////////////////
1866/// Exception safe assignment operator.
1867
1874
1875////////////////////////////////////////////////////////////////////////////////
1876/// Exception safe swap.
1877
1878void TFormLeafInfoCollectionSize::Swap(TFormLeafInfoCollectionSize &other)
1879{
1880 TFormLeafInfo::Swap(other);
1881 std::swap(fCollClass,other.fCollClass);
1882 std::swap(fCollClassName,other.fCollClassName);
1883 std::swap(fCollProxy,other.fCollProxy);
1884}
1885
1886////////////////////////////////////////////////////////////////////////////////
1887/// Destructor.
1888
1893
1894////////////////////////////////////////////////////////////////////////////////
1895/// Copy the object and all of its content.
1896
1901
1902////////////////////////////////////////////////////////////////////////////////
1903/// We reloading all cached information in case the underlying class
1904/// information has changed (for example when changing from the 'emulated'
1905/// class to the real class.
1906
1907bool TFormLeafInfoCollectionSize::Update()
1908{
1909 bool changed = false;
1910 TClass *new_class = TClass::GetClass(fCollClassName);
1911 if (new_class!=fCollClass) {
1912 delete fCollProxy; fCollProxy = nullptr;
1913 fCollClass = new_class;
1914 if (fCollClass && fCollClass->GetCollectionProxy()) {
1915 fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1916 }
1917 changed = true;
1918 }
1919 return changed;
1920}
1921
1922////////////////////////////////////////////////////////////////////////////////
1923/// Not implemented.
1924
1925void *TFormLeafInfoCollectionSize::GetValuePointer(TLeaf * /* leaf */, Int_t /* instance */)
1926{
1927 Error("GetValuePointer","This should never be called");
1928 return nullptr;
1929}
1930
1931////////////////////////////////////////////////////////////////////////////////
1932/// Not implemented.
1933
1934void *TFormLeafInfoCollectionSize::GetValuePointer(char * /* from */, Int_t /* instance */)
1935{
1936 Error("GetValuePointer","This should never be called");
1937 return nullptr;
1938}
1939
1940////////////////////////////////////////////////////////////////////////////////
1941/// Not implemented.
1942
1943void *TFormLeafInfoCollectionSize::GetLocalValuePointer(TLeaf * /* leaf */, Int_t /* instance */)
1944{
1945 Error("GetLocalValuePointer","This should never be called");
1946 return nullptr;
1947}
1948
1949////////////////////////////////////////////////////////////////////////////////
1950/// Not implemented.
1951
1952void *TFormLeafInfoCollectionSize::GetLocalValuePointer( char * /* from */, Int_t /* instance */)
1953{
1954 Error("GetLocalValuePointer","This should never be called");
1955 return nullptr;
1956}
1957
1958////////////////////////////////////////////////////////////////////////////////
1959/// Return the value of the underlying pointer data member
1960
1961Double_t TFormLeafInfoCollectionSize::ReadValue(char *where, Int_t /* instance */)
1962{
1963 R__ASSERT(fCollProxy);
1964 if (where==nullptr) return 0;
1965 void *ptr = fElement ? TFormLeafInfo::GetLocalValuePointer(where) : where;
1966 TVirtualCollectionProxy::TPushPop helper(fCollProxy, ptr);
1967 return (Int_t)fCollProxy->Size();
1968}
1969
1970////////////////////////////////////////////////////////////////////////////////
1971/// \class TFormLeafInfoPointer
1972/// A small helper class to implement reading a data
1973/// member by following a pointer inside a branch of TTree.
1974
1975////////////////////////////////////////////////////////////////////////////////
1976/// Constructor.
1977
1984
1985////////////////////////////////////////////////////////////////////////////////
1986/// Copy the object and all of its content.
1987
1988TFormLeafInfo* TFormLeafInfoPointer::DeepCopy() const
1989{
1990 return new TFormLeafInfoPointer(*this);
1991}
1992
1993////////////////////////////////////////////////////////////////////////////////
1994/// Return the value of the underlying pointer data member
1995
1996template <typename T>
1997T TFormLeafInfoPointer::ReadValueImpl(char *where, Int_t instance)
1998{
1999 if (!fNext) return 0;
2000 char * whereoffset = where+fOffset;
2001 switch (fElement->GetNewType()) {
2002 // basic types
2003 case TStreamerInfo::kObjectp:
2004 case TStreamerInfo::kObjectP:
2005 case TStreamerInfo::kAnyp:
2006 case TStreamerInfo::kAnyP:
2007 case TStreamerInfo::kSTLp:
2008 {TObject **obj = (TObject**)(whereoffset);
2009 return obj && *obj ? fNext->ReadTypedValue<T>((char*)*obj,instance) : 0; }
2010
2011 case TStreamerInfo::kObject:
2012 case TStreamerInfo::kTString:
2013 case TStreamerInfo::kTNamed:
2014 case TStreamerInfo::kTObject:
2015 case TStreamerInfo::kAny:
2016 case TStreamerInfo::kBase:
2017 case TStreamerInfo::kSTL:
2018 {
2019 TObject *obj = (TObject*)(whereoffset);
2020 return fNext->ReadTypedValue<T>((char*)obj,instance);
2021 }
2022
2023 case TStreamerInfo::kOffsetL + TStreamerInfo::kTObject:
2024 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
2025 case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
2026 {
2027 Int_t len, index, sub_instance;
2028
2029 if (fNext) len = fNext->GetArrayLength();
2030 else len = 1;
2031 if (len) {
2032 index = instance / len;
2033 sub_instance = instance % len;
2034 } else {
2035 index = instance;
2036 sub_instance = 0;
2037 }
2038
2039 whereoffset += index*fElement->GetClassPointer()->Size();
2040
2041 TObject *obj = (TObject*)(whereoffset);
2042 return fNext->ReadTypedValue<T>((char*)obj,sub_instance);
2043 }
2044
2045 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
2046 case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
2047 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
2048 case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
2049 case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
2050 {
2051 TObject *obj = (TObject*)(whereoffset);
2052 return fNext->ReadTypedValue<T>((char*)obj,instance);
2053 }
2054
2055 case kOther_t:
2056 default: return 0;
2057 }
2058
2059}
2060
2061////////////////////////////////////////////////////////////////////////////////
2062/// Return the value of the underlying pointer data member
2063
2064template <typename T>
2065T TFormLeafInfoPointer::GetValueImpl(TLeaf *leaf, Int_t instance)
2066{
2067 if (!fNext) return 0;
2068 char * where = (char*)GetLocalValuePointer(leaf,instance);
2069 if (where==nullptr) return 0;
2070 return fNext->ReadTypedValue<T>(where,instance);
2071}
2072
2073INSTANTIATE_GETVAL(TFormLeafInfoPointer);
2074INSTANTIATE_READVAL(TFormLeafInfoPointer);
2075
2076////////////////////////////////////////////////////////////////////////////////
2077/// \class TFormLeafInfoMethod
2078/// Asmall helper class to implement executing a method
2079/// of an object stored in a TTree
2080
2081////////////////////////////////////////////////////////////////////////////////
2082/// Constructor.
2083
2084TFormLeafInfoMethod::TFormLeafInfoMethod( TClass* classptr,
2085 TMethodCall *method) :
2086 TFormLeafInfo(classptr,0,nullptr),fMethod(method),
2087 fResult(0), fCopyFormat(),fDeleteFormat(),fValuePointer(nullptr),fIsByValue(false)
2088{
2089 if (method) {
2090 fMethodName = method->GetMethodName();
2091 fParams = method->GetParams();
2092 TMethodCall::EReturnType r = fMethod->ReturnType();
2093 if (r == TMethodCall::kOther) {
2094 const char* rtype = fMethod->GetMethod()->GetReturnTypeName();
2095 Long_t rprop = fMethod->GetMethod()->Property();
2096 if (rtype[strlen(rtype)-1]!='*' &&
2097 rtype[strlen(rtype)-1]!='&' &&
2098 !(rprop & (kIsPointer|kIsReference)) ) {
2099 fCopyFormat = "new ";
2100 fCopyFormat += rtype;
2101 fCopyFormat += "(*(";
2102 fCopyFormat += rtype;
2103 fCopyFormat += "*)0x%zx)";
2104
2105 fDeleteFormat = "delete (";
2106 fDeleteFormat += rtype;
2107 fDeleteFormat += "*)0x%zx";
2108
2109 fIsByValue = true;
2110 }
2111 }
2112 }
2113}
2114
2115////////////////////////////////////////////////////////////////////////////////
2116/// Constructor.
2117
2118TFormLeafInfoMethod::TFormLeafInfoMethod(const TFormLeafInfoMethod& orig)
2119 : TFormLeafInfo(orig)
2120{
2121 fMethodName = orig.fMethodName;
2122 fParams = orig.fParams ;
2123 fResult = orig.fResult;
2124 if (orig.fMethod) {
2125 fMethod = new TMethodCall();
2126 fMethod->Init(orig.fMethod->GetMethod());
2127 } else {
2128 fMethod = nullptr;
2129 }
2130 fCopyFormat = orig.fCopyFormat;
2131 fDeleteFormat = orig.fDeleteFormat;
2132 fValuePointer = nullptr;
2133 fIsByValue = orig.fIsByValue;
2134}
2135
2136
2137////////////////////////////////////////////////////////////////////////////////
2138/// Exception safe swap.
2139
2140void TFormLeafInfoMethod::Swap(TFormLeafInfoMethod &other)
2141{
2142 TFormLeafInfo::Swap(other);
2143 std::swap(fMethod,other.fMethod);
2144 std::swap(fMethodName,other.fMethodName);
2145 std::swap(fParams,other.fParams);
2146 std::swap(fResult,other.fResult);
2147 std::swap(fCopyFormat,other.fCopyFormat);
2148 std::swap(fDeleteFormat,other.fDeleteFormat);
2149 std::swap(fValuePointer,other.fValuePointer);
2150 std::swap(fIsByValue,other.fIsByValue);
2151}
2152
2153////////////////////////////////////////////////////////////////////////////////
2154/// Exception safe assignment operator.
2155
2162
2163////////////////////////////////////////////////////////////////////////////////
2164/// Destructor.
2165
2173
2174////////////////////////////////////////////////////////////////////////////////
2175/// Copy the object and all its content.
2176
2177TFormLeafInfo* TFormLeafInfoMethod::DeepCopy() const
2178{
2179 return new TFormLeafInfoMethod(*this);
2180}
2181
2182////////////////////////////////////////////////////////////////////////////////
2183/// Return the TClass corresponding to the return type of the function
2184/// if it is an object type or if the return type is a reference (&) then
2185/// return the TClass corresponding to the reference.
2186
2187TClass *TFormLeafInfoMethod::ReturnTClass(TMethodCall *mc)
2188{
2189 if (!mc || !mc->GetMethod())
2190 return nullptr;
2191
2192 std::string return_type;
2193
2194 if (0 == strcmp(mc->GetMethod()->GetReturnTypeName(), "void"))
2195 return nullptr;
2196
2197 R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
2198
2199 {
2200 TInterpreter::SuspendAutoLoadingRAII autoloadOff(gInterpreter);
2201 TClassEdit::GetNormalizedName(return_type, mc->GetMethod()->GetReturnTypeName());
2202 }
2203 // Beyond this point we no longer 'need' the lock.
2204 // How TClass::GetClass will take at least the read lock to search
2205 // So keeping it just a little longer is likely to be faster
2206 // than releasing and retaking it.
2207
2208 return_type = gInterpreter->TypeName(return_type.c_str());
2209
2210 if (return_type == "void")
2211 return nullptr;
2212
2213 return TClass::GetClass(return_type.c_str());
2214}
2215
2216////////////////////////////////////////////////////////////////////////////////
2217/// Return the type of the underlying return value
2218
2219TClass* TFormLeafInfoMethod::GetClass() const
2220{
2221 if (fNext) return fNext->GetClass();
2222 TMethodCall::EReturnType r = fMethod->ReturnType();
2223 if (r!=TMethodCall::kOther) return nullptr;
2224
2225 return ReturnTClass(fMethod);
2226}
2227
2228////////////////////////////////////////////////////////////////////////////////
2229/// Return true if the return value is integral.
2230
2231bool TFormLeafInfoMethod::IsInteger() const
2232{
2233 TMethodCall::EReturnType r = fMethod->ReturnType();
2234 if (r == TMethodCall::kLong) {
2235 return true;
2236 } else return false;
2237}
2238
2239////////////////////////////////////////////////////////////////////////////////
2240/// Return true if the return value is a string.
2241
2242bool TFormLeafInfoMethod::IsString() const
2243{
2244 if (fNext) return fNext->IsString();
2245
2246 TMethodCall::EReturnType r = fMethod->ReturnType();
2247 return (r==TMethodCall::kString);
2248}
2249
2250////////////////////////////////////////////////////////////////////////////////
2251/// We reloading all cached information in case the underlying class
2252/// information has changed (for example when changing from the 'emulated'
2253/// class to the real class.
2254
2255bool TFormLeafInfoMethod::Update()
2256{
2257 if (!TFormLeafInfo::Update()) return false;
2258 delete fMethod;
2259 fMethod = new TMethodCall(fClass, fMethodName, fParams);
2260 return true;
2261}
2262
2263////////////////////////////////////////////////////////////////////////////////
2264/// This is implemented here because some compiler want ALL the
2265/// signature of an overloaded function to be re-implemented.
2266
2272
2273////////////////////////////////////////////////////////////////////////////////
2274/// Return the address of the local underlying value.
2275
2276void *TFormLeafInfoMethod::GetLocalValuePointer(char *from,
2277 Int_t /*instance*/)
2278{
2279 void *thisobj = from;
2280 if (!thisobj) return nullptr;
2281
2282 TMethodCall::EReturnType r = fMethod->ReturnType();
2283 fResult = 0;
2284
2285 if (r == TMethodCall::kLong) {
2286 Longptr_t l = 0;
2287 fMethod->Execute(thisobj, l);
2288 fResult = (Double_t) l;
2289 // Get rid of temporary return object.
2290 gInterpreter->ClearStack();
2291 return &fResult;
2292
2293 } else if (r == TMethodCall::kDouble) {
2294 Double_t d = 0;
2295 fMethod->Execute(thisobj, d);
2296 fResult = (Double_t) d;
2297 // Get rid of temporary return object.
2298 gInterpreter->ClearStack();
2299 return &fResult;
2300
2301 } else if (r == TMethodCall::kString) {
2302 char *returntext = nullptr;
2303 fMethod->Execute(thisobj,&returntext);
2304 gInterpreter->ClearStack();
2305 return returntext;
2306
2307 } else if (r == TMethodCall::kOther) {
2308 char * char_result = nullptr;
2309 if (fIsByValue) {
2310 if (fValuePointer) {
2311 gROOT->ProcessLine(Form(fDeleteFormat.Data(),fValuePointer));
2312 fValuePointer = nullptr;
2313 }
2314 }
2315 fMethod->Execute(thisobj, &char_result);
2316 if (fIsByValue) {
2317 fValuePointer = (char*)gInterpreter->Calc(Form(fCopyFormat.Data(),char_result));
2318 char_result = (char*)fValuePointer;
2319 }
2320 gInterpreter->ClearStack();
2321 return char_result;
2322
2323 }
2324 return nullptr;
2325}
2326
2327////////////////////////////////////////////////////////////////////////////////
2328/// Execute the method on the given address
2329
2330template <typename T>
2331T TFormLeafInfoMethod::ReadValueImpl(char *where, Int_t instance)
2332{
2333 void *thisobj = where;
2334 if (!thisobj) return 0;
2335
2336 TMethodCall::EReturnType r = fMethod->ReturnType();
2337 T result = 0;
2338
2339 if (r == TMethodCall::kLong) {
2340 Longptr_t l = 0;
2341 fMethod->Execute(thisobj, l);
2342 result = (T) l;
2343
2344 } else if (r == TMethodCall::kDouble) {
2345 Double_t d = 0;
2346 fMethod->Execute(thisobj, d);
2347 result = (T) d;
2348
2349 } else if (r == TMethodCall::kString) {
2350 char *returntext = nullptr;
2351 fMethod->Execute(thisobj,&returntext);
2352 result = T((Longptr_t) returntext);
2353
2354 } else if (fNext) {
2355 char * char_result = nullptr;
2356 fMethod->Execute(thisobj, &char_result);
2357 result = fNext->ReadTypedValue<T>(char_result,instance);
2358
2359 } else fMethod->Execute(thisobj);
2360
2361 // Get rid of temporary return object.
2362 gInterpreter->ClearStack();
2363 return result;
2364}
2365
2366INSTANTIATE_READVAL(TFormLeafInfoMethod);
2367
2368////////////////////////////////////////////////////////////////////////////////
2369/// \class TFormLeafInfoMultiVarDim
2370/// A helper class to implement reading a
2371/// data member on a variable size array inside a TClonesArray object stored in
2372/// a TTree. This is the version used when the data member is inside a
2373/// non-split object.
2374
2375////////////////////////////////////////////////////////////////////////////////
2376/// Constructor.
2377
2378TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim( TClass* classptr,
2379 Longptr_t offset,
2380 TStreamerElement* element,
2381 TFormLeafInfo* parent) :
2382 TFormLeafInfo(classptr,offset,element),fNsize(0),fCounter2(nullptr),fSumOfSizes(0),
2383 fDim(0),fVirtDim(-1),fPrimaryIndex(-1),fSecondaryIndex(-1)
2384{
2385 if (element && element->InheritsFrom(TStreamerBasicPointer::Class())) {
2386 TStreamerBasicPointer * elem = (TStreamerBasicPointer*)element;
2387
2388 Int_t counterOffset = 0;
2389 TStreamerElement* counter = ((TStreamerInfo*)classptr->GetStreamerInfo())->GetStreamerElement(elem->GetCountName(),counterOffset);
2390 if (!parent) return;
2391 fCounter2 = parent->DeepCopy();
2392 TFormLeafInfo ** next = &(fCounter2->fNext);
2393 while(*next != nullptr) next = &( (*next)->fNext);
2394 *next = new TFormLeafInfo(classptr,counterOffset,counter);
2395
2396 } else Error("Constructor","Called without a proper TStreamerElement");
2397}
2398
2399////////////////////////////////////////////////////////////////////////////////
2400/// Constructor.
2401
2402TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim() :
2403 TFormLeafInfo(nullptr,0,nullptr),fNsize(0),fCounter2(nullptr),fSumOfSizes(0),
2404 fDim(0),fVirtDim(-1),fPrimaryIndex(-1),fSecondaryIndex(-1)
2405{
2406}
2407
2408////////////////////////////////////////////////////////////////////////////////
2409/// Constructor.
2410
2411TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim(const TFormLeafInfoMultiVarDim& orig) : TFormLeafInfo(orig)
2412{
2413 fNsize = orig.fNsize;
2414 orig.fSizes.Copy(fSizes);
2415 fCounter2 = orig.fCounter2?orig.fCounter2->DeepCopy():nullptr;
2416 fSumOfSizes = orig.fSumOfSizes;
2417 fDim = orig.fDim;
2418 fVirtDim = orig.fVirtDim;
2419 fPrimaryIndex = orig.fPrimaryIndex;
2420 fSecondaryIndex = orig.fSecondaryIndex;
2421}
2422
2423////////////////////////////////////////////////////////////////////////////////
2424/// Exception safe swap.
2425
2426void TFormLeafInfoMultiVarDim::Swap(TFormLeafInfoMultiVarDim &other)
2427{
2428 TFormLeafInfo::Swap(other);
2429 std::swap(fNsize,other.fNsize);
2430 std::swap(fSizes,other.fSizes);
2431 std::swap(fSumOfSizes,other.fSumOfSizes);
2432 std::swap(fDim,other.fDim);
2433 std::swap(fVirtDim,other.fVirtDim);
2434 std::swap(fPrimaryIndex,other.fPrimaryIndex);
2435 std::swap(fSecondaryIndex,other.fSecondaryIndex);
2436}
2437
2438////////////////////////////////////////////////////////////////////////////////
2439/// Exception safe assignment operator.
2440
2447
2448////////////////////////////////////////////////////////////////////////////////
2449/// Copy the object and all its content.
2450
2455
2456////////////////////////////////////////////////////////////////////////////////
2457/// Destructor.
2458
2463
2464/* The proper indexing and unwinding of index is done by prior leafinfo in the chain. */
2465//virtual Double_t TFormLeafInfoMultiVarDim::ReadValue(char *where, Int_t instance = 0) {
2466// return TFormLeafInfo::ReadValue(where,instance);
2467//}
2468
2469////////////////////////////////////////////////////////////////////////////////
2470/// Load the current array sizes.
2471
2472void TFormLeafInfoMultiVarDim::LoadSizes(TBranch* branch)
2473{
2474 if (fElement) {
2475 TLeaf *leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
2476 if (fCounter) fNsize = (Int_t)fCounter->GetValue(leaf);
2477 else fNsize = fCounter2->GetCounterValue(leaf);
2478 if (fNsize > fSizes.GetSize()) fSizes.Set(fNsize);
2479 fSumOfSizes = 0;
2480 for (Int_t i=0; i<fNsize; i++) {
2481 Int_t size = (Int_t)fCounter2->GetValue(leaf,i);
2482 fSumOfSizes += size;
2483 fSizes.AddAt( size, i );
2484 }
2485 return;
2486 }
2487 if (!fCounter2 || !fCounter) return;
2488 TBranchElement *br = dynamic_cast<TBranchElement*>(branch);
2489 R__ASSERT(br);
2490 fNsize = br->GetBranchCount()->GetNdata();
2491 if (fNsize > fSizes.GetSize()) fSizes.Set(fNsize);
2492 fSumOfSizes = 0;
2493 for (Int_t i=0; i<fNsize; i++) {
2494 Int_t size = (Int_t)fCounter2->GetValue((TLeaf*)br->GetBranchCount2()->GetListOfLeaves()->At(0),i);
2495 fSumOfSizes += size;
2496 fSizes.AddAt( size, i );
2497 }
2498}
2499
2500////////////////////////////////////////////////////////////////////////////////
2501/// Return the index value of the primary index.
2502
2507
2508////////////////////////////////////////////////////////////////////////////////
2509/// Return the size of the requested sub-array.
2510
2511Int_t TFormLeafInfoMultiVarDim::GetSize(Int_t index)
2512{
2513 if (index >= fSizes.GetSize()) {
2514 return -1;
2515 } else {
2516 return fSizes.At(index);
2517 }
2518}
2519
2520////////////////////////////////////////////////////////////////////////////////
2521/// Set the current value of the primary index.
2522
2527
2528////////////////////////////////////////////////////////////////////////////////
2529/// Set the current value of the primary index.
2530
2535
2536////////////////////////////////////////////////////////////////////////////////
2537/// Set the sizes of the sub-array.
2538
2539void TFormLeafInfoMultiVarDim::SetSize(Int_t index, Int_t val)
2540{
2541 fSumOfSizes += (val - fSizes.At(index));
2542 fSizes.AddAt(val,index);
2543}
2544
2545////////////////////////////////////////////////////////////////////////////////
2546/// Get the total size.
2547
2552
2553////////////////////////////////////////////////////////////////////////////////
2554
2555Double_t TFormLeafInfoMultiVarDim::GetValue(TLeaf * /*leaf*/,
2556 Int_t /*instance*/)
2557{
2558 /* The proper indexing and unwinding of index need to be done by prior leafinfo in the chain. */
2559 Error("GetValue","This should never be called");
2560 return 0;
2561}
2562
2563
2564////////////////////////////////////////////////////////////////////////////////
2565/// Return the index of the dimension which varies
2566/// for each elements of an enclosing array (typically a TClonesArray)
2567
2572
2573////////////////////////////////////////////////////////////////////////////////
2574/// Return the virtual index (for this expression) of the dimension which varies
2575/// for each elements of an enclosing array (typically a TClonesArray)
2576
2581
2582////////////////////////////////////////////////////////////////////////////////
2583/// We reloading all cached information in case the underlying class
2584/// information has changed (for example when changing from the 'emulated'
2585/// class to the real class.
2586
2587bool TFormLeafInfoMultiVarDim::Update()
2588{
2589 bool res = TFormLeafInfo::Update();
2590 if (fCounter2) fCounter2->Update();
2591 return res;
2592}
2593
2594////////////////////////////////////////////////////////////////////////////////
2595/// Update the sizes of the arrays.
2596
2597void TFormLeafInfoMultiVarDim::UpdateSizes(TArrayI *garr)
2598{
2599 if (!garr) return;
2600 if (garr->GetSize()<fNsize) garr->Set(fNsize);
2601 for (Int_t i=0; i<fNsize; i++) {
2602 Int_t local = fSizes.At(i);
2603 Int_t global = garr->At(i);
2604 if (global==0 || local<global) global = local;
2605 garr->AddAt(global,i);
2606 }
2607}
2608
2609////////////////////////////////////////////////////////////////////////////////
2610/// \class TFormLeafInfoMultiVarDimDirect
2611/// A small helper class to implement reading
2612/// a data member on a variable size array inside a TClonesArray object stored
2613/// in a TTree. This is the version used for split access
2614
2615////////////////////////////////////////////////////////////////////////////////
2616/// Copy the object and all its content.
2617
2622
2623////////////////////////////////////////////////////////////////////////////////
2624/// Return the underlying value.
2625
2626template <typename T>
2631
2632INSTANTIATE_GETVAL(TFormLeafInfoMultiVarDimDirect);
2633
2634////////////////////////////////////////////////////////////////////////////////
2635/// Not implemented.
2636
2637Double_t TFormLeafInfoMultiVarDimDirect::ReadValue(char * /*where*/, Int_t /*instance*/)
2638{
2639 Error("ReadValue","This should never be called");
2640 return 0;
2641}
2642
2643////////////////////////////////////////////////////////////////////////////////
2644/// \class TFormLeafInfoMultiVarDimCollection
2645/// A small helper class to implement reading
2646/// a data member on a variable size array inside a TClonesArray object stored
2647/// in a TTree. This is the version used for split access
2648
2649////////////////////////////////////////////////////////////////////////////////
2650/// Constructor.
2651
2652TFormLeafInfoMultiVarDimCollection::TFormLeafInfoMultiVarDimCollection(
2653 TClass* motherclassptr,
2654 Longptr_t offset,
2655 TClass* elementclassptr,
2656 TFormLeafInfo *parent) :
2657 TFormLeafInfoMultiVarDim(motherclassptr,offset,
2658 new TStreamerElement("collection","in class",
2659 0,
2660 TStreamerInfo::kAny,
2661 elementclassptr
2662 ? elementclassptr->GetName()
2663 : ( motherclassptr
2664 ? motherclassptr->GetName()
2665 : "Unknown")
2666 )
2667 )
2668{
2669 R__ASSERT(parent);
2670 fCounter = parent->DeepCopy();
2671 fCounter2 = parent->DeepCopy();
2672 TFormLeafInfo ** next = &(fCounter2->fNext);
2673 while(*next != nullptr) next = &( (*next)->fNext);
2674 *next = new TFormLeafInfoCollectionSize(elementclassptr);
2675}
2676
2677////////////////////////////////////////////////////////////////////////////////
2678/// Constructor.
2679
2680TFormLeafInfoMultiVarDimCollection::TFormLeafInfoMultiVarDimCollection(
2681 TClass* motherclassptr,
2682 Longptr_t offset,
2683 TStreamerElement* element,
2684 TFormLeafInfo *parent) :
2685 TFormLeafInfoMultiVarDim(motherclassptr,offset,element)
2686{
2687 R__ASSERT(parent && element);
2688 fCounter = parent->DeepCopy();
2689 fCounter2 = parent->DeepCopy();
2690 TFormLeafInfo ** next = &(fCounter2->fNext);
2691 while(*next != nullptr) next = &( (*next)->fNext);
2692 *next = new TFormLeafInfoCollectionSize(motherclassptr,offset,element);
2693}
2694
2695////////////////////////////////////////////////////////////////////////////////
2696/// Copy the object and all its content.
2697
2702
2703////////////////////////////////////////////////////////////////////////////////
2704
2705Double_t TFormLeafInfoMultiVarDimCollection::GetValue(TLeaf * /* leaf */,
2706 Int_t /* instance */)
2707{
2708 /* The proper indexing and unwinding of index need to be done by prior leafinfo in the chain. */
2709 Error("GetValue","This should never be called");
2710 return 0;
2711}
2712
2713////////////////////////////////////////////////////////////////////////////////
2714/// Load the current array sizes.
2715
2716void TFormLeafInfoMultiVarDimCollection::LoadSizes(TBranch* branch)
2717{
2718 R__ASSERT(fCounter2);
2719
2720 TLeaf *leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
2721 fNsize = (Int_t)fCounter->GetCounterValue(leaf);
2722
2723 if (fNsize > fSizes.GetSize()) fSizes.Set(fNsize);
2724 fSumOfSizes = 0;
2725 for (Int_t i=0; i<fNsize; i++) {
2726 Int_t size = (Int_t)fCounter2->GetValue(leaf,i);
2727 fSumOfSizes += size;
2728 fSizes.AddAt( size, i );
2729 }
2730 return;
2731}
2732
2733////////////////////////////////////////////////////////////////////////////////
2734/// Return the value of the underlying data.
2735
2736template <typename T>
2737T TFormLeafInfoMultiVarDimCollection::ReadValueImpl(char *where, Int_t instance)
2738{
2739 if (fSecondaryIndex>=0) {
2740 UInt_t len = fNext->GetArrayLength();
2741 if (len) {
2742 instance = fSecondaryIndex*len;
2743 } else {
2744 instance = fSecondaryIndex;
2745 }
2746 }
2747 return fNext->ReadTypedValue<T>(where,instance);
2748}
2749
2750INSTANTIATE_READVAL(TFormLeafInfoMultiVarDimCollection);
2751
2752
2753////////////////////////////////////////////////////////////////////////////////
2754/// \class TFormLeafInfoMultiVarDimClones
2755/// A small helper class to implement reading
2756/// a data member on a variable size array inside a TClonesArray object stored
2757/// in a TTree. This is the version used for split access
2758
2759////////////////////////////////////////////////////////////////////////////////
2760/// Constructor.
2761
2762TFormLeafInfoMultiVarDimClones::TFormLeafInfoMultiVarDimClones(
2763 TClass* motherclassptr,
2764 Longptr_t offset,
2765 TClass* elementclassptr,
2766 TFormLeafInfo *parent) :
2767 TFormLeafInfoMultiVarDim(motherclassptr,offset,
2768 new TStreamerElement("clones","in class",
2769 0,
2770 TStreamerInfo::kAny,
2771 elementclassptr
2772 ? elementclassptr->GetName()
2773 : ( motherclassptr
2774 ? motherclassptr->GetName()
2775 : "Unknown")
2776 )
2777 )
2778{
2779 R__ASSERT(parent);
2780 fCounter = parent->DeepCopy();
2781 fCounter2 = parent->DeepCopy();
2782 TFormLeafInfo ** next = &(fCounter2->fNext);
2783 while(*next != nullptr) next = &( (*next)->fNext);
2784 *next = new TFormLeafInfoClones(elementclassptr);
2785}
2786
2787////////////////////////////////////////////////////////////////////////////////
2788/// Constructor.
2789
2790TFormLeafInfoMultiVarDimClones::TFormLeafInfoMultiVarDimClones(
2791 TClass* motherclassptr,
2792 Longptr_t offset,
2793 TStreamerElement* element,
2794 TFormLeafInfo *parent) :
2795 TFormLeafInfoMultiVarDim(motherclassptr,offset,element)
2796{
2797 R__ASSERT(parent && element);
2798 fCounter = parent->DeepCopy();
2799 fCounter2 = parent->DeepCopy();
2800 TFormLeafInfo ** next = &(fCounter2->fNext);
2801 while(*next != nullptr) next = &( (*next)->fNext);
2802 *next = new TFormLeafInfoClones(motherclassptr,offset,element);
2803}
2804
2805////////////////////////////////////////////////////////////////////////////////
2806/// Copy the object and all its data.
2807
2812
2813////////////////////////////////////////////////////////////////////////////////
2814
2815Double_t TFormLeafInfoMultiVarDimClones::GetValue(TLeaf * /* leaf */,
2816 Int_t /* instance */)
2817{
2818 /* The proper indexing and unwinding of index need to be done by prior leafinfo in the chain. */
2819 Error("GetValue","This should never be called");
2820 return 0;
2821}
2822
2823////////////////////////////////////////////////////////////////////////////////
2824/// Load the current array sizes.
2825
2826void TFormLeafInfoMultiVarDimClones::LoadSizes(TBranch* branch)
2827{
2828 R__ASSERT(fCounter2);
2829
2830 TLeaf *leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
2831 fNsize = (Int_t)fCounter->GetCounterValue(leaf);
2832
2833 if (fNsize > fSizes.GetSize()) fSizes.Set(fNsize);
2834 fSumOfSizes = 0;
2835 for (Int_t i=0; i<fNsize; i++) {
2836 TClonesArray *clones = (TClonesArray*)fCounter2->GetValuePointer(leaf,i);
2837 if (clones) {
2838 Int_t size = clones->GetEntries();
2839 fSumOfSizes += size;
2840 fSizes.AddAt( size, i );
2841 }
2842 }
2843 return;
2844}
2845
2846////////////////////////////////////////////////////////////////////////////////
2847/// Return the value of the underlying data.
2848
2849template <typename T>
2850T TFormLeafInfoMultiVarDimClones::ReadValueImpl(char *where, Int_t instance)
2851{
2852 if (fSecondaryIndex>=0) {
2853 UInt_t len = fNext->GetArrayLength();
2854 if (len) {
2855 instance = fSecondaryIndex*len;
2856 } else {
2857 instance = fSecondaryIndex;
2858 }
2859 }
2860 return fNext->ReadTypedValue<T>(where,instance);
2861}
2862
2863INSTANTIATE_READVAL(TFormLeafInfoMultiVarDimClones);
2864
2865////////////////////////////////////////////////////////////////////////////////
2866/// \class TFormLeafInfoCast
2867/// A small helper class to implement casting an object to
2868/// a different type (equivalent to dynamic_cast)
2869
2870////////////////////////////////////////////////////////////////////////////////
2871/// Constructor.
2872
2873TFormLeafInfoCast::TFormLeafInfoCast(TClass* classptr, TClass* casted) :
2874 TFormLeafInfo(classptr),fCasted(casted),fGoodCast(true)
2875{
2876 if (casted) { fCastedName = casted->GetName(); }
2877 fMultiplicity = -1;
2878 fIsTObject = fClass->IsTObject() && fCasted->IsLoaded();
2879}
2880
2881////////////////////////////////////////////////////////////////////////////////
2882/// Constructor.
2883
2884TFormLeafInfoCast::TFormLeafInfoCast(const TFormLeafInfoCast& orig) :
2885 TFormLeafInfo(orig)
2886{
2887 fCasted = orig.fCasted;
2888 fCastedName = orig.fCastedName;
2889 fGoodCast = orig.fGoodCast;
2890 fIsTObject = orig.fIsTObject;
2891}
2892
2893////////////////////////////////////////////////////////////////////////////////
2894/// Exception safe swap.
2895
2896void TFormLeafInfoCast::Swap(TFormLeafInfoCast &other)
2897{
2898 TFormLeafInfo::Swap(other);
2899 std::swap(fCasted,other.fCasted);
2900 std::swap(fCastedName,other.fCastedName);
2901 std::swap(fGoodCast,other.fGoodCast);
2902 std::swap(fIsTObject,other.fIsTObject);
2903}
2904
2905////////////////////////////////////////////////////////////////////////////////
2906/// Exception safe assignment operator.
2907
2908TFormLeafInfoCast &TFormLeafInfoCast::operator=(const TFormLeafInfoCast &other)
2909{
2910 TFormLeafInfoCast tmp(other);
2911 Swap(tmp);
2912 return *this;
2913}
2914
2915////////////////////////////////////////////////////////////////////////////////
2916/// Copy the object and all its content.
2917
2918TFormLeafInfo* TFormLeafInfoCast::DeepCopy() const
2919{
2920 return new TFormLeafInfoCast(*this);
2921}
2922
2923////////////////////////////////////////////////////////////////////////////////
2924/// Destructor.
2925
2929
2930// Currently only implemented in TFormLeafInfoCast
2931Int_t TFormLeafInfoCast::GetNdata()
2932{
2933 // Get the number of element in the entry.
2934
2935 if (!fGoodCast) return 0;
2936 if (fNext) return fNext->GetNdata();
2937 return 1;
2938}
2939
2940////////////////////////////////////////////////////////////////////////////////
2941/// Read the value at the given memory location
2942
2943template <typename T>
2944T TFormLeafInfoCast::ReadValueImpl(char *where, Int_t instance)
2945{
2946 if (!fNext) return 0;
2947
2948 // First check that the real class inherits from the
2949 // casted class
2950 // First assume TObject ...
2951 if ( fIsTObject && !((TObject*)where)->InheritsFrom(fCasted) ) {
2952 fGoodCast = false;
2953 return 0;
2954 } else {
2955 // We know we have a TBranchElement and we need to find out the
2956 // real class name.
2957 }
2958 fGoodCast = true;
2959 return fNext->ReadTypedValue<T>(where,instance);
2960}
2961
2962INSTANTIATE_READVAL(TFormLeafInfoCast);
2963
2964
2965////////////////////////////////////////////////////////////////////////////////
2966/// We reloading all cached information in case the underlying class
2967/// information has changed (for example when changing from the 'emulated'
2968/// class to the real class.
2969
2970bool TFormLeafInfoCast::Update()
2971{
2972 if (fCasted) {
2973 TClass * new_class = TClass::GetClass(fCastedName);
2974 if (new_class!=fCasted) {
2975 fCasted = new_class;
2976 }
2977 }
2978 return TFormLeafInfo::Update();
2979}
2980
2981////////////////////////////////////////////////////////////////////////////////
2982/// \class TFormLeafInfoTTree
2983/// A small helper class to implement reading
2984/// from the containing TTree object itself.
2985
2986
2987////////////////////////////////////////////////////////////////////////////////
2988/// Constructor.
2989
2990TFormLeafInfoTTree::TFormLeafInfoTTree(TTree *tree, const char *alias, TTree *current) :
2991TFormLeafInfo( TTree::Class(), 0, nullptr ), fTree(tree),fCurrent(current),fAlias(alias)
2992{
2993 if (fCurrent==nullptr) fCurrent = fTree->GetFriend(alias);
2994}
2995
2996TFormLeafInfoTTree::TFormLeafInfoTTree(const TFormLeafInfoTTree& orig) :
2997 TFormLeafInfo(orig)
2998{
2999 // Copy Constructor.
3000 fTree = orig.fTree;
3001 fAlias = orig.fAlias;
3002 fCurrent = orig.fCurrent;
3003}
3004
3005////////////////////////////////////////////////////////////////////////////////
3006/// Copy the object and all its content.
3007
3008TFormLeafInfo* TFormLeafInfoTTree::DeepCopy() const
3009{
3010 return new TFormLeafInfoTTree(*this);
3011}
3012
3013////////////////////////////////////////////////////////////////////////////////
3014/// returns the address of the value pointed to by the
3015/// TFormLeafInfo.
3016
3021
3022////////////////////////////////////////////////////////////////////////////////
3023/// Return result of a leafobject method.
3024
3025template <typename T>
3030
3031////////////////////////////////////////////////////////////////////////////////
3032/// Return result of a leafobject method.
3033
3034template <typename T>
3035T TFormLeafInfoTTree::ReadValueImpl(char *thisobj, Int_t instance)
3036{
3037 if (fElement) return TFormLeafInfo::ReadTypedValue<T>(thisobj,instance);
3038 else if (fNext) return fNext->ReadTypedValue<T>(thisobj,instance);
3039 else return 0;
3040}
3041
3042INSTANTIATE_GETVAL(TFormLeafInfoTTree);
3043INSTANTIATE_READVAL(TFormLeafInfoTTree);
3044
3045////////////////////////////////////////////////////////////////////////////////
3046/// Update after a change of file in a chain
3047
3048bool TFormLeafInfoTTree::Update()
3049{
3050 if (fAlias.Length() && fAlias != fTree->GetName()) {
3051 fCurrent = fTree->GetFriend(fAlias.Data());
3052 }
3053 return fCurrent && TFormLeafInfo::Update();
3054}
fClass
Cppyy::TCppType_t fClass
Definition DeclareConverters.h:289
d
#define d(i)
Definition RSha256.hxx:102
instance
static Roo_reg_AGKInteg1D instance
Definition RooAdaptiveGaussKronrodIntegrator1D.cxx:151
size
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
Int_t
int Int_t
Definition RtypesCore.h:45
Longptr_t
long Longptr_t
Definition RtypesCore.h:75
Char_t
char Char_t
Definition RtypesCore.h:37
ULong_t
unsigned long ULong_t
Definition RtypesCore.h:55
Long_t
long Long_t
Definition RtypesCore.h:54
Float_t
float Float_t
Definition RtypesCore.h:57
Short_t
short Short_t
Definition RtypesCore.h:39
Double_t
double Double_t
Definition RtypesCore.h:59
TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358
EDataType
EDataType
Definition TDataType.h:28
kNoType_t
@ kNoType_t
Definition TDataType.h:33
kChar_t
@ kChar_t
Definition TDataType.h:29
kOther_t
@ kOther_t
Definition TDataType.h:32
kIsPointer
@ kIsPointer
Definition TDictionary.h:78
kIsReference
@ kIsReference
Definition TDictionary.h:82
R__ASSERT
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:125
INSTANTIATE_GETVAL
#define INSTANTIATE_GETVAL(CLASS)
Definition TFormLeafInfo.cxx:66
INSTANTIATE_READVAL
#define INSTANTIATE_READVAL(CLASS)
Definition TFormLeafInfo.cxx:60
GET_ARRAY
#define GET_ARRAY(TYPE_t)
offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Definition TGWin32VirtualXProxy.cxx:245
r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Definition TGWin32VirtualXProxy.cxx:168
result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Definition TGWin32VirtualXProxy.cxx:174
index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Definition TGWin32VirtualXProxy.cxx:168
len
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Definition TGWin32VirtualXProxy.cxx:249
type
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Definition TGWin32VirtualXProxy.cxx:249
gInterpreter
#define gInterpreter
Definition TInterpreter.h:571
gROOT
#define gROOT
Definition TROOT.h:414
READ_ARRAY
#define READ_ARRAY(TYPE_t)
Class
static TClass * Class()
Definition Class.C:29
Form
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
R__WRITE_LOCKGUARD
#define R__WRITE_LOCKGUARD(mutex)
Definition TVirtualRWMutex.h:157
TArrayI
Array of integers (32 bits per element).
Definition TArrayI.h:27
TArrayI::Set
void Set(Int_t n) override
Set size of this array to n ints.
Definition TArrayI.cxx:105
TArrayI::At
Int_t At(Int_t i) const
Definition TArrayI.h:79
TArrayI::AddAt
void AddAt(Int_t c, Int_t i)
Add Int_t c at position i. Check for out of bounds.
Definition TArrayI.cxx:93
TArray::GetSize
Int_t GetSize() const
Definition TArray.h:47
TBranchElement
A Branch for the case of an object.
Definition TBranchElement.h:39
TBranch
A TTree is a list of TBranches.
Definition TBranch.h:93
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
TClass::Size
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5844
TClass::IsLoaded
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition TClass.cxx:6055
TClass::IsTObject
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition TClass.cxx:6081
TClass::GetStreamerInfo
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4727
TClass::GetCollectionProxy
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:3003
TClass::GetClass
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition TClass.cxx:3074
TClonesArray
An array of clone (identical) objects.
Definition TClonesArray.h:29
TClonesArray::Class
static TClass * Class()
TFormLeafInfoCast
A small helper class to implement casting an object to a different type (equivalent to dynamic_cast)
Definition TFormLeafInfo.h:500
TFormLeafInfoCast::fIsTObject
bool fIsTObject
Marked by ReadValue.
Definition TFormLeafInfo.h:505
TFormLeafInfoCast::fCastedName
TString fCastedName
Pointer to the class we are trying to case to.
Definition TFormLeafInfo.h:503
TFormLeafInfoCast::Swap
void Swap(TFormLeafInfoCast &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:2896
TFormLeafInfoCast::~TFormLeafInfoCast
~TFormLeafInfoCast() override
Destructor.
Definition TFormLeafInfo.cxx:2926
TFormLeafInfoCast::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:2970
TFormLeafInfoCast::TFormLeafInfoCast
TFormLeafInfoCast(TClass *classptr=nullptr, TClass *casted=nullptr)
Indicated whether the fClass inherits from TObject.
Definition TFormLeafInfo.cxx:2873
TFormLeafInfoCast::GetNdata
Int_t GetNdata() override
Get the number of element in the entry.
Definition TFormLeafInfo.cxx:2931
TFormLeafInfoCast::fGoodCast
bool fGoodCast
Name of the class we are casting to.
Definition TFormLeafInfo.h:504
TFormLeafInfoCast::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:2918
TFormLeafInfoCast::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Read the value at the given memory location.
Definition TFormLeafInfo.cxx:2944
TFormLeafInfoCast::operator=
TFormLeafInfoCast & operator=(const TFormLeafInfoCast &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:2908
TFormLeafInfoClones
A small helper class to implement reading a data member on a TClonesArray object stored in a TTree.
Definition TFormLeafInfo.h:231
TFormLeafInfoClones::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1201
TFormLeafInfoClones::ReadCounterValue
Int_t ReadCounterValue(char *where) override
Return the current size of the TClonesArray.
Definition TFormLeafInfo.cxx:1185
TFormLeafInfoClones::GetCounterValue
Int_t GetCounterValue(TLeaf *leaf) override
Return the current size of the TClonesArray.
Definition TFormLeafInfo.cxx:1171
TFormLeafInfoClones::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1227
TFormLeafInfoClones::operator=
TFormLeafInfoClones & operator=(const TFormLeafInfoClones &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:1161
TFormLeafInfoClones::TFormLeafInfoClones
TFormLeafInfoClones(TClass *classptr=nullptr, Longptr_t offset=0)
Constructor.
Definition TFormLeafInfo.cxx:1117
TFormLeafInfoClones::Swap
void Swap(TFormLeafInfoClones &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:1152
TFormLeafInfoClones::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1255
TFormLeafInfoClones::GetValuePointer
void * GetValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1283
TFormLeafInfoCollectionObject
A small helper class to implement reading a data member on a TClonesArray object stored in a TTree.
Definition TFormLeafInfo.h:204
TFormLeafInfoCollectionObject::Swap
void Swap(TFormLeafInfoCollectionObject &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:1350
TFormLeafInfoCollectionObject::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1387
TFormLeafInfoCollectionObject::GetCounterValue
Int_t GetCounterValue(TLeaf *leaf) override
Return the current size of the TClonesArray.
Definition TFormLeafInfo.cxx:1369
TFormLeafInfoCollectionObject::GetValuePointer
void * GetValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1428
TFormLeafInfoCollectionObject::TFormLeafInfoCollectionObject
TFormLeafInfoCollectionObject(TClass *classptr=nullptr, bool fTop=true)
Constructor.
Definition TFormLeafInfo.cxx:1334
TFormLeafInfoCollectionObject::operator=
TFormLeafInfoCollectionObject & operator=(const TFormLeafInfoCollectionObject &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:1359
TFormLeafInfoCollectionObject::ReadValue
Double_t ReadValue(char *where, Int_t instance=0) override
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1378
TFormLeafInfoCollectionObject::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1415
TFormLeafInfoCollectionSize
Used to return the size of a collection.
Definition TFormLeafInfo.h:306
TFormLeafInfoCollectionSize::fCollProxy
TVirtualCollectionProxy * fCollProxy
Definition TFormLeafInfo.h:309
TFormLeafInfoCollectionSize::ReadValue
Double_t ReadValue(char *where, Int_t instance=0) override
Return the value of the underlying pointer data member.
Definition TFormLeafInfo.cxx:1961
TFormLeafInfoCollectionSize::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
Not implemented.
Definition TFormLeafInfo.cxx:1943
TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize
TFormLeafInfoCollectionSize()
Constructor.
Definition TFormLeafInfo.cxx:1849
TFormLeafInfoCollectionSize::Swap
void Swap(TFormLeafInfoCollectionSize &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:1878
TFormLeafInfoCollectionSize::GetValuePointer
void * GetValuePointer(TLeaf *leaf, Int_t instance=0) override
Not implemented.
Definition TFormLeafInfo.cxx:1925
TFormLeafInfoCollectionSize::~TFormLeafInfoCollectionSize
~TFormLeafInfoCollectionSize() override
Destructor.
Definition TFormLeafInfo.cxx:1889
TFormLeafInfoCollectionSize::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all of its content.
Definition TFormLeafInfo.cxx:1897
TFormLeafInfoCollectionSize::operator=
TFormLeafInfoCollectionSize & operator=(const TFormLeafInfoCollectionSize &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:1868
TFormLeafInfoCollectionSize::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:1907
TFormLeafInfoCollection
A small helper class to implement reading a data member on a generic collection object stored in a TT...
Definition TFormLeafInfo.h:261
TFormLeafInfoCollection::fCollProxy
TVirtualCollectionProxy * fCollProxy
Definition TFormLeafInfo.h:266
TFormLeafInfoCollection::GetCounterValue
Int_t GetCounterValue(TLeaf *leaf) override
Return the current size of the TClonesArray.
Definition TFormLeafInfo.cxx:1612
TFormLeafInfoCollection::TFormLeafInfoCollection
TFormLeafInfoCollection()
Constructor.
Definition TFormLeafInfo.cxx:1519
TFormLeafInfoCollection::GetValuePointer
void * GetValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1753
TFormLeafInfoCollection::HasCounter
bool HasCounter() const override
Return true if the underlying data has a array size counter.
Definition TFormLeafInfo.cxx:1604
TFormLeafInfoCollection::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy of the object and its content.
Definition TFormLeafInfo.cxx:1576
TFormLeafInfoCollection::~TFormLeafInfoCollection
~TFormLeafInfoCollection() override
Destructor.
Definition TFormLeafInfo.cxx:1567
TFormLeafInfoCollection::Swap
void Swap(TFormLeafInfoCollection &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:1544
TFormLeafInfoCollection::ReadCounterValue
Int_t ReadCounterValue(char *where) override
Return the size of the underlying array for the current entry in the TTree.
Definition TFormLeafInfo.cxx:1627
TFormLeafInfoCollection::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the pointer to the clonesArray.
Definition TFormLeafInfo.cxx:1692
TFormLeafInfoCollection::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:1586
TFormLeafInfoCollection::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1657
TFormLeafInfoCollection::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the value of the underlying data member inside the clones array.
Definition TFormLeafInfo.cxx:1720
TFormLeafInfoCollection::fLocalElement
TStreamerElement * fLocalElement
Definition TFormLeafInfo.h:267
TFormLeafInfoCollection::operator=
TFormLeafInfoCollection & operator=(const TFormLeafInfoCollection &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:1557
TFormLeafInfoDirect
A small helper class to implement reading a data member on an object stored in a TTree.
Definition TFormLeafInfo.h:162
TFormLeafInfoDirect::TFormLeafInfoDirect
TFormLeafInfoDirect(TBranchElement *from)
Constructor.
Definition TFormLeafInfo.cxx:943
TFormLeafInfoDirect::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the underlying value.
Definition TFormLeafInfo.cxx:970
TFormLeafInfoDirect::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
Return the address of the underlying value.
Definition TFormLeafInfo.cxx:980
TFormLeafInfoDirect::ReadValue
Double_t ReadValue(char *, Int_t=0) override
Read the value at the given memory location.
Definition TFormLeafInfo.cxx:960
TFormLeafInfoDirect::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy this object and its content.
Definition TFormLeafInfo.cxx:952
TFormLeafInfoMethod
Asmall helper class to implement executing a method of an object stored in a TTree.
Definition TFormLeafInfo.h:352
TFormLeafInfoMethod::TFormLeafInfoMethod
TFormLeafInfoMethod(TClass *classptr=nullptr, TMethodCall *method=nullptr)
Constructor.
Definition TFormLeafInfo.cxx:2084
TFormLeafInfoMethod::ReturnTClass
static TClass * ReturnTClass(TMethodCall *mc)
Return the TClass corresponding to the return type of the function if it is an object type or if the ...
Definition TFormLeafInfo.cxx:2187
TFormLeafInfoMethod::operator=
TFormLeafInfoMethod & operator=(const TFormLeafInfoMethod &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:2156
TFormLeafInfoMethod::IsInteger
bool IsInteger() const override
Return true if the return value is integral.
Definition TFormLeafInfo.cxx:2231
TFormLeafInfoMethod::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:2177
TFormLeafInfoMethod::IsString
bool IsString() const override
Return true if the return value is a string.
Definition TFormLeafInfo.cxx:2242
TFormLeafInfoMethod::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Execute the method on the given address.
Definition TFormLeafInfo.cxx:2331
TFormLeafInfoMethod::fMethod
TMethodCall * fMethod
Definition TFormLeafInfo.h:354
TFormLeafInfoMethod::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *from, Int_t instance=0) override
This is implemented here because some compiler want ALL the signature of an overloaded function to be...
Definition TFormLeafInfo.cxx:2267
TFormLeafInfoMethod::GetClass
TClass * GetClass() const override
Return the type of the underlying return value.
Definition TFormLeafInfo.cxx:2219
TFormLeafInfoMethod::Swap
void Swap(TFormLeafInfoMethod &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:2140
TFormLeafInfoMethod::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:2255
TFormLeafInfoMethod::~TFormLeafInfoMethod
~TFormLeafInfoMethod() override
Destructor.
Definition TFormLeafInfo.cxx:2166
TFormLeafInfoMultiVarDimClones
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:479
TFormLeafInfoMultiVarDimClones::GetValue
Double_t GetValue(TLeaf *leaf, Int_t instance=0) override
Definition TFormLeafInfo.cxx:2815
TFormLeafInfoMultiVarDimClones::TFormLeafInfoMultiVarDimClones
TFormLeafInfoMultiVarDimClones(TClass *motherclassptr, Longptr_t offset, TClass *elementclassptr, TFormLeafInfo *parent)
Constructor.
Definition TFormLeafInfo.cxx:2762
TFormLeafInfoMultiVarDimClones::LoadSizes
void LoadSizes(TBranch *branch) override
Load the current array sizes.
Definition TFormLeafInfo.cxx:2826
TFormLeafInfoMultiVarDimClones::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return the value of the underlying data.
Definition TFormLeafInfo.cxx:2850
TFormLeafInfoMultiVarDimClones::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its data.
Definition TFormLeafInfo.cxx:2808
TFormLeafInfoMultiVarDimCollection
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:457
TFormLeafInfoMultiVarDimCollection::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:2698
TFormLeafInfoMultiVarDimCollection::TFormLeafInfoMultiVarDimCollection
TFormLeafInfoMultiVarDimCollection(TClass *motherclassptr, Longptr_t offset, TClass *elementclassptr, TFormLeafInfo *parent)
Constructor.
Definition TFormLeafInfo.cxx:2652
TFormLeafInfoMultiVarDimCollection::GetValue
Double_t GetValue(TLeaf *leaf, Int_t instance=0) override
Definition TFormLeafInfo.cxx:2705
TFormLeafInfoMultiVarDimCollection::LoadSizes
void LoadSizes(TBranch *branch) override
Load the current array sizes.
Definition TFormLeafInfo.cxx:2716
TFormLeafInfoMultiVarDimCollection::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return the value of the underlying data.
Definition TFormLeafInfo.cxx:2737
TFormLeafInfoMultiVarDimDirect
A small helper class to implement reading a data member on a variable size array inside a TClonesArra...
Definition TFormLeafInfo.h:441
TFormLeafInfoMultiVarDimDirect::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:2618
TFormLeafInfoMultiVarDimDirect::ReadValue
Double_t ReadValue(char *, Int_t=0) override
Not implemented.
Definition TFormLeafInfo.cxx:2637
TFormLeafInfoMultiVarDimDirect::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the underlying value.
Definition TFormLeafInfo.cxx:2627
TFormLeafInfoMultiVarDim
A helper class to implement reading a data member on a variable size array inside a TClonesArray obje...
Definition TFormLeafInfo.h:389
TFormLeafInfoMultiVarDim::GetSize
Int_t GetSize(Int_t index) override
Return the size of the requested sub-array.
Definition TFormLeafInfo.cxx:2511
TFormLeafInfoMultiVarDim::UpdateSizes
void UpdateSizes(TArrayI *garr) override
Update the sizes of the arrays.
Definition TFormLeafInfo.cxx:2597
TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim
TFormLeafInfoMultiVarDim()
Constructor.
Definition TFormLeafInfo.cxx:2402
TFormLeafInfoMultiVarDim::fCounter2
TFormLeafInfo * fCounter2
Definition TFormLeafInfo.h:393
TFormLeafInfoMultiVarDim::SetPrimaryIndex
void SetPrimaryIndex(Int_t index) override
Set the current value of the primary index.
Definition TFormLeafInfo.cxx:2523
TFormLeafInfoMultiVarDim::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:2451
TFormLeafInfoMultiVarDim::Swap
void Swap(TFormLeafInfoMultiVarDim &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:2426
TFormLeafInfoMultiVarDim::operator=
TFormLeafInfoMultiVarDim & operator=(const TFormLeafInfoMultiVarDim &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:2441
TFormLeafInfoMultiVarDim::GetPrimaryIndex
Int_t GetPrimaryIndex() override
Return the index value of the primary index.
Definition TFormLeafInfo.cxx:2503
TFormLeafInfoMultiVarDim::GetVarDim
Int_t GetVarDim() override
Return the index of the dimension which varies for each elements of an enclosing array (typically a T...
Definition TFormLeafInfo.cxx:2568
TFormLeafInfoMultiVarDim::GetSumOfSizes
Int_t GetSumOfSizes() override
Get the total size.
Definition TFormLeafInfo.cxx:2548
TFormLeafInfoMultiVarDim::GetValue
Double_t GetValue(TLeaf *, Int_t=0) override
Definition TFormLeafInfo.cxx:2555
TFormLeafInfoMultiVarDim::GetVirtVarDim
Int_t GetVirtVarDim() override
Return the virtual index (for this expression) of the dimension which varies for each elements of an ...
Definition TFormLeafInfo.cxx:2577
TFormLeafInfoMultiVarDim::LoadSizes
void LoadSizes(TBranch *branch) override
Load the current array sizes.
Definition TFormLeafInfo.cxx:2472
TFormLeafInfoMultiVarDim::SetSecondaryIndex
void SetSecondaryIndex(Int_t index) override
Set the current value of the primary index.
Definition TFormLeafInfo.cxx:2531
TFormLeafInfoMultiVarDim::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:2587
TFormLeafInfoMultiVarDim::SetSize
void SetSize(Int_t index, Int_t val) override
Set the sizes of the sub-array.
Definition TFormLeafInfo.cxx:2539
TFormLeafInfoMultiVarDim::~TFormLeafInfoMultiVarDim
~TFormLeafInfoMultiVarDim() override
Destructor.
Definition TFormLeafInfo.cxx:2459
TFormLeafInfoNumerical
A small helper class to implement reading a numerical value inside a collection.
Definition TFormLeafInfo.h:182
TFormLeafInfoNumerical::operator=
TFormLeafInfoNumerical & operator=(const TFormLeafInfoNumerical &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:1055
TFormLeafInfoNumerical::IsString
bool IsString() const override
Return true if the underlying data is a string.
Definition TFormLeafInfo.cxx:1081
TFormLeafInfoNumerical::Swap
void Swap(TFormLeafInfoNumerical &other)
Exception safe swap.
Definition TFormLeafInfo.cxx:1045
TFormLeafInfoNumerical::~TFormLeafInfoNumerical
~TFormLeafInfoNumerical() override
Destructor.
Definition TFormLeafInfo.cxx:1073
TFormLeafInfoNumerical::TFormLeafInfoNumerical
TFormLeafInfoNumerical(TVirtualCollectionProxy *holder_of)
Construct a TFormLeafInfo for the numerical type contained in the collection.
Definition TFormLeafInfo.cxx:1014
TFormLeafInfoNumerical::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:1065
TFormLeafInfoNumerical::Update
bool Update() override
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:1092
TFormLeafInfoPointer
A small helper class to implement reading a data member by following a pointer inside a branch of TTr...
Definition TFormLeafInfo.h:337
TFormLeafInfoPointer::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all of its content.
Definition TFormLeafInfo.cxx:1988
TFormLeafInfoPointer::TFormLeafInfoPointer
TFormLeafInfoPointer(TClass *classptr=nullptr, Longptr_t offset=0, TStreamerElement *element=nullptr)
Constructor.
Definition TFormLeafInfo.cxx:1978
TFormLeafInfoPointer::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return the value of the underlying pointer data member.
Definition TFormLeafInfo.cxx:1997
TFormLeafInfoPointer::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return the value of the underlying pointer data member.
Definition TFormLeafInfo.cxx:2065
TFormLeafInfoTTree
A small helper class to implement reading from the containing TTree object itself.
Definition TFormLeafInfo.h:525
TFormLeafInfoTTree::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return result of a leafobject method.
Definition TFormLeafInfo.cxx:3026
TFormLeafInfoTTree::TFormLeafInfoTTree
TFormLeafInfoTTree(TTree *tree=nullptr, const char *alias=nullptr, TTree *current=nullptr)
Constructor.
Definition TFormLeafInfo.cxx:2990
TFormLeafInfoTTree::GetLocalValuePointer
void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0) override
returns the address of the value pointed to by the TFormLeafInfo.
Definition TFormLeafInfo.cxx:3017
TFormLeafInfoTTree::DeepCopy
TFormLeafInfo * DeepCopy() const override
Copy the object and all its content.
Definition TFormLeafInfo.cxx:3008
TFormLeafInfoTTree::Update
bool Update() override
Update after a change of file in a chain.
Definition TFormLeafInfo.cxx:3048
TFormLeafInfoTTree::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Return result of a leafobject method.
Definition TFormLeafInfo.cxx:3035
TFormLeafInfo
This class is a small helper class to implement reading a data member on an object stored in a TTree.
Definition TFormLeafInfo.h:47
TFormLeafInfo::GetVarDim
virtual Int_t GetVarDim()
Return the index of the dimension which varies for each elements of an enclosing array (typically a T...
Definition TFormLeafInfo.cxx:428
TFormLeafInfo::GetValuePointer
virtual void * GetValuePointer(TLeaf *leaf, Int_t instance=0)
returns the address of the value pointed to by the serie of TFormLeafInfo.
Definition TFormLeafInfo.cxx:619
TFormLeafInfo::fCounter
TFormLeafInfo * fCounter
Definition TFormLeafInfo.h:66
TFormLeafInfo::GetNdata
virtual Int_t GetNdata()
Get the number of element in the entry.
Definition TFormLeafInfo.cxx:332
TFormLeafInfo::fClass
TClass * fClass
! This is the class of the data pointed to
Definition TFormLeafInfo.h:60
TFormLeafInfo::GetObjectAddress
char * GetObjectAddress(TLeafElement *leaf, Int_t &instance)
Returns the location of the object pointed to.
Definition TFormLeafInfo.cxx:184
TFormLeafInfo::fElementName
TString fElementName
Definition TFormLeafInfo.h:69
TFormLeafInfo::Update
virtual bool Update()
We reloading all cached information in case the underlying class information has changed (for example...
Definition TFormLeafInfo.cxx:509
TFormLeafInfo::GetPrimaryIndex
virtual Int_t GetPrimaryIndex()
Method for multiple variable dimensions.
Definition TFormLeafInfo.cxx:418
TFormLeafInfo::SetSize
virtual void SetSize(Int_t index, Int_t val)
Set the current size of the arrays.
Definition TFormLeafInfo.cxx:491
TFormLeafInfo::ReadValueImpl
T ReadValueImpl(char *where, Int_t instance=0)
Read the value at the given memory location.
Definition TFormLeafInfo.cxx:810
TFormLeafInfo::ReadValue
virtual Double_t ReadValue(char *where, Int_t instance=0)
Definition TFormLeafInfo.h:117
TFormLeafInfo::~TFormLeafInfo
~TFormLeafInfo() override
Delete this object and all its content.
Definition TFormLeafInfo.cxx:135
TFormLeafInfo::GetClass
virtual TClass * GetClass() const
Get the class of the underlying data.
Definition TFormLeafInfo.cxx:173
TFormLeafInfo::fElement
TStreamerElement * fElement
! Descriptor of the data pointed to.
Definition TFormLeafInfo.h:63
TFormLeafInfo::TFormLeafInfo
TFormLeafInfo(TClass *classptr=nullptr, Longptr_t offset=0, TStreamerElement *element=nullptr)
Constructor.
Definition TFormLeafInfo.cxx:74
TFormLeafInfo::IsString
virtual bool IsString() const
Return true if the underlying data is a string.
Definition TFormLeafInfo.cxx:351
TFormLeafInfo::fNext
TFormLeafInfo * fNext
follow this to grab the inside information
Definition TFormLeafInfo.h:67
TFormLeafInfo::GetVirtVarDim
virtual Int_t GetVirtVarDim()
Return the virtual index (for this expression) of the dimension which varies for each elements of an ...
Definition TFormLeafInfo.cxx:438
TFormLeafInfo::SetSecondaryIndex
virtual void SetSecondaryIndex(Int_t index)
Set the primary index value.
Definition TFormLeafInfo.cxx:483
TFormLeafInfo::IsInteger
virtual bool IsInteger() const
Return true if the underlying data is an integral value.
Definition TFormLeafInfo.cxx:374
TFormLeafInfo::LoadSizes
virtual void LoadSizes(TBranch *branch)
Load the current array sizes.
Definition TFormLeafInfo.cxx:467
TFormLeafInfo::GetSumOfSizes
virtual Int_t GetSumOfSizes()
Total all the elements that are available for the current entry for the secondary variable dimension.
Definition TFormLeafInfo.cxx:458
TFormLeafInfo::GetArrayLength
virtual Int_t GetArrayLength()
Return the current length of the array.
Definition TFormLeafInfo.cxx:158
TFormLeafInfo::operator=
TFormLeafInfo & operator=(const TFormLeafInfo &orig)
Exception safe assignment operator.
Definition TFormLeafInfo.cxx:98
TFormLeafInfo::ReadTypedValue
T ReadTypedValue(char *where, Int_t instance=0)
Definition TFormLeafInfo.h:124
TFormLeafInfo::Swap
void Swap(TFormLeafInfo &other)
Definition TFormLeafInfo.cxx:107
TFormLeafInfo::ReadCounterValue
virtual Int_t ReadCounterValue(char *where)
Return the size of the underlying array for the current entry in the TTree.
Definition TFormLeafInfo.cxx:588
TFormLeafInfo::HasCounter
virtual bool HasCounter() const
Return true if any of underlying data has a array size counter.
Definition TFormLeafInfo.cxx:341
TFormLeafInfo::GetCounterValue
virtual Int_t GetCounterValue(TLeaf *leaf)
Return the size of the underlying array for the current entry in the TTree.
Definition TFormLeafInfo.cxx:575
TFormLeafInfo::GetNdata
Int_t GetNdata(TLeaf *leaf)
Definition TFormLeafInfo.cxx:320
TFormLeafInfo::UpdateSizes
virtual void UpdateSizes(TArrayI *garr)
Set the current sizes of the arrays.
Definition TFormLeafInfo.cxx:499
TFormLeafInfo::GetSize
virtual Int_t GetSize(Int_t index)
For the current entry, and the value 'index' for the main array, return the size of the secondary var...
Definition TFormLeafInfo.cxx:448
TFormLeafInfo::SetPrimaryIndex
virtual void SetPrimaryIndex(Int_t index)
Set the primary index value.
Definition TFormLeafInfo.cxx:475
TFormLeafInfo::AddOffset
virtual void AddOffset(Int_t offset, TStreamerElement *element)
Increase the offset of this element.
Definition TFormLeafInfo.cxx:145
TFormLeafInfo::GetValue
virtual Double_t GetValue(TLeaf *leaf, Int_t instance=0)
Definition TFormLeafInfo.h:116
TFormLeafInfo::GetMultiplicity
Int_t GetMultiplicity()
Reminder of the meaning of fMultiplicity:
Definition TFormLeafInfo.cxx:314
TFormLeafInfo::fOffset
Longptr_t fOffset
! Offset of the data pointed inside the class fClass
Definition TFormLeafInfo.h:62
TFormLeafInfo::GetLocalValuePointer
virtual void * GetLocalValuePointer(TLeaf *leaf, Int_t instance=0)
returns the address of the value pointed to by the TFormLeafInfo.
Definition TFormLeafInfo.cxx:603
TFormLeafInfo::fClassName
TString fClassName
Definition TFormLeafInfo.h:68
TFormLeafInfo::GetValueImpl
T GetValueImpl(TLeaf *leaf, Int_t instance=0)
Return result of a leafobject method.
Definition TFormLeafInfo.cxx:791
TFormLeafInfo::DeepCopy
virtual TFormLeafInfo * DeepCopy() const
Make a complete copy of this FormLeafInfo and all its content.
Definition TFormLeafInfo.cxx:127
TFunction::Property
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
Definition TFunction.cxx:193
TFunction::GetReturnTypeName
const char * GetReturnTypeName() const
Get full type description of function return type, e,g.: "class TDirectory*".
Definition TFunction.cxx:150
TLeafElement
A TLeaf for the general case when using the branches created via a TStreamerInfo (i....
Definition TLeafElement.h:32
TLeafElement::Class
static TClass * Class()
TLeafObject
A TLeaf for a general object derived from TObject.
Definition TLeafObject.h:31
TLeafObject::Class
static TClass * Class()
TLeaf
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
TMethodCall
Method or function calling interface.
Definition TMethodCall.h:37
TMethodCall::ReturnType
EReturnType ReturnType()
Returns the return type of the method.
Definition TMethodCall.cxx:565
TMethodCall::kLong
static const EReturnType kLong
Definition TMethodCall.h:43
TMethodCall::kString
static const EReturnType kString
Definition TMethodCall.h:45
TMethodCall::kOther
static const EReturnType kOther
Definition TMethodCall.h:46
TMethodCall::GetMethod
TFunction * GetMethod()
Returns the TMethod describing the method to be executed.
Definition TMethodCall.cxx:386
TMethodCall::Execute
void Execute(const char *, const char *, int *=nullptr) override
Execute method on this object with the given parameter string, e.g.
Definition TMethodCall.h:64
TMethodCall::Init
void Init(const TFunction *func)
Initialize the method invocation environment based on the TFunction object.
Definition TMethodCall.cxx:226
TMethodCall::kDouble
static const EReturnType kDouble
Definition TMethodCall.h:44
TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
TObject
Mother of all ROOT objects.
Definition TObject.h:41
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:543
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
TStreamerBasicPointer::Class
static TClass * Class()
TStreamerElement
Describe one element (data member) to be Streamed.
Definition TStreamerElement.h:25
TStreamerElement::GetNewType
Int_t GetNewType() const
Definition TStreamerElement.h:111
TStreamerElement::GetClassPointer
virtual TClass * GetClassPointer() const
Returns a pointer to the TClass of this element.
Definition TStreamerElement.cxx:295
TStreamerElement::GetArrayLength
Int_t GetArrayLength() const
Definition TStreamerElement.h:101
TStreamerElement::IsA
TClass * IsA() const override
Definition TStreamerElement.h:141
TStreamerInfo
Describes a persistent version of a class.
Definition TStreamerInfo.h:39
TString
Basic string class.
Definition TString.h:139
TString::Length
Ssiz_t Length() const
Definition TString.h:417
TString::Data
const char * Data() const
Definition TString.h:376
TString::Append
TString & Append(const char *cs)
Definition TString.h:572
TTree
A TTree represents a columnar dataset.
Definition TTree.h:84
TTree::GetFriend
virtual TTree * GetFriend(const char *) const
Return a pointer to the TTree friend whose name or alias is friendname.
Definition TTree.cxx:5985
TVirtualCollectionProxy::TPushPop
RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++...
Definition TVirtualCollectionProxy.h:75
TVirtualCollectionProxy
Defines a common interface to inspect/change the contents of an object that represents a collection.
Definition TVirtualCollectionProxy.h:52
TVirtualCollectionProxy::At
virtual void * At(UInt_t idx)=0
Return the address of the value at index idx
TVirtualCollectionProxy::Size
virtual UInt_t Size() const =0
Return the current number of elements in the container.
TVirtualCollectionProxy::Generate
virtual TVirtualCollectionProxy * Generate() const =0
Returns a clean object of the actual class that derives from TVirtualCollectionProxy.
TVirtualCollectionProxy::HasPointers
virtual Bool_t HasPointers() const =0
Return true if the content is of type 'pointer to'.
TVirtualStreamerInfo::kUChar
@ kUChar
Equal to TDataType's kchar.
Definition TVirtualStreamerInfo.h:121
ROOT::gCoreMutex
R__EXTERN TVirtualRWMutex * gCoreMutex
Definition TVirtualRWMutex.h:37
TClassEdit::GetNormalizedName
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition TClassEdit.cxx:891
l
TLine l
Definition textangle.C:4