Logo ROOT   master
Reference Guide
TBranchProxy.h
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Philippe Canal 01/06/2004
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, 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 #ifndef ROOT_TBranchProxy
13 #define ROOT_TBranchProxy
14 
15 #include "TBranchProxyDirector.h"
16 #include "TTree.h"
17 #include "TBranch.h"
18 #include "TLeaf.h"
19 #include "TClonesArray.h"
20 #include "TString.h"
21 #include "Riostream.h"
22 #include "TError.h"
24 #include "TNotifyLink.h"
25 
26 #include <algorithm>
27 
28 class TBranch;
29 class TStreamerElement;
30 
31 // Note we could protect the arrays more by introducing a class TArrayWrapper<class T> which somehow knows
32 // its internal dimensions and check for them ...
33 // template <class T> TArrayWrapper {
34 // public:
35 // TArrayWrapper(void *where, int dim1);
36 // const T operator[](int i) {
37 // if (i>=dim1) return 0;
38 // return where[i];
39 // };
40 // };
41 // 2D array would actually be a wrapper of a wrapper i.e. has a method TArrayWrapper<T> operator[](int i);
42 
43 namespace ROOT {
44 namespace Internal {
45  //_______________________________________________
46  // String builder to be used in the constructors.
48  public:
50  TBranchProxyHelper(const char *left,const char *right = 0) :
51  fName() {
52  if (left) {
53  fName = left;
54  if (left[0]&&right && fName[fName.Length()-1]!='.') fName += ".";
55  }
56  if (right) {
57  fName += right;
58  }
59  }
60  operator const char*() { return fName.Data(); };
61  };
62 
64 } // namespace Internal
65 
66 
67 namespace Detail {
68  class TBranchProxy {
69  protected:
70  Internal::TBranchProxyDirector *fDirector; // contain pointer to TTree and entry to be read
71 
73  const Bool_t fIsMember : 1; // true if we proxy an unsplit data member
74  Bool_t fIsClone : 1; // true if we proxy the inside of a TClonesArray
75  Bool_t fIsaPointer : 1; // true if we proxy a data member of pointer type
76  Bool_t fHasLeafCount : 1;// true if we proxy a variable size leaf of a leaflist
77 
78  const TString fBranchName; // name of the branch to read
79  TBranchProxy *fParent; // Proxy to a parent object
80 
81  const TString fDataMember; // name of the (eventual) data member being proxied
82 
83 
84  TString fClassName; // class name of the object pointed to by the branch
85  TClass *fClass; // class name of the object pointed to by the branch
88  Int_t fOffset; // Offset inside the object
89  Int_t fArrayLength; // Number of element if the data is an array
90 
91  TBranch *fBranch; // branch to read
92  union {
93  TBranch *fBranchCount; // eventual auxiliary branch (for example holding the size)
94  TLeaf *fLeafCount; // eventual auxiliary leaf (for example holding the size)
95  };
96 
97  TNotifyLink<TBranchProxy> fNotify; // Callback object used by the TChain to update this proxy
98 
99  Long64_t fRead; // Last entry read
100 
101  void *fWhere; // memory location of the data
102  TVirtualCollectionProxy *fCollection; // Handle to the collection containing the data chunk.
103 
104  public:
105  virtual void Print();
106 
107  TBranchProxy();
108  TBranchProxy(Internal::TBranchProxyDirector* boss, const char* top, const char* name = 0);
109  TBranchProxy(Internal::TBranchProxyDirector* boss, const char *top, const char *name, const char *membername);
110  TBranchProxy(Internal::TBranchProxyDirector* boss, TBranchProxy *parent, const char* membername, const char* top = 0, const char* name = 0);
111  TBranchProxy(Internal::TBranchProxyDirector* boss, TBranch* branch, const char* membername);
112  TBranchProxy(Internal::TBranchProxyDirector* boss, const char* branchname, TBranch* branch, const char* membername);
113  virtual ~TBranchProxy();
114 
115  TBranchProxy* GetProxy() { return this; }
116  const char* GetBranchName() const { return fBranchName; }
117 
118  void Reset();
119 
121  fRead = -1;
122  return Setup();
123  }
124 
125  Bool_t Setup();
126 
128  return fInitialized;
129  // return fLastTree && fCurrentTreeNumber == fDirector->GetTree()->GetTreeNumber() && fLastTree == fDirector->GetTree();
130  }
131 
132  Bool_t IsaPointer() const {
133  return fIsaPointer;
134  }
135 
137  if (R__unlikely(fDirector==0)) return false;
138 
139  auto treeEntry = fDirector->GetReadEntry();
140  if (treeEntry != fRead) {
141  if (!IsInitialized()) {
142  if (!Setup()) {
143  ::Error("TBranchProxy::Read","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
144  return kFALSE;
145  }
146  }
147  Bool_t result = kTRUE;
148  if (fParent) {
149  result = fParent->Read();
150  } else {
151  if (fBranchCount) {
152  result &= (-1 != fBranchCount->GetEntry(treeEntry));
153  }
154  result &= (-1 != fBranch->GetEntry(treeEntry));
155  }
156  fRead = treeEntry;
157  if (R__unlikely(fCollection)) {
158  fCollection->PopProxy(); // works even if no proxy env object was set.
159  if (IsaPointer()) {
160  fCollection->PushProxy( *(void**)fWhere );
161  } else {
163  }
164  }
165  return result;
166  } else {
167  return IsInitialized();
168  }
169  }
170 
171 private:
173 
174  enum class EReadType {
175  kDefault,
176  kNoDirector,
186  };
187 
189  if (fParent) {
190  if (!fCollection) {
192  } else {
193  if (IsaPointer()) {
195  } else {
197  }
198  }
199  } else {
200  if (fBranchCount) {
201  if (fCollection) {
202  if (IsaPointer()) {
204  } else {
206  }
207  } else {
209  }
210 
211  } else {
212  if (fCollection) {
213  if (IsaPointer()) {
215  } else {
217  }
218  } else {
220  }
221  }
222  }
223  return EReadType::kDefault;
224  }
225 
227  return false;
228  }
229 
231  auto treeEntry = fDirector->GetReadEntry();
232  if (treeEntry != fRead) {
233  const Bool_t result = fParent->Read();
234  fRead = treeEntry;
235  return result;
236  } else {
237  return IsInitialized();
238  }
239  }
240 
242  auto treeEntry = fDirector->GetReadEntry();
243  if (treeEntry != fRead) {
244  const Bool_t result = fParent->Read();
245  fRead = treeEntry;
246  fCollection->PopProxy(); // works even if no proxy env object was set.
248  return result;
249  } else {
250  return IsInitialized();
251  }
252  }
253 
255  auto treeEntry = fDirector->GetReadEntry();
256  if (treeEntry != fRead) {
257  const Bool_t result = fParent->Read();
258  fRead = treeEntry;
259  fCollection->PopProxy(); // works even if no proxy env object was set.
260  fCollection->PushProxy( *(void**)fWhere );
261  return result;
262  } else {
263  return IsInitialized();
264  }
265  }
266 
268  auto treeEntry = fDirector->GetReadEntry();
269  if (treeEntry != fRead) {
270  Bool_t result = (-1 != fBranch->GetEntry(treeEntry));
271  fRead = treeEntry;
272  fCollection->PopProxy(); // works even if no proxy env object was set.
273  fCollection->PushProxy( *(void**)fWhere );
274  return result;
275  } else {
276  return IsInitialized();
277  }
278  }
279 
281  auto treeEntry = fDirector->GetReadEntry();
282  if (treeEntry != fRead) {
283  Bool_t result = (-1 != fBranch->GetEntry(treeEntry));
284  fRead = treeEntry;
285  fCollection->PopProxy(); // works even if no proxy env object was set.
287  return result;
288  } else {
289  return IsInitialized();
290  }
291  }
292 
294  auto treeEntry = fDirector->GetReadEntry();
295  if (treeEntry != fRead) {
296  Bool_t result = (-1 != fBranch->GetEntry(treeEntry));
297  fRead = treeEntry;
298  return result;
299  } else {
300  return IsInitialized();
301  }
302  }
303 
305  auto treeEntry = fDirector->GetReadEntry();
306  if (treeEntry != fRead) {
307  Bool_t result = (-1 != fBranchCount->GetEntry(treeEntry));
308  result &= (-1 != fBranch->GetEntry(treeEntry));
309  fRead = treeEntry;
310  fCollection->PopProxy(); // works even if no proxy env object was set.
311  fCollection->PushProxy( *(void**)fWhere );
312  return result;
313  } else {
314  return IsInitialized();
315  }
316  }
317 
319  auto treeEntry = fDirector->GetReadEntry();
320  if (treeEntry != fRead) {
321  Bool_t result = (-1 != fBranchCount->GetEntry(treeEntry));
322  result &= (-1 != fBranch->GetEntry(treeEntry));
323  fRead = treeEntry;
324  fCollection->PopProxy(); // works even if no proxy env object was set.
326  return result;
327  } else {
328  return IsInitialized();
329  }
330  }
331 
333  auto treeEntry = fDirector->GetReadEntry();
334  if (treeEntry != fRead) {
335  Bool_t result = (-1 != fBranchCount->GetEntry(treeEntry));
336  result &= (-1 != fBranch->GetEntry(treeEntry));
337  fRead = treeEntry;
338  return result;
339  } else {
340  return IsInitialized();
341  }
342  }
343 
344 public:
345 
347  if (R__unlikely(fDirector==0)) return false;
348 
349  auto treeEntry = fDirector->GetReadEntry();
350  if (treeEntry != fRead) {
351  if (!IsInitialized()) {
352  if (!Setup()) {
353  ::Error("TBranchProxy::ReadEntries","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
354  return false;
355  }
356  }
357  if (fParent) fParent->ReadEntries();
358  else {
359  if (fBranchCount) {
360  fBranchCount->TBranch::GetEntry(treeEntry);
361  }
362  fBranch->TBranch::GetEntry(treeEntry);
363  }
364  // NO - we only read the entries, not the contained objects!
365  // fRead = treeEntry;
366  }
367  return IsInitialized();
368  }
369 
370  virtual Int_t GetEntries() {
371  if (!ReadEntries()) return 0;
372  if (!fHasLeafCount) {
373  return *(Int_t*)fLeafCount->GetValuePointer();
374  } else {
375  return 1;
376  }
377  }
378 
379  virtual Int_t GetArrayLength() {
380  return fArrayLength;
381  }
382 
384  if (fDirector==0) return 0;
385 
386  if (fDirector->GetReadEntry() != fRead) {
387  if (!IsInitialized()) {
388  if (!Setup()) {
389  return 0;
390  }
391  }
392  }
393  return fClass;
394  }
395 
396  void* GetWhere() const { return fWhere; } // intentionally non-virtual
397 
398  /// Return the address of the element number i. Returns `nullptr` for non-collections. It assumed that Setip() has
399  /// been called.
400  virtual void *GetAddressOfElement(UInt_t /*i*/) {
401  return nullptr;
402  }
403 
405 
406  // protected:
407  virtual void *GetStart(UInt_t /*i*/=0) {
408  // return the address of the start of the object being proxied. Assumes
409  // that Setup() has been called.
410 
411  if (fParent) {
412  fWhere = ((unsigned char*)fParent->GetStart()) + fMemberOffset;
413  }
414  if (IsaPointer()) {
415  if (fWhere) return *(void**)fWhere;
416  else return 0;
417  } else {
418  return fWhere;
419  }
420  }
421 
422  void *GetClaStart(UInt_t i=0) {
423  // return the address of the start of the object being proxied. Assumes
424  // that Setup() has been called. Assumes the object containing this data
425  // member is held in TClonesArray.
426 
427  char *location;
428 
429  if (fIsClone) {
430 
431  TClonesArray *tca;
432  tca = (TClonesArray*)GetStart();
433 
434  if (!tca || tca->GetLast()<(Int_t)i) return 0;
435 
436  location = (char*)tca->At(i);
437 
438  return location;
439 
440  } else if (fParent) {
441 
442  //tcaloc = ((unsigned char*)fParent->GetStart());
443  location = (char*)fParent->GetClaStart(i);
444 
445  } else {
446 
447  void *tcaloc;
448  tcaloc = fWhere;
449  TClonesArray *tca;
450  tca = (TClonesArray*)tcaloc;
451 
452  if (tca->GetLast()<(Int_t)i) return 0;
453 
454  location = (char*)tca->At(i);
455  }
456 
457  if (location) location += fOffset;
458  else return 0;
459 
460  if (IsaPointer()) {
461  return *(void**)(location);
462  } else {
463  return location;
464  }
465 
466  }
467 
468  void *GetStlStart(UInt_t i=0) {
469  // return the address of the start of the object being proxied. Assumes
470  // that Setup() has been called. Assumes the object containing this data
471  // member is held in STL Collection.
472 
473  char *location=0;
474 
475  if (fCollection) {
476 
477  if (fCollection->Size()<i) return 0;
478 
479  location = (char*)fCollection->At(i);
480 
481  // return location;
482 
483  } else if (fParent) {
484 
485  //tcaloc = ((unsigned char*)fParent->GetStart());
486  location = (char*)fParent->GetStlStart(i);
487 
488  } else {
489 
490  R__ASSERT(0);
491  //void *tcaloc;
492  //tcaloc = fWhere;
493  //TClonesArray *tca;
494  //tca = (TClonesArray*)tcaloc;
495 
496  //if (tca->GetLast()<i) return 0;
497 
498  //location = (char*)tca->At(i);
499  }
500 
501  if (location) location += fOffset;
502  else return 0;
503 
504  if (IsaPointer()) {
505  return *(void**)(location);
506  } else {
507  return location;
508  }
509 
510  }
511 
512  Int_t GetOffset() { return fOffset; }
513  };
514 } // namespace Detail
515 
516 namespace Internal {
517 
518  //____________________________________________________________________________________________
519  // Concrete Implementation of the branch proxy around the data members which are array of char
521  public:
522  void Print() override {
524  std::cout << "fWhere " << fWhere << std::endl;
525  if (fWhere) std::cout << "value? " << *(unsigned char*)GetStart() << std::endl;
526  }
527 
529  TArrayCharProxy() = default; // work around bug in GCC < 7
530  ~TArrayCharProxy() override = default;
531 
532  void *GetAddressOfElement(UInt_t i) final {
533  if (!Read()) return nullptr;
534  unsigned char* str = (unsigned char*)GetStart();
535  return str + i;
536  }
537 
538  unsigned char At(UInt_t i) {
539  static unsigned char default_val = {};
540  if (unsigned char* elAddr = (unsigned char*)GetAddressOfElement(i)) {
541  // should add out-of bound test
542  return *elAddr;
543  }
544  return default_val;
545  }
546 
547  unsigned char operator [](Int_t i) {
548  return At(i);
549  }
550 
551  unsigned char operator [](UInt_t i) {
552  return At(i);
553  }
554 
555  operator const char*() {
556  if (!Read()) return "";
557  return (const char*)GetStart();
558  }
559 
560  const char* Data() {
561  if (!Read()) return "";
562  return (const char*)GetStart();
563  }
564 
565  const char* c_str() {
566  if (!Read()) return "";
567  return (const char*)GetStart();
568  }
569 
570  operator std::string() {
571  if (!Read()) return "";
572  return std::string((const char*)GetStart());
573  }
574 
575  };
576 
577  //_______________________________________________________
578  // Base class for the proxy around object in TClonesArray.
580  public:
581  void Print() override {
583  std::cout << "fWhere " << fWhere << std::endl;
584  if (fWhere) {
585  if (IsaPointer()) {
586  std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
587  } else {
588  std::cout << "location " << fWhere << std::endl;
589  }
590  }
591  }
592 
594  TClaProxy() = default; // work around bug in GCC < 7
595  ~TClaProxy() override = default;
596 
597  const TClonesArray* GetPtr() {
598  if (!Read()) return 0;
599  return (TClonesArray*)GetStart();
600  }
601 
602  Int_t GetEntries() override {
603  if (!ReadEntries()) return 0;
605  if (arr) return arr->GetEntries();
606  return 0;
607  }
608 
609  void *GetAddressOfElement(UInt_t i) final {
610  if (!Read()) return nullptr;
611  if (fWhere==0) return nullptr;
612  return GetClaStart(i);
613  }
614 
615  const TClonesArray* operator->() { return GetPtr(); }
616 
617  };
618 
619  //_______________________________________________
620  // Base class for the proxy around STL containers.
622  public:
623  void Print() override {
625  std::cout << "fWhere " << fWhere << std::endl;
626  if (fWhere) {
627  if (IsaPointer()) {
628  std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
629  } else {
630  std::cout << "location " << fWhere << std::endl;
631  }
632  }
633  }
634 
636  TStlProxy() = default; // work around bug in GCC < 7
637  ~TStlProxy() override = default;
638 
640  if (!Read()) return 0;
641  return GetCollection();
642  }
643 
644  Int_t GetEntries() override {
645  if (!ReadEntries()) return 0;
646  return GetPtr()->Size();
647  }
648 
649  void *GetAddressOfElement(UInt_t i) final {
650  if (!Read()) return nullptr;
651  if (fWhere==0) return nullptr;
652  return GetStlStart(i);
653  }
654 
656 
657  };
658 
659  //______________________________________
660  // Template of the proxy around objects.
661  template <class T>
663  public:
664  void Print() override {
666  std::cout << "fWhere " << fWhere << std::endl;
667  if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
668  }
669 
671  TImpProxy() = default; // work around bug in GCC < 7
672  ~TImpProxy() override = default;
673 
674  operator T() {
675  if (!Read()) return 0;
676  return *(T*)GetStart();
677  }
678 
679  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
680  TImpProxy(T) = delete;
681  TImpProxy &operator=(T) = delete;
682 
683  };
684 
685  //____________________________________________
686  // Helper template to be able to determine and
687  // use array dimentsions.
688  template <class T, int d = 0> struct TArrayType {
689  typedef T type_t;
690  typedef T array_t[d];
691  static constexpr int gSize = d;
692  };
693  //____________________________________________
694  // Helper class for proxy around multi dimension array
695  template <class T> struct TArrayType<T,0> {
696  typedef T type_t;
697  typedef T array_t;
698  static constexpr int gSize = 0;
699  };
700  //____________________________________________
701  // Helper class for proxy around multi dimension array
702  template <class T, int d> struct TMultiArrayType {
703  typedef typename T::type_t type_t;
704  typedef typename T::array_t array_t[d];
705  static constexpr int gSize = d;
706  };
707 
708  //____________________________________________
709  // Template for concrete implementation of proxy around array of T
710  template <class T>
712  public:
714  TArrayProxy() = default; // work around bug in GCC < 7
715  ~TArrayProxy() override = default;
716 
717  typedef typename T::array_t array_t;
718  typedef typename T::type_t type_t;
719 
720  void Print() override {
722  std::cout << "fWhere " << GetWhere() << std::endl;
723  if (GetWhere()) std::cout << "value? " << *(type_t*)GetWhere() << std::endl;
724  }
725 
726  Int_t GetEntries() override {
727  return T::gSize;
728  }
729 
730  void *GetAddressOfElement(UInt_t i) final {
731  if (!Read()) return nullptr;
732  if (array_t *arr = (array_t*)((type_t*)(GetStart())))
733  return &arr[i];
734  return nullptr;
735  }
736 
737  const array_t &At(UInt_t i) {
738  static array_t default_val;
739  // should add out-of bound test
740  if (array_t *arr = (array_t*)GetAddressOfElement(i))
741  return *arr;
742  return default_val;
743  }
744 
745  const array_t &operator [](Int_t i) { return At(i); }
746  const array_t &operator [](UInt_t i) { return At(i); }
747  };
748 
749  //_____________________________________________________________________________________
750  // Template of the Concrete Implementation of the branch proxy around TClonesArray of T
751  template <class T>
752  class TClaImpProxy : public TClaProxy {
753  public:
754 
755  // void Print() override {
756  // TClaProxy::Print();
757  // }
758 
759  using TClaProxy::TClaProxy;
760  TClaImpProxy() = default; // work around bug in GCC < 7
761  ~TClaImpProxy() override = default;
762 
763  const T& At(UInt_t i) {
764  static T default_val;
765  if (void* addr = GetAddressOfElement(i))
766  return *(T*)addr;
767  return default_val;
768  }
769 
770  const T& operator [](Int_t i) { return At(i); }
771  const T& operator [](UInt_t i) { return At(i); }
772 
773  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
774  TClaImpProxy(T) = delete;
775  TClaImpProxy &operator=(T) = delete;
776 
777  };
778 
779  //_________________________________________________________________________________________
780  // Template of the Concrete Implementation of the branch proxy around an stl container of T
781  template <class T>
782  class TStlImpProxy : public TStlProxy {
783  public:
784 
785  // void Print() override {
786  // TBranchProxy::Print();
787  // }
788 
789  using TStlProxy::TStlProxy;
790  TStlImpProxy() = default; // work around bug in GCC < 7
791  ~TStlImpProxy() override = default;
792 
793  const T& At(UInt_t i) {
794  static T default_val;
795  if (void* addr = GetAddressOfElement(i))
796  return *(T*)addr;
797  return default_val;
798  }
799 
800  const T& operator [](Int_t i) { return At(i); }
801  const T& operator [](UInt_t i) { return At(i); }
802 
803  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
804  TStlImpProxy(T) = delete;
805  TStlImpProxy &operator=(T) = delete;
806 
807  };
808 
809  //_________________________________________________________________________________________________
810  // Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
811  template <class T>
812  class TClaArrayProxy : public TClaProxy {
813  public:
814  typedef typename T::array_t array_t;
815  typedef typename T::type_t type_t;
816 
817  // void Print() override {
818  // TClaProxy::Print();
819  // }
820 
821  using TClaProxy::TClaProxy;
822  TClaArrayProxy() = default; // work around bug in GCC < 7
823  ~TClaArrayProxy() override = default;
824 
825  /* const */ array_t *At(UInt_t i) {
826  static array_t default_val;
827  if (array_t* ptr = (array_t*)GetAddressOfElement(i))
828  return ptr; // no de-ref!
829 
830  return &default_val;
831  }
832 
833  /* const */ array_t *operator [](Int_t i) { return At(i); }
834  /* const */ array_t *operator [](UInt_t i) { return At(i); }
835  };
836 
837 
838  //__________________________________________________________________________________________________
839  // Template of the Concrete Implementation of the branch proxy around an stl container of array of T
840  template <class T>
841  class TStlArrayProxy : public TStlProxy {
842  public:
843  typedef typename T::array_t array_t;
844  typedef typename T::type_t type_t;
845 
846  // void Print() override {
847  // TBranchProxy::Print();
848  // }
849 
850  using TStlProxy::TStlProxy;
851  TStlArrayProxy() = default; // work around bug in GCC < 7
852  ~TStlArrayProxy() override = default;
853 
854  /* const */ array_t *At(UInt_t i) {
855  static array_t default_val;
856  if (array_t* ptr = (array_t*)GetAddressOfElement(i))
857  return ptr; // no de-ref!
858  return &default_val;
859  }
860 
861  /* const */ array_t *operator [](Int_t i) { return At(i); }
862  /* const */ array_t *operator [](UInt_t i) { return At(i); }
863  };
864 
865  //TImpProxy<TObject> d;
866  typedef TImpProxy<Double_t> TDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are double
867  typedef TImpProxy<Double32_t> TDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are double32
868  typedef TImpProxy<Float_t> TFloatProxy; // Concrete Implementation of the branch proxy around the data members which are float
869  typedef TImpProxy<Float16_t> TFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are float16
870  typedef TImpProxy<UInt_t> TUIntProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned int
871  typedef TImpProxy<ULong_t> TULongProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long
872  typedef TImpProxy<ULong64_t> TULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long long
873  typedef TImpProxy<UShort_t> TUShortProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned short
874  typedef TImpProxy<UChar_t> TUCharProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned char
875  typedef TImpProxy<Int_t> TIntProxy; // Concrete Implementation of the branch proxy around the data members which are int
876  typedef TImpProxy<Long_t> TLongProxy; // Concrete Implementation of the branch proxy around the data members which are long
877  typedef TImpProxy<Long64_t> TLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are long long
878  typedef TImpProxy<Short_t> TShortProxy; // Concrete Implementation of the branch proxy around the data members which are short
879  typedef TImpProxy<Char_t> TCharProxy; // Concrete Implementation of the branch proxy around the data members which are char
880  typedef TImpProxy<Bool_t> TBoolProxy; // Concrete Implementation of the branch proxy around the data members which are bool
881 
882  typedef TArrayProxy<TArrayType<Double_t> > TArrayDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are array of double
883  typedef TArrayProxy<TArrayType<Double32_t> > TArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are array of double32
884  typedef TArrayProxy<TArrayType<Float_t> > TArrayFloatProxy; // Concrete Implementation of the branch proxy around the data members which are array of float
885  typedef TArrayProxy<TArrayType<Float16_t> > TArrayFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are array of float16
886  typedef TArrayProxy<TArrayType<UInt_t> > TArrayUIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned int
887  typedef TArrayProxy<TArrayType<ULong_t> > TArrayULongProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long
888  typedef TArrayProxy<TArrayType<ULong64_t> > TArrayULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long long
889  typedef TArrayProxy<TArrayType<UShort_t> > TArrayUShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned short
890  typedef TArrayProxy<TArrayType<UChar_t> > TArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned char
891  typedef TArrayProxy<TArrayType<Int_t> > TArrayIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of int
892  typedef TArrayProxy<TArrayType<Long_t> > TArrayLongProxy; // Concrete Implementation of the branch proxy around the data members which are array of long
893  typedef TArrayProxy<TArrayType<Long64_t> > TArrayLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of long long
894  typedef TArrayProxy<TArrayType<UShort_t> > TArrayShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of short
895  //specialized ! typedef TArrayProxy<TArrayType<Char_t> > TArrayCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of char
896  typedef TArrayProxy<TArrayType<Bool_t> > TArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members which are array of bool
897 
898  typedef TClaImpProxy<Double_t> TClaDoubleProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double
899  typedef TClaImpProxy<Double32_t> TClaDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double32
900  typedef TClaImpProxy<Float_t> TClaFloatProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float
901  typedef TClaImpProxy<Float16_t> TClaFloat16Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float16
902  typedef TClaImpProxy<UInt_t> TClaUIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned int
903  typedef TClaImpProxy<ULong_t> TClaULongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long
904  typedef TClaImpProxy<ULong64_t> TClaULong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long long
905  typedef TClaImpProxy<UShort_t> TClaUShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned short
906  typedef TClaImpProxy<UChar_t> TClaUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned char
907  typedef TClaImpProxy<Int_t> TClaIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are int
908  typedef TClaImpProxy<Long_t> TClaLongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long
909  typedef TClaImpProxy<Long64_t> TClaLong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long long
910  typedef TClaImpProxy<Short_t> TClaShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are short
911  typedef TClaImpProxy<Char_t> TClaCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are char
912  typedef TClaImpProxy<Bool_t> TClaBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are bool
913 
914  typedef TClaArrayProxy<TArrayType<Double_t> > TClaArrayDoubleProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of double
915  typedef TClaArrayProxy<TArrayType<Double32_t> > TClaArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of double32
916  typedef TClaArrayProxy<TArrayType<Float_t> > TClaArrayFloatProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of float
917  typedef TClaArrayProxy<TArrayType<Float16_t> > TClaArrayFloat16Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of float16
918  typedef TClaArrayProxy<TArrayType<UInt_t> > TClaArrayUIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of unsigned int
919  typedef TClaArrayProxy<TArrayType<ULong_t> > TClaArrayULongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of unsigned long
920  typedef TClaArrayProxy<TArrayType<ULong64_t> > TClaArrayULong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of unsigned long long
921  typedef TClaArrayProxy<TArrayType<UShort_t> > TClaArrayUShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of unsigned short
922  typedef TClaArrayProxy<TArrayType<UChar_t> > TClaArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of nsigned char
923  typedef TClaArrayProxy<TArrayType<Int_t> > TClaArrayIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of int
924  typedef TClaArrayProxy<TArrayType<Long_t> > TClaArrayLongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of long
925  typedef TClaArrayProxy<TArrayType<Long64_t> > TClaArrayLong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of long long
926  typedef TClaArrayProxy<TArrayType<UShort_t> > TClaArrayShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of short
927  typedef TClaArrayProxy<TArrayType<Char_t> > TClaArrayCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of char
928  typedef TClaArrayProxy<TArrayType<Bool_t> > TClaArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of bool
929  //specialized ! typedef TClaArrayProxy<TArrayType<Char_t> > TClaArrayCharProxy;
930 
931  typedef TStlImpProxy<Double_t> TStlDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
932  typedef TStlImpProxy<Double32_t> TStlDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
933  typedef TStlImpProxy<Float_t> TStlFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
934  typedef TStlImpProxy<Float16_t> TStlFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
935  typedef TStlImpProxy<UInt_t> TStlUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
936  typedef TStlImpProxy<ULong_t> TStlULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
937  typedef TStlImpProxy<ULong64_t> TStlULong64Proxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long long
938  typedef TStlImpProxy<UShort_t> TStlUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
939  typedef TStlImpProxy<UChar_t> TStlUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
940  typedef TStlImpProxy<Int_t> TStlIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
941  typedef TStlImpProxy<Long_t> TStlLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
942  typedef TStlImpProxy<Long64_t> TStlLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
943  typedef TStlImpProxy<Short_t> TStlShortProxy; // Concrete Implementation of the branch proxy around an stl container of short
944  typedef TStlImpProxy<Char_t> TStlCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
945  typedef TStlImpProxy<Bool_t> TStlBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
946 
947  typedef TStlArrayProxy<TArrayType<Double_t> > TStlArrayDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
948  typedef TStlArrayProxy<TArrayType<Double32_t> > TStlArrayDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
949  typedef TStlArrayProxy<TArrayType<Float_t> > TStlArrayFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
950  typedef TStlArrayProxy<TArrayType<Float16_t> > TStlArrayFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
951  typedef TStlArrayProxy<TArrayType<UInt_t> > TStlArrayUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
952  typedef TStlArrayProxy<TArrayType<ULong_t> > TStlArrayULongProxy; // Concrete Implementation of the branch proxy around an stl container of usigned long
953  typedef TStlArrayProxy<TArrayType<ULong64_t> > TStlArrayULong64Proxy; // Concrete Implementation of the branch proxy around an stl contained of unsigned long long
954  typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unisgned short
955  typedef TStlArrayProxy<TArrayType<UChar_t> > TStlArrayUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsingned char
956  typedef TStlArrayProxy<TArrayType<Int_t> > TStlArrayIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
957  typedef TStlArrayProxy<TArrayType<Long_t> > TStlArrayLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
958  typedef TStlArrayProxy<TArrayType<Long64_t> > TStlArrayLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
959  typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayShortProxy; // Concrete Implementation of the branch proxy around an stl container of UShort_t
960  typedef TStlArrayProxy<TArrayType<Char_t> > TStlArrayCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
961  typedef TStlArrayProxy<TArrayType<Bool_t> > TStlArrayBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
962 
963 } // namespace Internal
964 
965 // Reasonably backward compatible.
967 
968 } // namespace ROOT
969 
970 #endif
971 
TStlArrayProxy< TArrayType< Bool_t > > TStlArrayBoolProxy
Definition: TBranchProxy.h:961
TStlArrayProxy< TArrayType< Int_t > > TStlArrayIntProxy
Definition: TBranchProxy.h:956
TImpProxy< Double32_t > TDouble32Proxy
Definition: TBranchProxy.h:867
TStlArrayProxy< TArrayType< Double_t > > TStlArrayDoubleProxy
Definition: TBranchProxy.h:947
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:49
Int_t GetEntries() override
Definition: TBranchProxy.h:644
TArrayProxy< TArrayType< Double_t > > TArrayDoubleProxy
Definition: TBranchProxy.h:882
TClaImpProxy< Float_t > TClaFloatProxy
Definition: TBranchProxy.h:900
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayUShortProxy
Definition: TBranchProxy.h:954
void * GetClaStart(UInt_t i=0)
Definition: TBranchProxy.h:422
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
Definition: TBranchProxy.h:649
const array_t & operator[](Int_t i)
Definition: TBranchProxy.h:745
static constexpr int gSize
Definition: TBranchProxy.h:705
long long Long64_t
Definition: RtypesCore.h:69
TStlArrayProxy< TArrayType< Long64_t > > TStlArrayLong64Proxy
Definition: TBranchProxy.h:958
Returns the available number of logical cores.
Definition: StringConv.hxx:21
TStlImpProxy< Float16_t > TStlFloat16Proxy
Definition: TBranchProxy.h:934
TArrayProxy< TArrayType< Long64_t > > TArrayLong64Proxy
Definition: TBranchProxy.h:893
const T & At(UInt_t i)
Definition: TBranchProxy.h:793
TStlImpProxy< ULong64_t > TStlULong64Proxy
Definition: TBranchProxy.h:937
TImpProxy< Double_t > TDoubleProxy
Definition: TBranchProxy.h:866
~TStlProxy() override=default
const TVirtualCollectionProxy * operator->()
Definition: TBranchProxy.h:655
TStlArrayProxy< TArrayType< UChar_t > > TStlArrayUCharProxy
Definition: TBranchProxy.h:955
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
Definition: TBranchProxy.h:532
double T(double x)
Definition: ChebyshevPol.h:34
TImpProxy< ULong64_t > TULong64Proxy
Definition: TBranchProxy.h:872
virtual void PushProxy(void *objectstart)=0
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayShortProxy
Definition: TBranchProxy.h:959
R__EXTERN PyObject * gSize
Definition: PyStrings.h:49
Bool_t ReadParentCollectionNoPointer()
Definition: TBranchProxy.h:241
TArrayProxy< TArrayType< Long_t > > TArrayLongProxy
Definition: TBranchProxy.h:892
TClaImpProxy< UInt_t > TClaUIntProxy
Definition: TBranchProxy.h:902
TClaArrayProxy< TArrayType< Char_t > > TClaArrayCharProxy
Definition: TBranchProxy.h:927
~TArrayProxy() override=default
TImpProxy< Char_t > TCharProxy
Definition: TBranchProxy.h:879
TStlImpProxy< Long64_t > TStlLong64Proxy
Definition: TBranchProxy.h:942
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
Definition: TBranchProxy.h:730
const TClonesArray * operator->()
Definition: TBranchProxy.h:615
TClaImpProxy & operator=(T)=delete
#define R__unlikely(expr)
Definition: RConfig.hxx:604
TArrayProxy< TArrayType< UShort_t > > TArrayUShortProxy
Definition: TBranchProxy.h:889
#define R__ASSERT(e)
Definition: TError.h:96
TStreamerElement * fElement
Definition: TBranchProxy.h:86
TArrayProxy< TArrayType< Double32_t > > TArrayDouble32Proxy
Definition: TBranchProxy.h:883
TClaImpProxy< Float16_t > TClaFloat16Proxy
Definition: TBranchProxy.h:901
const T & At(UInt_t i)
Definition: TBranchProxy.h:763
Basic string class.
Definition: TString.h:131
virtual void * GetStart(UInt_t=0)
Definition: TBranchProxy.h:407
TImpProxy< Float_t > TFloatProxy
Definition: TBranchProxy.h:868
int Int_t
Definition: RtypesCore.h:41
TClaImpProxy< Long_t > TClaLongProxy
Definition: TBranchProxy.h:908
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
TStlImpProxy & operator=(T)=delete
Bool_t ReadNoParentBranchCountCollectionPointer()
Definition: TBranchProxy.h:304
TClaImpProxy< UShort_t > TClaUShortProxy
Definition: TBranchProxy.h:905
~TClaImpProxy() override=default
~TStlImpProxy() override=default
TArrayProxy< TArrayType< ULong_t > > TArrayULongProxy
Definition: TBranchProxy.h:887
TClaArrayProxy< TArrayType< UInt_t > > TClaArrayUIntProxy
Definition: TBranchProxy.h:918
Bool_t ReadNoParentNoBranchCountNoCollection()
Definition: TBranchProxy.h:293
~TClaProxy() override=default
TStlArrayProxy< TArrayType< ULong_t > > TStlArrayULongProxy
Definition: TBranchProxy.h:952
Int_t GetEntries() override
Definition: TBranchProxy.h:602
TStlArrayProxy< TArrayType< Float16_t > > TStlArrayFloat16Proxy
Definition: TBranchProxy.h:950
TStlImpProxy< Short_t > TStlShortProxy
Definition: TBranchProxy.h:943
TArrayProxy< TArrayType< UChar_t > > TArrayUCharProxy
Definition: TBranchProxy.h:890
TStlArrayProxy< TArrayType< ULong64_t > > TStlArrayULong64Proxy
Definition: TBranchProxy.h:953
TNotifyLink< TBranchProxy > fNotify
Definition: TBranchProxy.h:97
static constexpr int gSize
Definition: TBranchProxy.h:691
TArrayProxy< TArrayType< Bool_t > > TArrayBoolProxy
Definition: TBranchProxy.h:896
TClaArrayProxy< TArrayType< UChar_t > > TClaArrayUCharProxy
Definition: TBranchProxy.h:922
void Error(const char *location, const char *msgfmt,...)
Bool_t ReadNoParentNoBranchCountCollectionNoPointer()
Definition: TBranchProxy.h:280
TStlImpProxy< Int_t > TStlIntProxy
Definition: TBranchProxy.h:940
TClaImpProxy< UChar_t > TClaUCharProxy
Definition: TBranchProxy.h:906
const T & operator[](Int_t i)
Definition: TBranchProxy.h:770
TImpProxy< Int_t > TIntProxy
Definition: TBranchProxy.h:875
Int_t GetLast() const
Return index of last object in array.
Definition: TObjArray.cxx:576
array_t * operator[](Int_t i)
Definition: TBranchProxy.h:833
const char * GetBranchName() const
Definition: TBranchProxy.h:116
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayShortProxy
Definition: TBranchProxy.h:926
TClaArrayProxy< TArrayType< Long_t > > TClaArrayLongProxy
Definition: TBranchProxy.h:924
TStlImpProxy< ULong_t > TStlULongProxy
Definition: TBranchProxy.h:936
TStlImpProxy< Char_t > TStlCharProxy
Definition: TBranchProxy.h:944
TArrayProxy< TArrayType< Float16_t > > TArrayFloat16Proxy
Definition: TBranchProxy.h:885
virtual Int_t GetArrayLength()
Definition: TBranchProxy.h:379
unsigned int UInt_t
Definition: RtypesCore.h:42
TImpProxy< UChar_t > TUCharProxy
Definition: TBranchProxy.h:874
TClaImpProxy< Short_t > TClaShortProxy
Definition: TBranchProxy.h:910
char * Form(const char *fmt,...)
TArrayProxy< TArrayType< Int_t > > TArrayIntProxy
Definition: TBranchProxy.h:891
Ssiz_t Length() const
Definition: TString.h:405
TClaArrayProxy< TArrayType< Double_t > > TClaArrayDoubleProxy
Definition: TBranchProxy.h:914
TImpProxy & operator=(T)=delete
Base class of TTreeReaderValue.
virtual void * GetValuePointer() const
Definition: TLeaf.h:128
TClaArrayProxy< TArrayType< Float16_t > > TClaArrayFloat16Proxy
Definition: TBranchProxy.h:917
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayUShortProxy
Definition: TBranchProxy.h:921
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Read all leaves of entry and return total number of bytes read.
Definition: TBranch.cxx:1580
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75
TClaImpProxy< ULong_t > TClaULongProxy
Definition: TBranchProxy.h:903
void * GetStlStart(UInt_t i=0)
Definition: TBranchProxy.h:468
TClaImpProxy< Double_t > TClaDoubleProxy
Definition: TBranchProxy.h:898
TImpProxy< Short_t > TShortProxy
Definition: TBranchProxy.h:878
TImpProxy< Long_t > TLongProxy
Definition: TBranchProxy.h:876
TClaImpProxy< ULong64_t > TClaULong64Proxy
Definition: TBranchProxy.h:904
TClaImpProxy< Long64_t > TClaLong64Proxy
Definition: TBranchProxy.h:909
TStlImpProxy< Double32_t > TStlDouble32Proxy
Definition: TBranchProxy.h:932
Bool_t ReadNoParentBranchCountCollectionNoPointer()
Definition: TBranchProxy.h:318
Int_t GetEntries() override
Definition: TBranchProxy.h:726
const T & operator[](Int_t i)
Definition: TBranchProxy.h:800
const TVirtualCollectionProxy * GetPtr()
Definition: TBranchProxy.h:639
const Bool_t kFALSE
Definition: RtypesCore.h:88
TClaImpProxy< Bool_t > TClaBoolProxy
Definition: TBranchProxy.h:912
TArrayProxy< TArrayType< ULong64_t > > TArrayULong64Proxy
Definition: TBranchProxy.h:888
TStlImpProxy< Float_t > TStlFloatProxy
Definition: TBranchProxy.h:933
#define d(i)
Definition: RSha256.hxx:102
virtual Int_t GetEntries()
Definition: TBranchProxy.h:370
TClaArrayProxy< TArrayType< Int_t > > TClaArrayIntProxy
Definition: TBranchProxy.h:923
virtual void PopProxy()=0
TClaImpProxy< Double32_t > TClaDouble32Proxy
Definition: TBranchProxy.h:899
Bool_t ReadNoParentBranchCountNoCollection()
Definition: TBranchProxy.h:332
Bool_t ReadNoParentNoBranchCountCollectionPointer()
Definition: TBranchProxy.h:267
Long64_t GetReadEntry() const
Return the current &#39;local&#39; entry number; i.e.
TVirtualCollectionProxy * GetCollection()
Definition: TBranchProxy.h:404
TImpProxy< ULong_t > TULongProxy
Definition: TBranchProxy.h:871
TStlImpProxy< UInt_t > TStlUIntProxy
Definition: TBranchProxy.h:935
TClaArrayProxy< TArrayType< Long64_t > > TClaArrayLong64Proxy
Definition: TBranchProxy.h:925
virtual void * At(UInt_t idx)=0
TStlArrayProxy< TArrayType< Char_t > > TStlArrayCharProxy
Definition: TBranchProxy.h:960
TClaArrayProxy< TArrayType< Double32_t > > TClaArrayDouble32Proxy
Definition: TBranchProxy.h:915
TImpProxy< Bool_t > TBoolProxy
Definition: TBranchProxy.h:880
TClaArrayProxy< TArrayType< Bool_t > > TClaArrayBoolProxy
Definition: TBranchProxy.h:928
TImpProxy< UShort_t > TUShortProxy
Definition: TBranchProxy.h:873
~TArrayCharProxy() override=default
Internal::TBranchProxyDirector * fDirector
Definition: TBranchProxy.h:70
TStlImpProxy< Long_t > TStlLongProxy
Definition: TBranchProxy.h:941
TArrayProxy< TArrayType< Float_t > > TArrayFloatProxy
Definition: TBranchProxy.h:884
TStlImpProxy< UChar_t > TStlUCharProxy
Definition: TBranchProxy.h:939
TArrayProxy< TArrayType< UShort_t > > TArrayShortProxy
Definition: TBranchProxy.h:894
~TClaArrayProxy() override=default
TImpProxy< UInt_t > TUIntProxy
Definition: TBranchProxy.h:870
virtual UInt_t Size() const =0
const TClonesArray * GetPtr()
Definition: TBranchProxy.h:597
TArrayProxy< TArrayType< UInt_t > > TArrayUIntProxy
Definition: TBranchProxy.h:886
virtual void * GetAddressOfElement(UInt_t)
Return the address of the element number i.
Definition: TBranchProxy.h:400
TStlArrayProxy< TArrayType< Float_t > > TStlArrayFloatProxy
Definition: TBranchProxy.h:949
TClaImpProxy< Int_t > TClaIntProxy
Definition: TBranchProxy.h:907
An array of clone (identical) objects.
Definition: TClonesArray.h:32
TStlImpProxy< Double_t > TStlDoubleProxy
Definition: TBranchProxy.h:931
TBranchProxyHelper(const char *left, const char *right=0)
Definition: TBranchProxy.h:50
TStlArrayProxy< TArrayType< Long_t > > TStlArrayLongProxy
Definition: TBranchProxy.h:957
~TStlArrayProxy() override=default
TImpProxy< Long64_t > TLong64Proxy
Definition: TBranchProxy.h:877
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:522
TBranchProxy * GetProxy()
Definition: TBranchProxy.h:115
TClaImpProxy< Char_t > TClaCharProxy
Definition: TBranchProxy.h:911
TStlArrayProxy< TArrayType< UInt_t > > TStlArrayUIntProxy
Definition: TBranchProxy.h:951
TStlArrayProxy< TArrayType< Double32_t > > TStlArrayDouble32Proxy
Definition: TBranchProxy.h:948
const array_t & At(UInt_t i)
Definition: TBranchProxy.h:737
TStlImpProxy< Bool_t > TStlBoolProxy
Definition: TBranchProxy.h:945
TImpProxy< Float16_t > TFloat16Proxy
Definition: TBranchProxy.h:869
TClaArrayProxy< TArrayType< Float_t > > TClaArrayFloatProxy
Definition: TBranchProxy.h:916
Base class for all the proxy object.
Definition: TBranchProxy.h:68
array_t * operator[](Int_t i)
Definition: TBranchProxy.h:861
~TImpProxy() override=default
A TTree is a list of TBranches.
Definition: TBranch.h:90
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
Definition: TBranchProxy.h:609
TClaArrayProxy< TArrayType< ULong64_t > > TClaArrayULong64Proxy
Definition: TBranchProxy.h:920
const Bool_t kTRUE
Definition: RtypesCore.h:87
unsigned char operator[](Int_t i)
Definition: TBranchProxy.h:547
TVirtualCollectionProxy * fCollection
Definition: TBranchProxy.h:102
unsigned char At(UInt_t i)
Definition: TBranchProxy.h:538
char name[80]
Definition: TGX11.cxx:109
TClaArrayProxy< TArrayType< ULong_t > > TClaArrayULongProxy
Definition: TBranchProxy.h:919
const char * Data() const
Definition: TString.h:364
TStlImpProxy< UShort_t > TStlUShortProxy
Definition: TBranchProxy.h:938