Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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
13 This class is a small helper class to implement reading a data member
14 on an object stored in a TTree.
15 
16 TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
17 reading 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 
29 The 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 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 
74 TFormLeafInfo::TFormLeafInfo(TClass* classptr, Long_t offset,
75  TStreamerElement* element) :
76  fClass(classptr),fOffset(offset),fElement(element),
77  fCounter(0), fNext(0),fMultiplicity(0)
78 {
79  if (fClass) fClassName = fClass->GetName();
80  if (fElement) {
81  fElementName = fElement->GetName();
82  }
83 }
84 
85 ////////////////////////////////////////////////////////////////////////////////
86 ///Constructor.
87 
88 TFormLeafInfo::TFormLeafInfo(const TFormLeafInfo& orig) : TObject(orig),fClass(orig.fClass),fOffset(orig.fOffset),fElement(orig.fElement),fCounter(0),fNext(0),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 
98 TFormLeafInfo &TFormLeafInfo::operator=(const TFormLeafInfo &other)
99 {
100  TFormLeafInfo tmp(other);
101  Swap(tmp);
102  return *this;
103 }
104 
105 ////////////////////////////////////////////////////////////////////////////////
106 
107 void 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 
127 TFormLeafInfo* TFormLeafInfo::DeepCopy() const
128 {
129  return new TFormLeafInfo(*this);
130 }
131 
132 ////////////////////////////////////////////////////////////////////////////////
133 /// Delete this object and all its content
134 
135 TFormLeafInfo::~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 
145 void 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 
158 Int_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 
173 TClass* 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 the location of the object pointed to.
182 /// Modify instance if the object is part of an array.
183 
184 char* 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 = 0;
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 = 0;
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 
314 Int_t TFormLeafInfo::GetMultiplicity()
315 {
316  // Currently only TFormLeafInfoCast uses this field.
317  return fMultiplicity;
318 }
319 
320 Int_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 
332 Int_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 
341 Bool_t TFormLeafInfo::HasCounter() const
342 {
343  Bool_t result = kFALSE;
344  if (fNext) result = fNext->HasCounter();
345  return fCounter!=0 || result;
346 }
347 
348 ////////////////////////////////////////////////////////////////////////////////
349 /// Return true if the underlying data is a string
350 
351 Bool_t TFormLeafInfo::IsString() const
352 {
353  if (fNext) return fNext->IsString();
354  if (!fElement) return kFALSE;
355 
356  switch (fElement->GetNewType()) {
357  // basic types
358  case kChar_t:
359  // This is new in ROOT 3.02/05
360  return kFALSE;
361  case TStreamerInfo::kOffsetL + kChar_t:
362  // This is new in ROOT 3.02/05
363  return kTRUE;
364  case TStreamerInfo::kCharStar:
365  return kTRUE;
366  default:
367  return kFALSE;
368  }
369 }
370 
371 ////////////////////////////////////////////////////////////////////////////////
372 /// Return true if the underlying data is an integral value
373 
374 Bool_t TFormLeafInfo::IsInteger() const
375 {
376  if (fNext) return fNext->IsInteger();
377  if (!fElement) return kFALSE;
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 kTRUE;
403  case TStreamerInfo::kCharStar:
404  return kTRUE; // 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 kFALSE;
410  default:
411  return kFALSE;
412  }
413 }
414 
415 ////////////////////////////////////////////////////////////////////////////////
416 /// Method for multiple variable dimensions.
417 
418 Int_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 
428 Int_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 
438 Int_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 
448 Int_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 
458 Int_t TFormLeafInfo::GetSumOfSizes()
459 {
460  if (fNext) return fNext->GetSumOfSizes();
461  else return 0;
462 }
463 
464 ////////////////////////////////////////////////////////////////////////////////
465 /// Load the current array sizes
466 
467 void TFormLeafInfo::LoadSizes(TBranch* branch)
468 {
469  if (fNext) fNext->LoadSizes(branch);
470 }
471 
472 ////////////////////////////////////////////////////////////////////////////////
473 /// Set the primary index value
474 
475 void TFormLeafInfo::SetPrimaryIndex(Int_t index)
476 {
477  if (fNext) fNext->SetPrimaryIndex(index);
478 }
479 
480 ////////////////////////////////////////////////////////////////////////////////
481 /// Set the primary index value
482 
483 void TFormLeafInfo::SetSecondaryIndex(Int_t index)
484 {
485  if (fNext) fNext->SetSecondaryIndex(index);
486 }
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 /// Set the current size of the arrays
490 
491 void 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 
499 void TFormLeafInfo::UpdateSizes(TArrayI *garr)
500 {
501  if (fNext) fNext->UpdateSizes(garr);
502 }
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 
509 Bool_t 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 kFALSE;
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 kTRUE;
570 }
571 
572 ////////////////////////////////////////////////////////////////////////////////
573 /// Return the size of the underlying array for the current entry in the TTree.
574 
575 Int_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 
588 Int_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 
603 void* TFormLeafInfo::GetLocalValuePointer(TLeaf *leaf, Int_t instance)
604 {
605  char *thisobj = 0;
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 0;
612  return GetLocalValuePointer(thisobj, instance);
613 }
614 
615 ////////////////////////////////////////////////////////////////////////////////
616 /// returns the address of the value pointed to by the
617 /// serie of TFormLeafInfo.
618 
619 void* TFormLeafInfo::GetValuePointer(TLeaf *leaf, Int_t instance)
620 {
621  char *thisobj = (char*)GetLocalValuePointer(leaf,instance);
622  if (fNext) return fNext->GetValuePointer(thisobj,instance);
623  else return thisobj;
624 }
625 
626 ////////////////////////////////////////////////////////////////////////////////
627 /// returns the address of the value pointed to by the
628 /// TFormLeafInfo.
629 
630 void* 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 
641 void* TFormLeafInfo::GetLocalValuePointer(char *thisobj, Int_t instance)
642 {
643  if (fElement==0 || thisobj==0) 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_t *val = (Bool_t*)(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_t)
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 0;
783  }
784 }
785 
786 
787 ////////////////////////////////////////////////////////////////////////////////
788 /// Return result of a leafobject method.
789 
790 template <typename T>
791 T TFormLeafInfo::GetValueImpl(TLeaf *leaf, Int_t instance)
792 {
793  char *thisobj = 0;
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==0) return 0;
800  return ReadTypedValue<T>(thisobj,instance);
801 }
802 
803 INSTANTIATE_GETVAL(TFormLeafInfo);
804 INSTANTIATE_READVAL(TFormLeafInfo);
805 
806 ////////////////////////////////////////////////////////////////////////////////
807 /// Read the value at the given memory location
808 
809 template <typename T>
810 T 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_t*)(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_t *val = (Bool_t*)(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 + kULong64_t:
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_t)
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 
943 TFormLeafInfoDirect::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 
952 TFormLeafInfo* TFormLeafInfoDirect::DeepCopy() const
953 {
954  return new TFormLeafInfoDirect(*this);
955 }
956 
957 ////////////////////////////////////////////////////////////////////////////////
958 /// Read the value at the given memory location
959 
960 Double_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 
969 template <typename T>
970 T TFormLeafInfoDirect::GetValueImpl(TLeaf *leaf, Int_t instance)
971 {
972  return leaf->GetTypedValue<T>(instance);
973 }
974 
975 INSTANTIATE_GETVAL(TFormLeafInfoDirect);
976 
977 ////////////////////////////////////////////////////////////////////////////////
978 /// Return the address of the underlying value.
979 
980 void* 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 
992 void* TFormLeafInfoDirect::GetLocalValuePointer(char *thisobj, Int_t instance)
993 {
994  return TFormLeafInfo::GetLocalValuePointer(thisobj,instance);
995 }
996 
997 ////////////////////////////////////////////////////////////////////////////////
998 /// \class TFormLeafInfoNumerical
999 /// A small helper class to implement reading a numerical value inside a collection
1000 
1001 ////////////////////////////////////////////////////////////////////////////////
1002 /// Constructor.
1003 
1004 TFormLeafInfoNumerical::TFormLeafInfoNumerical(EDataType kind) :
1005  TFormLeafInfo(0,0,0),
1006  fKind(kind), fIsBool(kFALSE)
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 
1014 TFormLeafInfoNumerical::TFormLeafInfoNumerical(TVirtualCollectionProxy *collection) :
1015  TFormLeafInfo(0,0,0),
1016  fKind(kNoType_t), fIsBool(kFALSE)
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<", strlen("bitset<") ) ==0 ) {
1024  fIsBool = kTRUE;
1025  fKind = (EDataType)18;
1026  }
1027  }
1028  }
1029  fElement = new TStreamerElement("data","in collection", 0, fKind, "");
1030 }
1031 
1032 ////////////////////////////////////////////////////////////////////////////////
1033 /// Constructor.
1034 
1035 TFormLeafInfoNumerical::TFormLeafInfoNumerical(const TFormLeafInfoNumerical& orig) :
1036  TFormLeafInfo(orig),
1037  fKind(orig.fKind), fIsBool(kFALSE)
1038 {
1039  fElement = new TStreamerElement("data","in collection", 0, fKind, "");
1040 }
1041 
1042 ////////////////////////////////////////////////////////////////////////////////
1043 /// Exception safe swap.
1044 
1045 void 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 
1055 TFormLeafInfoNumerical &TFormLeafInfoNumerical::operator=(const TFormLeafInfoNumerical &other)
1056 {
1057  TFormLeafInfoNumerical tmp(other);
1058  Swap(tmp);
1059  return *this;
1060 }
1061 
1062 ////////////////////////////////////////////////////////////////////////////////
1063 /// Copy the object and all its content.
1064 
1065 TFormLeafInfo* TFormLeafInfoNumerical::DeepCopy() const
1066 {
1067  return new TFormLeafInfoNumerical(*this);
1068 }
1069 
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// Destructor
1072 
1073 TFormLeafInfoNumerical::~TFormLeafInfoNumerical()
1074 {
1075  delete fElement;
1076 }
1077 
1078 ////////////////////////////////////////////////////////////////////////////////
1079 /// Return true if the underlying data is a string
1080 
1081 Bool_t TFormLeafInfoNumerical::IsString() const
1082 {
1083  if (fIsBool) return kFALSE;
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 
1092 Bool_t TFormLeafInfoNumerical::Update()
1093 {
1094  //R__ASSERT(fNext==0);
1095 
1096  if (fCounter) return fCounter->Update();
1097  return kFALSE;
1098 }
1099 
1100 namespace {
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 
1117 TFormLeafInfoClones::TFormLeafInfoClones(TClass* classptr, Long_t offset) :
1118  TFormLeafInfo(classptr,offset,R__GetFakeClonesElem()),fTop(kFALSE)
1119 {
1120 }
1121 
1122 ////////////////////////////////////////////////////////////////////////////////
1123 /// Constructor.
1124 
1125 TFormLeafInfoClones::TFormLeafInfoClones(TClass* classptr, Long_t offset,
1126  Bool_t top) :
1127  TFormLeafInfo(classptr,offset,R__GetFakeClonesElem()),fTop(top)
1128 {
1129 }
1130 
1131 ////////////////////////////////////////////////////////////////////////////////
1132 /// Constructor.
1133 
1134 TFormLeafInfoClones::TFormLeafInfoClones(TClass* classptr, Long_t offset,
1135  TStreamerElement* element,
1136  Bool_t top) :
1137  TFormLeafInfo(classptr,offset,element),fTop(top)
1138 {
1139 }
1140 
1141 ////////////////////////////////////////////////////////////////////////////////
1142 /// Deep Copy constructor.
1143 
1144 TFormLeafInfoClones::TFormLeafInfoClones(const TFormLeafInfoClones &orig) :
1145  TFormLeafInfo(orig), fTop(orig.fTop)
1146 {
1147 }
1148 
1149 ////////////////////////////////////////////////////////////////////////////////
1150 /// Exception safe swap.
1151 
1152 void TFormLeafInfoClones::Swap(TFormLeafInfoClones &other)
1153 {
1154  TFormLeafInfo::Swap(other);
1155  std::swap(fTop,other.fTop);
1156 }
1157 
1158 ////////////////////////////////////////////////////////////////////////////////
1159 /// Exception safe assignement operator
1160 
1161 TFormLeafInfoClones &TFormLeafInfoClones::operator=(const TFormLeafInfoClones &orig)
1162 {
1163  TFormLeafInfoClones tmp(orig);
1164  Swap(tmp);
1165  return *this;
1166 }
1167 
1168 ////////////////////////////////////////////////////////////////////////////////
1169 /// Return the current size of the the TClonesArray
1170 
1171 Int_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 the TClonesArray
1184 
1185 Int_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 
1200 template <typename T>
1201 T TFormLeafInfoClones::ReadValueImpl(char *where, Int_t instance)
1202 {
1203  if (fNext==0) 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 
1221 INSTANTIATE_GETVAL(TFormLeafInfoClones);
1222 INSTANTIATE_READVAL(TFormLeafInfoClones);
1223 
1224 ////////////////////////////////////////////////////////////////////////////////
1225 /// Return the pointer to the clonesArray
1226 
1227 void* 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 
1245 void* TFormLeafInfoClones::GetLocalValuePointer(char *where, Int_t instance)
1246 {
1247  return TFormLeafInfo::GetLocalValuePointer(where,instance);
1248 }
1249 
1250 ////////////////////////////////////////////////////////////////////////////////
1251 /// Return the value of the underlying data member inside the
1252 /// clones array.
1253 
1254 template <typename T>
1255 T TFormLeafInfoClones::GetValueImpl(TLeaf *leaf, Int_t instance)
1256 {
1257  if (fNext==0) return 0;
1258  Int_t len,index,sub_instance;
1259  len = (fNext->fElement==0)? 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==0) 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 
1283 void * 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==0)? 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 
1306 void * 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==0)? 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 
1334 TFormLeafInfoCollectionObject::TFormLeafInfoCollectionObject(TClass* classptr, Bool_t top) :
1335  TFormLeafInfo(classptr,0,R__GetFakeClonesElem()),fTop(top)
1336 {
1337 }
1338 
1339 ////////////////////////////////////////////////////////////////////////////////
1340 /// Constructor.
1341 
1342 TFormLeafInfoCollectionObject::TFormLeafInfoCollectionObject(const TFormLeafInfoCollectionObject &orig) :
1343  TFormLeafInfo(orig),fTop(orig.fTop)
1344 {
1345 }
1346 
1347 ////////////////////////////////////////////////////////////////////////////////
1348 /// Exception safe swap.
1349 
1350 void TFormLeafInfoCollectionObject::Swap(TFormLeafInfoCollectionObject &other)
1351 {
1352  TFormLeafInfo::Swap(other);
1353  std::swap(fTop,other.fTop);
1354 }
1355 
1356 ////////////////////////////////////////////////////////////////////////////////
1357 /// Exception safe assignement operator
1358 
1359 TFormLeafInfoCollectionObject &TFormLeafInfoCollectionObject::operator=(const TFormLeafInfoCollectionObject &orig)
1360 {
1361  TFormLeafInfoCollectionObject tmp(orig);
1362  Swap(tmp);
1363  return *this;
1364 }
1365 
1366 ////////////////////////////////////////////////////////////////////////////////
1367 /// Return the current size of the the TClonesArray
1368 
1369 Int_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 
1378 Double_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 
1387 void* 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 
1405 void* TFormLeafInfoCollectionObject::GetLocalValuePointer(char *where, Int_t instance)
1406 {
1407  return TFormLeafInfo::GetLocalValuePointer(where,instance);
1408 }
1409 
1410 ////////////////////////////////////////////////////////////////////////////////
1411 /// Return the value of the underlying data member inside the
1412 /// clones array.
1413 
1414 template <typename T>
1415 T TFormLeafInfoCollectionObject::GetValueImpl(TLeaf *leaf, Int_t instance)
1416 {
1417  char * obj = (char*)GetLocalValuePointer(leaf);
1418 
1419  if (fNext==0) return 0;
1420  return fNext->ReadTypedValue<T>(obj,instance);
1421 }
1422 
1423 INSTANTIATE_GETVAL(TFormLeafInfoCollectionObject);
1424 
1425 ////////////////////////////////////////////////////////////////////////////////
1426 /// Return the pointer to the clonesArray
1427 
1428 void * TFormLeafInfoCollectionObject::GetValuePointer(TLeaf *leaf, Int_t instance)
1429 {
1430  void *collection = GetLocalValuePointer(leaf);
1431  if (fNext) {
1432  return fNext->GetValuePointer((char*)collection,instance);
1433  }
1434  return collection;
1435 }
1436 
1437 ////////////////////////////////////////////////////////////////////////////////
1438 /// Return the pointer to the clonesArray
1439 
1440 void * 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 /// Cosntructor.
1455 
1456 TFormLeafInfoCollection::TFormLeafInfoCollection(TClass* classptr,
1457  Long_t offset,
1458  TStreamerElement* element,
1459  Bool_t top) :
1460  TFormLeafInfo(classptr,offset,element),
1461  fTop(top),
1462  fCollClass( 0),
1463  fCollProxy( 0),
1464  fLocalElement( 0)
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 
1483 TFormLeafInfoCollection::TFormLeafInfoCollection(TClass* motherclassptr,
1484  Long_t offset,
1485  TClass* elementclassptr,
1486  Bool_t 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  : "Unknwon")
1496  ) ),
1497  fTop(top),
1498  fCollClass( 0),
1499  fCollProxy( 0) ,
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 
1519 TFormLeafInfoCollection::TFormLeafInfoCollection() :
1520  TFormLeafInfo(),
1521  fTop(kFALSE),
1522  fCollClass( 0),
1523  fCollProxy( 0),
1524  fLocalElement( 0)
1525 {
1526 }
1527 
1528 ////////////////////////////////////////////////////////////////////////////////
1529 /// Constructor.
1530 
1531 TFormLeafInfoCollection::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() : 0 ),
1537  fLocalElement( 0 ) // humm why not initialize it?
1538 {
1539 }
1540 
1541 ////////////////////////////////////////////////////////////////////////////////
1542 /// Exception safe swap.
1543 
1544 void 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 
1557 TFormLeafInfoCollection &TFormLeafInfoCollection::operator=(const TFormLeafInfoCollection &other)
1558 {
1559  TFormLeafInfoCollection tmp(other);
1560  Swap(tmp);
1561  return *this;
1562 }
1563 
1564 ////////////////////////////////////////////////////////////////////////////////
1565 /// Destructor.
1566 
1567 TFormLeafInfoCollection::~TFormLeafInfoCollection()
1568 {
1569  delete fCollProxy;
1570  delete fLocalElement;
1571 }
1572 
1573 ////////////////////////////////////////////////////////////////////////////////
1574 /// Copy of the object and its content.
1575 
1576 TFormLeafInfo* TFormLeafInfoCollection::DeepCopy() const
1577 {
1578  return new TFormLeafInfoCollection(*this);
1579 }
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 
1586 Bool_t TFormLeafInfoCollection::Update()
1587 {
1588  Bool_t changed = kFALSE;
1589  TClass * new_class = TClass::GetClass(fCollClassName);
1590  if (new_class!=fCollClass) {
1591  delete fCollProxy; fCollProxy = 0;
1592  fCollClass = new_class;
1593  if (fCollClass && fCollClass->GetCollectionProxy()) {
1594  fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1595  }
1596  changed = kTRUE;
1597  }
1598  return changed || TFormLeafInfo::Update();
1599 }
1600 
1601 ////////////////////////////////////////////////////////////////////////////////
1602 /// Return true if the underlying data has a array size counter
1603 
1604 Bool_t TFormLeafInfoCollection::HasCounter() const
1605 {
1606  return fCounter!=0 || fCollProxy!=0;
1607 }
1608 
1609 ////////////////////////////////////////////////////////////////////////////////
1610 /// Return the current size of the the TClonesArray
1611 
1612 Int_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==0) 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 
1627 Int_t TFormLeafInfoCollection::ReadCounterValue(char* where)
1628 {
1629  if (fCounter) { return (Int_t)fCounter->ReadValue(where); }
1630  R__ASSERT(fCollProxy);
1631  if (where==0) 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 the TClonesArray
1639 
1640 Int_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==0) 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 
1656 template <typename T>
1657 T TFormLeafInfoCollection::ReadValueImpl(char *where, Int_t instance)
1658 {
1659  if (fNext==0) return 0;
1660  UInt_t len,index,sub_instance;
1661  len = (fNext->fElement==0)? 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 
1686 INSTANTIATE_GETVAL(TFormLeafInfoCollection);
1687 INSTANTIATE_READVAL(TFormLeafInfoCollection);
1688 
1689 ////////////////////////////////////////////////////////////////////////////////
1690 /// Return the pointer to the clonesArray
1691 
1692 void* 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 
1710 void* TFormLeafInfoCollection::GetLocalValuePointer(char *where, Int_t instance)
1711 {
1712  return TFormLeafInfo::GetLocalValuePointer(where,instance);
1713 }
1714 
1715 ////////////////////////////////////////////////////////////////////////////////
1716 /// Return the value of the underlying data member inside the
1717 /// clones array.
1718 
1719 template <typename T>
1720 T TFormLeafInfoCollection::GetValueImpl(TLeaf *leaf, Int_t instance)
1721 {
1722  if (fNext==0) return 0;
1723  Int_t len,index,sub_instance;
1724  len = (fNext->fElement==0)? 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==0) return 0;
1745  if (fCollProxy->HasPointers()) obj = *(char**)obj;
1746  if (obj==0) return 0;
1747  return fNext->ReadTypedValue<T>(obj,sub_instance);
1748 }
1749 
1750 ////////////////////////////////////////////////////////////////////////////////
1751 /// Return the pointer to the clonesArray
1752 
1753 void * 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 
1786 void * 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==0)? 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 
1818 TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize(TClass* classptr) :
1819  TFormLeafInfo(), fCollClass(classptr), fCollProxy(0)
1820 {
1821  if (fCollClass
1822  && fCollClass!=TClonesArray::Class()
1823  && fCollClass->GetCollectionProxy()) {
1824 
1825  fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1826  fCollClassName = fCollClass->GetName();
1827  }
1828 }
1829 
1830 ////////////////////////////////////////////////////////////////////////////////
1831 /// Constructor.
1832 
1833 TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize(
1834  TClass* classptr,Long_t offset,TStreamerElement* element) :
1835  TFormLeafInfo(classptr,offset,element), fCollClass(element->GetClassPointer()), fCollProxy(0)
1836 {
1837  if (fCollClass
1838  && fCollClass!=TClonesArray::Class()
1839  && fCollClass->GetCollectionProxy()) {
1840 
1841  fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1842  fCollClassName = fCollClass->GetName();
1843  }
1844 }
1845 
1846 ////////////////////////////////////////////////////////////////////////////////
1847 /// Constructor.
1848 
1849 TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize() :
1850  TFormLeafInfo(), fCollClass(0), fCollProxy(0)
1851 {
1852 }
1853 
1854 ////////////////////////////////////////////////////////////////////////////////
1855 /// Constructor.
1856 
1857 TFormLeafInfoCollectionSize::TFormLeafInfoCollectionSize(
1858  const TFormLeafInfoCollectionSize& orig) : TFormLeafInfo(),
1859  fCollClass(orig.fCollClass),
1860  fCollClassName(orig.fCollClassName),
1861  fCollProxy(orig.fCollProxy?orig.fCollProxy->Generate():0)
1862 {
1863 }
1864 
1865 ////////////////////////////////////////////////////////////////////////////////
1866 /// Exception safe assignment operator.
1867 
1868 TFormLeafInfoCollectionSize &TFormLeafInfoCollectionSize::operator=(const TFormLeafInfoCollectionSize &other)
1869 {
1870  TFormLeafInfoCollectionSize tmp(other);
1871  Swap(tmp);
1872  return *this;
1873 }
1874 
1875 ////////////////////////////////////////////////////////////////////////////////
1876 /// Exception safe swap.
1877 
1878 void 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 
1889 TFormLeafInfoCollectionSize::~TFormLeafInfoCollectionSize()
1890 {
1891  delete fCollProxy;
1892 }
1893 
1894 ////////////////////////////////////////////////////////////////////////////////
1895 /// Copy the object and all of its content.
1896 
1897 TFormLeafInfo* TFormLeafInfoCollectionSize::DeepCopy() const
1898 {
1899  return new TFormLeafInfoCollectionSize(*this);
1900 }
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 
1907 Bool_t TFormLeafInfoCollectionSize::Update()
1908 {
1909  Bool_t changed = kFALSE;
1910  TClass *new_class = TClass::GetClass(fCollClassName);
1911  if (new_class!=fCollClass) {
1912  delete fCollProxy; fCollProxy = 0;
1913  fCollClass = new_class;
1914  if (fCollClass && fCollClass->GetCollectionProxy()) {
1915  fCollProxy = fCollClass->GetCollectionProxy()->Generate();
1916  }
1917  changed = kTRUE;
1918  }
1919  return changed;
1920 }
1921 
1922 ////////////////////////////////////////////////////////////////////////////////
1923 /// Not implemented.
1924 
1925 void *TFormLeafInfoCollectionSize::GetValuePointer(TLeaf * /* leaf */, Int_t /* instance */)
1926 {
1927  Error("GetValuePointer","This should never be called");
1928  return 0;
1929 }
1930 
1931 ////////////////////////////////////////////////////////////////////////////////
1932 /// Not implemented.
1933 
1934 void *TFormLeafInfoCollectionSize::GetValuePointer(char * /* from */, Int_t /* instance */)
1935 {
1936  Error("GetValuePointer","This should never be called");
1937  return 0;
1938 }
1939 
1940 ////////////////////////////////////////////////////////////////////////////////
1941 /// Not implemented.
1942 
1943 void *TFormLeafInfoCollectionSize::GetLocalValuePointer(TLeaf * /* leaf */, Int_t /* instance */)
1944 {
1945  Error("GetLocalValuePointer","This should never be called");
1946  return 0;
1947 }
1948 
1949 ////////////////////////////////////////////////////////////////////////////////
1950 /// Not implemented.
1951 
1952 void *TFormLeafInfoCollectionSize::GetLocalValuePointer( char * /* from */, Int_t /* instance */)
1953 {
1954  Error("GetLocalValuePointer","This should never be called");
1955  return 0;
1956 }
1957 
1958 ////////////////////////////////////////////////////////////////////////////////
1959 /// Return the value of the underlying pointer data member
1960 
1961 Double_t TFormLeafInfoCollectionSize::ReadValue(char *where, Int_t /* instance */)
1962 {
1963  R__ASSERT(fCollProxy);
1964  if (where==0) 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 
1978 TFormLeafInfoPointer::TFormLeafInfoPointer(TClass* classptr,
1979  Long_t offset,
1980  TStreamerElement* element) :
1981  TFormLeafInfo(classptr,offset,element)
1982 {
1983 }
1984 
1985 ////////////////////////////////////////////////////////////////////////////////
1986 /// Copy the object and all of its contnet.
1987 
1988 TFormLeafInfo* TFormLeafInfoPointer::DeepCopy() const
1989 {
1990  return new TFormLeafInfoPointer(*this);
1991 }
1992 
1993 ////////////////////////////////////////////////////////////////////////////////
1994 /// Return the value of the underlying pointer data member
1995 
1996 template <typename T>
1997 T 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 
2064 template <typename T>
2065 T TFormLeafInfoPointer::GetValueImpl(TLeaf *leaf, Int_t instance)
2066 {
2067  if (!fNext) return 0;
2068  char * where = (char*)GetLocalValuePointer(leaf,instance);
2069  if (where==0) return 0;
2070  return fNext->ReadTypedValue<T>(where,instance);
2071 }
2072 
2073 INSTANTIATE_GETVAL(TFormLeafInfoPointer);
2074 INSTANTIATE_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 
2084 TFormLeafInfoMethod::TFormLeafInfoMethod( TClass* classptr,
2085  TMethodCall *method) :
2086  TFormLeafInfo(classptr,0,0),fMethod(method),
2087  fResult(0), fCopyFormat(),fDeleteFormat(),fValuePointer(0),fIsByValue(kFALSE)
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%lx)";
2104 
2105  fDeleteFormat = "delete (";
2106  fDeleteFormat += rtype;
2107  fDeleteFormat += "*)0x%lx";
2108 
2109  fIsByValue = kTRUE;
2110  }
2111  }
2112  }
2113 }
2114 
2115 ////////////////////////////////////////////////////////////////////////////////
2116 /// Constructor.
2117 
2118 TFormLeafInfoMethod::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 = 0;
2129  }
2130  fCopyFormat = orig.fCopyFormat;
2131  fDeleteFormat = orig.fDeleteFormat;
2132  fValuePointer = 0;
2133  fIsByValue = orig.fIsByValue;
2134 }
2135 
2136 
2137 ////////////////////////////////////////////////////////////////////////////////
2138 /// Exception safe swap.
2139 
2140 void 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 
2156 TFormLeafInfoMethod &TFormLeafInfoMethod::operator=(const TFormLeafInfoMethod &other)
2157 {
2158  TFormLeafInfoMethod tmp(other);
2159  Swap(tmp);
2160  return *this;
2161 }
2162 
2163 ////////////////////////////////////////////////////////////////////////////////
2164 /// Destructor.
2165 
2166 TFormLeafInfoMethod::~TFormLeafInfoMethod()
2167 {
2168  if (fValuePointer) {
2169  gInterpreter->Calc(Form(fDeleteFormat.Data(),fValuePointer));
2170  }
2171  delete fMethod;
2172 }
2173 
2174 ////////////////////////////////////////////////////////////////////////////////
2175 /// Copy the object and all its content.
2176 
2177 TFormLeafInfo* 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 referencee.
2186 
2187 TClass *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  // Beyhond 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 
2219 TClass* TFormLeafInfoMethod::GetClass() const
2220 {
2221  if (fNext) return fNext->GetClass();
2222  TMethodCall::EReturnType r = fMethod->ReturnType();
2223  if (r!=TMethodCall::kOther) return 0;
2224 
2225  return ReturnTClass(fMethod);
2226 }
2227 
2228 ////////////////////////////////////////////////////////////////////////////////
2229 /// Return true if the return value is integral.
2230 
2231 Bool_t TFormLeafInfoMethod::IsInteger() const
2232 {
2233  TMethodCall::EReturnType r = fMethod->ReturnType();
2234  if (r == TMethodCall::kLong) {
2235  return kTRUE;
2236  } else return kFALSE;
2237 }
2238 
2239 ////////////////////////////////////////////////////////////////////////////////
2240 /// Return true if the return value is a string.
2241 
2242 Bool_t 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 
2255 Bool_t TFormLeafInfoMethod::Update()
2256 {
2257  if (!TFormLeafInfo::Update()) return kFALSE;
2258  delete fMethod;
2259  fMethod = new TMethodCall(fClass, fMethodName, fParams);
2260  return kTRUE;
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 
2267 void *TFormLeafInfoMethod::GetLocalValuePointer( TLeaf *from,
2268  Int_t instance)
2269 {
2270  return TFormLeafInfo::GetLocalValuePointer( from, instance);
2271 }
2272 
2273 ////////////////////////////////////////////////////////////////////////////////
2274 /// Return the address of the lcoal underlying value.
2275 
2276 void *TFormLeafInfoMethod::GetLocalValuePointer(char *from,
2277  Int_t /*instance*/)
2278 {
2279  void *thisobj = from;
2280  if (!thisobj) return 0;
2281 
2282  TMethodCall::EReturnType r = fMethod->ReturnType();
2283  fResult = 0;
2284 
2285  if (r == TMethodCall::kLong) {
2286  Long_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 = 0;
2303  fMethod->Execute(thisobj,&returntext);
2304  gInterpreter->ClearStack();
2305  return returntext;
2306 
2307  } else if (r == TMethodCall::kOther) {
2308  char * char_result = 0;
2309  if (fIsByValue) {
2310  if (fValuePointer) {
2311  gROOT->ProcessLine(Form(fDeleteFormat.Data(),fValuePointer));
2312  fValuePointer = 0;
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 0;
2325 }
2326 
2327 ////////////////////////////////////////////////////////////////////////////////
2328 /// Execute the method on the given address
2329 
2330 template <typename T>
2331 T 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  Long_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 = 0;
2351  fMethod->Execute(thisobj,&returntext);
2352  result = T((Long_t) returntext);
2353 
2354  } else if (fNext) {
2355  char * char_result = 0;
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 
2366 INSTANTIATE_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 
2378 TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim( TClass* classptr,
2379  Long_t offset,
2380  TStreamerElement* element,
2381  TFormLeafInfo* parent) :
2382  TFormLeafInfo(classptr,offset,element),fNsize(0),fCounter2(0),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 != 0) 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 
2402 TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim() :
2403  TFormLeafInfo(0,0,0),fNsize(0),fCounter2(0),fSumOfSizes(0),
2404  fDim(0),fVirtDim(-1),fPrimaryIndex(-1),fSecondaryIndex(-1)
2405 {
2406 }
2407 
2408 ////////////////////////////////////////////////////////////////////////////////
2409 /// Constructor.
2410 
2411 TFormLeafInfoMultiVarDim::TFormLeafInfoMultiVarDim(const TFormLeafInfoMultiVarDim& orig) : TFormLeafInfo(orig)
2412 {
2413  fNsize = orig.fNsize;
2414  orig.fSizes.Copy(fSizes);
2415  fCounter2 = orig.fCounter2?orig.fCounter2->DeepCopy():0;
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 
2426 void 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 
2441 TFormLeafInfoMultiVarDim &TFormLeafInfoMultiVarDim::operator=(const TFormLeafInfoMultiVarDim &other)
2442 {
2443  TFormLeafInfoMultiVarDim tmp(other);
2444  Swap(tmp);
2445  return *this;
2446 }
2447 
2448 ////////////////////////////////////////////////////////////////////////////////
2449 /// Copy the object and all its content.
2450 
2451 TFormLeafInfo* TFormLeafInfoMultiVarDim::DeepCopy() const
2452 {
2453  return new TFormLeafInfoMultiVarDim(*this);
2454 }
2455 
2456 ////////////////////////////////////////////////////////////////////////////////
2457 /// Destructor.
2458 
2459 TFormLeafInfoMultiVarDim:: ~TFormLeafInfoMultiVarDim()
2460 {
2461  delete fCounter2;
2462 }
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 
2472 void 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 vlaue of the primary index.
2502 
2503 Int_t TFormLeafInfoMultiVarDim::GetPrimaryIndex()
2504 {
2505  return fPrimaryIndex;
2506 }
2507 
2508 ////////////////////////////////////////////////////////////////////////////////
2509 /// Return the size of the requested sub-array.
2510 
2511 Int_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 
2523 void TFormLeafInfoMultiVarDim::SetPrimaryIndex(Int_t index)
2524 {
2525  fPrimaryIndex = index;
2526 }
2527 
2528 ////////////////////////////////////////////////////////////////////////////////
2529 /// Set the current value of the primary index.
2530 
2531 void TFormLeafInfoMultiVarDim::SetSecondaryIndex(Int_t index)
2532 {
2533  fSecondaryIndex = index;
2534 }
2535 
2536 ////////////////////////////////////////////////////////////////////////////////
2537 /// Set the sizes of the sub-array.
2538 
2539 void 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 
2548 Int_t TFormLeafInfoMultiVarDim::GetSumOfSizes()
2549 {
2550  return fSumOfSizes;
2551 }
2552 
2553 ////////////////////////////////////////////////////////////////////////////////
2554 
2555 Double_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 
2568 Int_t TFormLeafInfoMultiVarDim::GetVarDim()
2569 {
2570  return fDim;
2571 }
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 
2577 Int_t TFormLeafInfoMultiVarDim::GetVirtVarDim()
2578 {
2579  return fVirtDim;
2580 }
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 
2587 Bool_t TFormLeafInfoMultiVarDim::Update()
2588 {
2589  Bool_t res = TFormLeafInfo::Update();
2590  if (fCounter2) fCounter2->Update();
2591  return res;
2592 }
2593 
2594 ////////////////////////////////////////////////////////////////////////////////
2595 /// Update the sizes of the arrays.
2596 
2597 void 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 
2618 TFormLeafInfo* TFormLeafInfoMultiVarDimDirect::DeepCopy() const
2619 {
2620  return new TFormLeafInfoMultiVarDimDirect(*this);
2621 }
2622 
2623 ////////////////////////////////////////////////////////////////////////////////
2624 /// Return the undersying value.
2625 
2626 template <typename T>
2627 T TFormLeafInfoMultiVarDimDirect::GetValueImpl(TLeaf *leaf, Int_t instance)
2628 {
2629  return ((TLeafElement*)leaf)->GetTypedValueSubArray<T>(fPrimaryIndex,instance);
2630 }
2631 
2632 INSTANTIATE_GETVAL(TFormLeafInfoMultiVarDimDirect);
2633 
2634 ////////////////////////////////////////////////////////////////////////////////
2635 /// Not implemented.
2636 
2637 Double_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 
2652 TFormLeafInfoMultiVarDimCollection::TFormLeafInfoMultiVarDimCollection(
2653  TClass* motherclassptr,
2654  Long_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  : "Unknwon")
2666  )
2667  )
2668 {
2669  R__ASSERT(parent);
2670  fCounter = parent->DeepCopy();
2671  fCounter2 = parent->DeepCopy();
2672  TFormLeafInfo ** next = &(fCounter2->fNext);
2673  while(*next != 0) next = &( (*next)->fNext);
2674  *next = new TFormLeafInfoCollectionSize(elementclassptr);
2675 }
2676 
2677 ////////////////////////////////////////////////////////////////////////////////
2678 /// Constructor.
2679 
2680 TFormLeafInfoMultiVarDimCollection::TFormLeafInfoMultiVarDimCollection(
2681  TClass* motherclassptr,
2682  Long_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 != 0) next = &( (*next)->fNext);
2692  *next = new TFormLeafInfoCollectionSize(motherclassptr,offset,element);
2693 }
2694 
2695 ////////////////////////////////////////////////////////////////////////////////
2696 /// Copy the object and all its content.
2697 
2698 TFormLeafInfo* TFormLeafInfoMultiVarDimCollection::DeepCopy() const
2699 {
2700  return new TFormLeafInfoMultiVarDimCollection(*this);
2701 }
2702 
2703 ////////////////////////////////////////////////////////////////////////////////
2704 
2705 Double_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 
2716 void 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 
2736 template <typename T>
2737 T 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 
2750 INSTANTIATE_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 
2762 TFormLeafInfoMultiVarDimClones::TFormLeafInfoMultiVarDimClones(
2763  TClass* motherclassptr,
2764  Long_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  : "Unknwon")
2776  )
2777  )
2778 {
2779  R__ASSERT(parent);
2780  fCounter = parent->DeepCopy();
2781  fCounter2 = parent->DeepCopy();
2782  TFormLeafInfo ** next = &(fCounter2->fNext);
2783  while(*next != 0) next = &( (*next)->fNext);
2784  *next = new TFormLeafInfoClones(elementclassptr);
2785 }
2786 
2787 ////////////////////////////////////////////////////////////////////////////////
2788 /// Constructor.
2789 
2790 TFormLeafInfoMultiVarDimClones::TFormLeafInfoMultiVarDimClones(
2791  TClass* motherclassptr,
2792  Long_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 != 0) next = &( (*next)->fNext);
2802  *next = new TFormLeafInfoClones(motherclassptr,offset,element);
2803 }
2804 
2805 ////////////////////////////////////////////////////////////////////////////////
2806 /// Copy the object and all its data.
2807 
2808 TFormLeafInfo* TFormLeafInfoMultiVarDimClones::DeepCopy() const
2809 {
2810  return new TFormLeafInfoMultiVarDimClones(*this);
2811 }
2812 
2813 ////////////////////////////////////////////////////////////////////////////////
2814 
2815 Double_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 
2826 void 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 
2849 template <typename T>
2850 T 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 
2863 INSTANTIATE_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 
2873 TFormLeafInfoCast::TFormLeafInfoCast(TClass* classptr, TClass* casted) :
2874  TFormLeafInfo(classptr),fCasted(casted),fGoodCast(kTRUE)
2875 {
2876  if (casted) { fCastedName = casted->GetName(); }
2877  fMultiplicity = -1;
2878  fIsTObject = fClass->IsTObject() && fCasted->IsLoaded();
2879 }
2880 
2881 ////////////////////////////////////////////////////////////////////////////////
2882 /// Constructor.
2883 
2884 TFormLeafInfoCast::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 
2896 void 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 
2908 TFormLeafInfoCast &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 
2918 TFormLeafInfo* TFormLeafInfoCast::DeepCopy() const
2919 {
2920  return new TFormLeafInfoCast(*this);
2921 }
2922 
2923 ////////////////////////////////////////////////////////////////////////////////
2924 /// Destructor.
2925 
2926 TFormLeafInfoCast::~TFormLeafInfoCast()
2927 {
2928 }
2929 
2930 // Currently only implemented in TFormLeafInfoCast
2931 Int_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 
2943 template <typename T>
2944 T 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 = kFALSE;
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 = kTRUE;
2959  return fNext->ReadTypedValue<T>(where,instance);
2960 }
2961 
2962 INSTANTIATE_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 
2970 Bool_t 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 TFormLeafInfoTTree::TFormLeafInfoTTree(TTree *tree, const char *alias, TTree *current) :
2987 TFormLeafInfo( TTree::Class(), 0, 0 ), fTree(tree),fCurrent(current),fAlias(alias)
2988 {
2989  // Constructor.
2990 
2991  if (fCurrent==0) fCurrent = fTree->GetFriend(alias);
2992 }
2993 
2994 TFormLeafInfoTTree::TFormLeafInfoTTree(const TFormLeafInfoTTree& orig) :
2995  TFormLeafInfo(orig)
2996 {
2997  // Copy Constructor.
2998  fTree = orig.fTree;
2999  fAlias = orig.fAlias;
3000  fCurrent = orig.fCurrent;
3001 }
3002 
3003 TFormLeafInfo* TFormLeafInfoTTree::DeepCopy() const
3004 {
3005  // Copy the object and all its content.
3006 
3007  return new TFormLeafInfoTTree(*this);
3008 }
3009 
3010 ////////////////////////////////////////////////////////////////////////////////
3011 /// returns the address of the value pointed to by the
3012 /// TFormLeafInfo.
3013 
3014 void* TFormLeafInfoTTree::GetLocalValuePointer(TLeaf *, Int_t instance)
3015 {
3016  return GetLocalValuePointer((char*)fCurrent,instance);
3017 }
3018 
3019 ////////////////////////////////////////////////////////////////////////////////
3020 /// Return result of a leafobject method.
3021 
3022 template <typename T>
3023 T TFormLeafInfoTTree::GetValueImpl(TLeaf *, Int_t instance)
3024 {
3025  return ReadTypedValue<T>((char*)fCurrent,instance);
3026 }
3027 
3028 ////////////////////////////////////////////////////////////////////////////////
3029 /// Return result of a leafobject method.
3030 
3031 template <typename T>
3032 T TFormLeafInfoTTree::ReadValueImpl(char *thisobj, Int_t instance)
3033 {
3034  if (fElement) return TFormLeafInfo::ReadTypedValue<T>(thisobj,instance);
3035  else if (fNext) return fNext->ReadTypedValue<T>(thisobj,instance);
3036  else return 0;
3037 }
3038 
3039 INSTANTIATE_GETVAL(TFormLeafInfoTTree);
3040 INSTANTIATE_READVAL(TFormLeafInfoTTree);
3041 
3042 ////////////////////////////////////////////////////////////////////////////////
3043 /// Update after a change of file in a chain
3044 
3045 Bool_t TFormLeafInfoTTree::Update()
3046 {
3047  if (fAlias.Length() && fAlias != fTree->GetName()) {
3048  fCurrent = fTree->GetFriend(fAlias.Data());
3049  }
3050  return fCurrent && TFormLeafInfo::Update();
3051 }