Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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
16#include "TTree.h"
17#include "TBranchElement.h"
18#include "TLeaf.h"
19#include "TClonesArray.h"
20#include "TString.h"
21#include "TError.h"
23#include "TNotifyLink.h"
24
25#include <algorithm>
26#include <string>
27#include <iostream>
28
29class TBranch;
31
32// Note we could protect the arrays more by introducing a class TArrayWrapper<class T> which somehow knows
33// its internal dimensions and check for them ...
34// template <class T> TArrayWrapper {
35// public:
36// TArrayWrapper(void *where, int dim1);
37// const T operator[](int i) {
38// if (i>=dim1) return 0;
39// return where[i];
40// };
41// };
42// 2D array would actually be a wrapper of a wrapper i.e. has a method TArrayWrapper<T> operator[](int i);
43
44namespace ROOT {
45namespace Internal {
46 ////////////////////////////////////////////////////////////////////////////////
47 /// String builder to be used in the constructors.
49 public:
51 TBranchProxyHelper(const char *left, const char *right = nullptr) :
52 fName() {
53 if (left) {
54 fName = left;
55 if (left[0]&&right && fName[fName.Length()-1]!='.') fName += ".";
56 }
57 if (right) {
58 fName += right;
59 }
60 }
61 operator const char*() { return fName.Data(); }
62 };
63
65} // namespace Internal
66
67// prevent access violation when executing the df017_vecOpsHEP.C tutorial with ROOT built in release mode
68// TODO: to be reviewed when updating Visual Studio or LLVM
69#if defined(_MSC_VER) && !defined(__clang__)
70#pragma optimize("", off)
71#endif
72
73namespace Detail {
75 protected:
76 Internal::TBranchProxyDirector *fDirector; // contain pointer to TTree and entry to be read
77
78 bool fInitialized : 1;
79 const bool fIsMember : 1; // true if we proxy an unsplit data member
80 bool fIsClone : 1; // true if we proxy the inside of a TClonesArray
81 bool fIsaPointer : 1; // true if we proxy a data member of pointer type
82 bool fHasLeafCount : 1;// true if we proxy a variable size leaf of a leaflist
83 bool fSuppressMissingBranchError{false}; // Suppress error issued when the branch is missing from the tree
84
85 const TString fBranchName; // name of the branch to read
86 TBranchProxy *fParent; // Proxy to a parent object
87
88 const TString fDataMember; // name of the (eventual) data member being proxied
89
90
91 TString fClassName; // class name of the object pointed to by the branch
92 TClass *fClass; // class name of the object pointed to by the branch
95 Int_t fOffset; // Offset inside the object
96 Int_t fArrayLength; // Number of element if the data is an array
97
98 TBranch *fBranch; // branch to read
99 union {
100 TBranchElement *fBranchCount; // eventual auxiliary branch (for example holding the size)
101 TLeaf *fLeafCount; // eventual auxiliary leaf (for example holding the size)
102 };
103
104 TNotifyLink<TBranchProxy> fNotify; // Callback object used by the TChain to update this proxy
105
106 Long64_t fRead; // Last entry read
107
108 void *fWhere; // memory location of the data
109 TVirtualCollectionProxy *fCollection; // Handle to the collection containing the data chunk.
110
111 std::size_t fValueSize{}; // Size of the data type of the proxied branch.
112
113 public:
114 virtual void Print();
115
116 TBranchProxy();
117 TBranchProxy(Internal::TBranchProxyDirector* boss, const char* top, const char* name = nullptr);
118 TBranchProxy(Internal::TBranchProxyDirector* boss, const char *top, const char *name, const char *membername);
119 TBranchProxy(Internal::TBranchProxyDirector* boss, TBranchProxy *parent, const char* membername, const char* top = nullptr, const char* name = nullptr);
122 const char *membername, bool suppressMissingBranchError = false);
123 virtual ~TBranchProxy();
124
125 TBranchProxy* GetProxy() { return this; }
126 const char* GetBranchName() const { return fBranchName; }
127
128 void Reset();
129
130 bool Notify() {
131 fRead = -1;
132 return Setup();
133 }
134
135 bool Setup();
136
138 return fInitialized;
139 // return fLastTree && fCurrentTreeNumber == fDirector->GetTree()->GetTreeNumber() && fLastTree == fDirector->GetTree();
140 }
141
142 bool IsaPointer() const {
143 return fIsaPointer;
144 }
145
146 bool Read() {
147 if (R__unlikely(fDirector == nullptr)) return false;
148
150 if (treeEntry != fRead) {
151 if (!IsInitialized()) {
152 if (!Setup()) {
153 ::Error("TBranchProxy::Read","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
154 return false;
155 }
156 }
157 bool result = true;
158 if (fParent) {
159 result = fParent->Read();
160 } else {
161 if (fHasLeafCount) {
162 if (fBranch != fLeafCount->GetBranch())
164 } else if (fBranchCount) {
166 }
167 // Sometimes the branch might be missing, e.g. when processing multiple
168 // files but one file of the chain does not have the branch.
169 if (R__unlikely(fBranch == nullptr))
170 return false;
171 result &= (-1 != fBranch->GetEntry(treeEntry));
172 }
175 fCollection->PopProxy(); // works even if no proxy env object was set.
176 if (IsaPointer()) {
177 fCollection->PushProxy( *(void**)fWhere );
178 } else {
180 }
181 }
182 return result;
183 } else {
184 return IsInitialized();
185 }
186 }
187
188private:
190
204
236
238 return false;
239 }
240
243 if (treeEntry != fRead) {
244 const bool result = fParent->Read();
246 return result;
247 } else {
248 return IsInitialized();
249 }
250 }
251
254 if (treeEntry != fRead) {
255 const bool result = fParent->Read();
257 fCollection->PopProxy(); // works even if no proxy env object was set.
259 return result;
260 } else {
261 return IsInitialized();
262 }
263 }
264
267 if (treeEntry != fRead) {
268 const bool result = fParent->Read();
270 fCollection->PopProxy(); // works even if no proxy env object was set.
271 fCollection->PushProxy( *(void**)fWhere );
272 return result;
273 } else {
274 return IsInitialized();
275 }
276 }
277
279 // Sometimes the branch might be missing, e.g. when processing multiple
280 // files but one file of the chain does not have the branch.
281 if (R__unlikely(fBranch == nullptr))
282 return false;
284 if (treeEntry != fRead) {
285 bool result = (-1 != fBranch->GetEntry(treeEntry));
287 fCollection->PopProxy(); // works even if no proxy env object was set.
288 fCollection->PushProxy( *(void**)fWhere );
289 return result;
290 } else {
291 return IsInitialized();
292 }
293 }
294
296 // Sometimes the branch might be missing, e.g. when processing multiple
297 // files but one file of the chain does not have the branch.
298 if (R__unlikely(fBranch == nullptr))
299 return false;
301 if (treeEntry != fRead) {
302 bool result = (-1 != fBranch->GetEntry(treeEntry));
304 fCollection->PopProxy(); // works even if no proxy env object was set.
306 return result;
307 } else {
308 return IsInitialized();
309 }
310 }
311
313 // Sometimes the branch might be missing, e.g. when processing multiple
314 // files but one file of the chain does not have the branch.
315 if (R__unlikely(fBranch == nullptr))
316 return false;
318 if (treeEntry != fRead) {
319 bool result = (-1 != fBranch->GetEntry(treeEntry));
321 return result;
322 } else {
323 return IsInitialized();
324 }
325 }
326
328 // Sometimes the branch might be missing, e.g. when processing multiple
329 // files but one file of the chain does not have the branch.
330 if (R__unlikely(fBranch == nullptr))
331 return false;
333 if (treeEntry != fRead) {
334 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
335 result &= (-1 != fBranch->GetEntry(treeEntry));
337 fCollection->PopProxy(); // works even if no proxy env object was set.
338 fCollection->PushProxy( *(void**)fWhere );
339 return result;
340 } else {
341 return IsInitialized();
342 }
343 }
344
346 // Sometimes the branch might be missing, e.g. when processing multiple
347 // files but one file of the chain does not have the branch.
348 if (R__unlikely(fBranch == nullptr))
349 return false;
351 if (treeEntry != fRead) {
352 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
353 result &= (-1 != fBranch->GetEntry(treeEntry));
355 fCollection->PopProxy(); // works even if no proxy env object was set.
357 return result;
358 } else {
359 return IsInitialized();
360 }
361 }
362
364 // Sometimes the branch might be missing, e.g. when processing multiple
365 // files but one file of the chain does not have the branch.
366 if (R__unlikely(fBranch == nullptr))
367 return false;
369 if (treeEntry != fRead) {
370 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
371 result &= (-1 != fBranch->GetEntry(treeEntry));
373 return result;
374 } else {
375 return IsInitialized();
376 }
377 }
378
379public:
380
381 bool ReadEntries() {
382 if (R__unlikely(fDirector == nullptr))
383 return false;
385 if (treeEntry != fRead) {
386 if (!IsInitialized()) {
387 if (!Setup()) {
388 ::Error("TBranchProxy::ReadEntries","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
389 return false;
390 }
391 }
393 else {
394 if (fBranchCount) {
395 fBranchCount->TBranch::GetEntry(treeEntry);
396 }
397 // Sometimes the branch might be missing, e.g. when processing multiple
398 // files but one file of the chain does not have the branch.
399 if (R__unlikely(fBranch == nullptr))
400 return false;
401 fBranch->TBranch::GetEntry(treeEntry);
402 }
403 // NO - we only read the entries, not the contained objects!
404 // fRead = treeEntry;
405 }
406 return IsInitialized();
407 }
408
409 virtual Int_t GetEntries() {
410 if (!ReadEntries()) return 0;
411 if (fHasLeafCount) {
412 return *(Int_t*)fLeafCount->GetValuePointer();
413 } else if (fBranchCount) {
414 return fBranchCount->GetNdata();
415 } else {
416 return 1;
417 }
418 }
419
421 return fArrayLength;
422 }
423
425 if (!fDirector) return nullptr;
426
427 if (fDirector->GetReadEntry() != fRead) {
428 if (!IsInitialized()) {
429 if (!Setup()) {
430 return nullptr;
431 }
432 }
433 }
434 return fClass;
435 }
436
437 void* GetWhere() const { return fWhere; } // intentionally non-virtual
438
439 /// Return the address of the element number i. Returns `nullptr` for non-collections. It assumed that Setip() has
440 /// been called.
441 virtual void *GetAddressOfElement(UInt_t /*i*/) {
442 return nullptr;
443 }
444
446
447 // protected:
448 virtual void *GetStart(UInt_t /*i*/=0) {
449 // return the address of the start of the object being proxied. Assumes
450 // that Setup() has been called.
451
452 if (fParent) {
453 fWhere = ((unsigned char*)fParent->GetStart()) + fMemberOffset;
454 }
455 if (IsaPointer()) {
456 if (fWhere) return *(void**)fWhere;
457 else return nullptr;
458 } else {
459 return fWhere;
460 }
461 }
462
463 void *GetClaStart(UInt_t i=0) {
464 // return the address of the start of the object being proxied. Assumes
465 // that Setup() has been called. Assumes the object containing this data
466 // member is held in TClonesArray.
467
468 char *location;
469
470 if (fIsClone) {
471
474
475 if (!tca || tca->GetLast()<(Int_t)i) return nullptr;
476
477 location = (char*)tca->At(i);
478
479 return location;
480
481 } else if (fParent) {
482
483 //tcaloc = ((unsigned char*)fParent->GetStart());
484 location = (char*)fParent->GetClaStart(i);
485
486 } else {
487
488 void *tcaloc;
489 tcaloc = fWhere;
492
493 if (tca->GetLast()<(Int_t)i) return nullptr;
494
495 location = (char*)tca->At(i);
496 }
497
498 if (location) location += fOffset;
499 else return nullptr;
500
501 if (IsaPointer()) {
502 return *(void**)(location);
503 } else {
504 return location;
505 }
506
507 }
508
509 void *GetStlStart(UInt_t i=0) {
510 // return the address of the start of the object being proxied. Assumes
511 // that Setup() has been called. Assumes the object containing this data
512 // member is held in STL Collection.
513
514 char *location = nullptr;
515
516 if (fCollection) {
517
518 if (fCollection->Size()<i) return nullptr;
519
520 location = (char*)fCollection->At(i);
521
522 // return location;
523
524 } else if (fParent) {
525
526 //tcaloc = ((unsigned char*)fParent->GetStart());
527 location = (char*)fParent->GetStlStart(i);
528
529 } else {
530
531 R__ASSERT(0);
532 //void *tcaloc;
533 //tcaloc = fWhere;
534 //TClonesArray *tca;
535 //tca = (TClonesArray*)tcaloc;
536
537 //if (tca->GetLast()<i) return nullptr;
538
539 //location = (char*)tca->At(i);
540 }
541
542 if (location) location += fOffset;
543 else return nullptr;
544
545 if (IsaPointer()) {
546 return *(void**)(location);
547 } else {
548 return location;
549 }
550
551 }
552
553 Int_t GetOffset() { return fOffset; }
554
556
557 std::size_t GetValueSize() const { return fValueSize; }
558 };
559} // namespace Detail
560
561#if defined(_MSC_VER) && !defined(__clang__)
562#pragma optimize("", on)
563#endif
564
565namespace Internal {
566
567 ////////////////////////////////////////////////////////////////////////////////
568 /// Concrete Implementation of the branch proxy around the data members which are array of char
570 public:
571 void Print() override {
573 std::cout << "fWhere " << fWhere << std::endl;
574 if (fWhere) std::cout << "value? " << *(unsigned char*)GetStart() << std::endl;
575 }
576
578 TArrayCharProxy() = default; // work around bug in GCC < 7
579 ~TArrayCharProxy() override = default;
580
582 if (!Read()) return nullptr;
583 unsigned char* str = (unsigned char*)GetStart();
584 return str + i;
585 }
586
587 unsigned char At(UInt_t i) {
588 static unsigned char default_val = {};
589 if (unsigned char* elAddr = (unsigned char*)GetAddressOfElement(i)) {
590 // should add out-of bound test
591 return *elAddr;
592 }
593 return default_val;
594 }
595
596 unsigned char operator [](Int_t i) {
597 return At(i);
598 }
599
600 unsigned char operator [](UInt_t i) {
601 return At(i);
602 }
603
604 operator const char*() {
605 if (!Read()) return "";
606 return (const char*)GetStart();
607 }
608
609 const char* Data() {
610 if (!Read()) return "";
611 return (const char*)GetStart();
612 }
613
614 const char* c_str() {
615 if (!Read()) return "";
616 return (const char*)GetStart();
617 }
618
619 operator std::string() {
620 if (!Read()) return "";
621 return std::string((const char*)GetStart());
622 }
623
624 };
625
626 ////////////////////////////////////////////////////////////////////////////////
627 /// Base class for the proxy around object in TClonesArray.
629 public:
630 void Print() override {
632 std::cout << "fWhere " << fWhere << std::endl;
633 if (fWhere) {
634 if (IsaPointer()) {
635 std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
636 } else {
637 std::cout << "location " << fWhere << std::endl;
638 }
639 }
640 }
641
643 TClaProxy() = default; // work around bug in GCC < 7
644 ~TClaProxy() override = default;
645
647 if (!Read()) return nullptr;
648 return (TClonesArray*)GetStart();
649 }
650
651 Int_t GetEntries() override {
652 if (!ReadEntries()) return 0;
654 if (arr) return arr->GetEntries();
655 return 0;
656 }
657
659 if (!Read()) return nullptr;
660 if (!fWhere) return nullptr;
661 return GetClaStart(i);
662 }
663
664 const TClonesArray* operator->() { return GetPtr(); }
665
666 };
667
668 ////////////////////////////////////////////////////////////////////////////////
669 /// Base class for the proxy around STL containers.
671 public:
672 void Print() override {
674 std::cout << "fWhere " << fWhere << std::endl;
675 if (fWhere) {
676 if (IsaPointer()) {
677 std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
678 } else {
679 std::cout << "location " << fWhere << std::endl;
680 }
681 }
682 }
683
685 TStlProxy() = default; // work around bug in GCC < 7
686 ~TStlProxy() override = default;
687
689 if (!Read()) return nullptr;
690 return GetCollection();
691 }
692
693 Int_t GetEntries() override {
694 if (!ReadEntries()) return 0;
695 return GetPtr()->Size();
696 }
697
699 if (!Read()) return nullptr;
700 if (!fWhere) return nullptr;
701 return GetStlStart(i);
702 }
703
705
706 };
707
708 ////////////////////////////////////////////////////////////////////////////////
709 /// Template of the proxy around objects.
710 template <class T>
712 public:
713 void Print() override {
715 std::cout << "fWhere " << fWhere << std::endl;
716 if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
717 }
718
720 TImpProxy() = default; // work around bug in GCC < 7
721 ~TImpProxy() override = default;
722
723 operator T() {
724 if (!Read()) return 0;
725 return *(T*)GetStart();
726 }
727
728 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
729 TImpProxy(T) = delete;
730 TImpProxy &operator=(T) = delete;
731
732 };
733
734 ////////////////////////////////////////////////////////////////////////////////
735 /// Helper template to be able to determine and
736 /// use array dimensions.
737 template <class T, int d = 0> struct TArrayType {
738 typedef T type_t;
739 typedef T array_t[d];
740 static constexpr int gSize = d;
741 };
742 ////////////////////////////////////////////////////////////////////////////////
743 /// Helper class for proxy around multi dimension array
744 template <class T> struct TArrayType<T,0> {
745 typedef T type_t;
746 typedef T array_t;
747 static constexpr int gSize = 0;
748 };
749 ////////////////////////////////////////////////////////////////////////////////
750 /// Helper class for proxy around multi dimension array
751 template <class T, int d> struct TMultiArrayType {
752 typedef typename T::type_t type_t;
753 typedef typename T::array_t array_t[d];
754 static constexpr int gSize = d;
755 };
756
757 ////////////////////////////////////////////////////////////////////////////////
758 /// Template for concrete implementation of proxy around array of T
759 template <class T>
761 public:
763 TArrayProxy() = default; // work around bug in GCC < 7
764 ~TArrayProxy() override = default;
765
766 typedef typename T::array_t array_t;
767 typedef typename T::type_t type_t;
768
769 void Print() override {
771 std::cout << "fWhere " << GetWhere() << std::endl;
772 if (GetWhere()) std::cout << "value? " << *(type_t*)GetWhere() << std::endl;
773 }
774
775 Int_t GetEntries() override {
776 return T::gSize;
777 }
778
780 if (!Read()) return nullptr;
781 if (array_t *arr = (array_t*)((type_t*)(GetStart())))
782 return &arr[i];
783 return nullptr;
784 }
785
786 const array_t &At(UInt_t i) {
787 static array_t default_val;
788 // should add out-of bound test
790 return *arr;
791 return default_val;
792 }
793
794 const array_t &operator [](Int_t i) { return At(i); }
795 const array_t &operator [](UInt_t i) { return At(i); }
796 };
797
798 ////////////////////////////////////////////////////////////////////////////////
799 /// Template of the Concrete Implementation of the branch proxy around TClonesArray of T
800 template <class T>
801 class TClaImpProxy : public TClaProxy {
802 public:
803
804 // void Print() override {
805 // TClaProxy::Print();
806 // }
807
809 TClaImpProxy() = default; // work around bug in GCC < 7
810 ~TClaImpProxy() override = default;
811
812 const T& At(UInt_t i) {
813 static T default_val;
814 if (void* addr = GetAddressOfElement(i))
815 return *(T*)addr;
816 return default_val;
817 }
818
819 const T& operator [](Int_t i) { return At(i); }
820 const T& operator [](UInt_t i) { return At(i); }
821
822 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
823 TClaImpProxy(T) = delete;
825
826 };
827
828 ////////////////////////////////////////////////////////////////////////////////
829 /// Template of the Concrete Implementation of the branch proxy around an stl container of T
830 template <class T>
831 class TStlImpProxy : public TStlProxy {
832 public:
833
834 // void Print() override {
835 // TBranchProxy::Print();
836 // }
837
839 TStlImpProxy() = default; // work around bug in GCC < 7
840 ~TStlImpProxy() override = default;
841
842 const T& At(UInt_t i) {
843 static T default_val;
844 if (void* addr = GetAddressOfElement(i))
845 return *(T*)addr;
846 return default_val;
847 }
848
849 const T& operator [](Int_t i) { return At(i); }
850 const T& operator [](UInt_t i) { return At(i); }
851
852 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
853 TStlImpProxy(T) = delete;
855
856 };
857
858 ////////////////////////////////////////////////////////////////////////////////
859 /// Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
860 template <class T>
861 class TClaArrayProxy : public TClaProxy {
862 public:
863 typedef typename T::array_t array_t;
864 typedef typename T::type_t type_t;
865
866 // void Print() override {
867 // TClaProxy::Print();
868 // }
869
871 TClaArrayProxy() = default; // work around bug in GCC < 7
872 ~TClaArrayProxy() override = default;
873
874 /* const */ array_t *At(UInt_t i) {
875 static array_t default_val;
876 if (array_t* ptr = (array_t*)GetAddressOfElement(i))
877 return ptr; // no de-ref!
878
879 return &default_val;
880 }
881
882 /* const */ array_t *operator [](Int_t i) { return At(i); }
883 /* const */ array_t *operator [](UInt_t i) { return At(i); }
884 };
885
886
887 ////////////////////////////////////////////////////////////////////////////////
888 /// Template of the Concrete Implementation of the branch proxy around an stl container of array of T
889 template <class T>
890 class TStlArrayProxy : public TStlProxy {
891 public:
892 typedef typename T::array_t array_t;
893 typedef typename T::type_t type_t;
894
895 // void Print() override {
896 // TBranchProxy::Print();
897 // }
898
900 TStlArrayProxy() = default; // work around bug in GCC < 7
901 ~TStlArrayProxy() override = default;
902
903 /* const */ array_t *At(UInt_t i) {
904 static array_t default_val;
905 if (array_t* ptr = (array_t*)GetAddressOfElement(i))
906 return ptr; // no de-ref!
907 return &default_val;
908 }
909
910 /* const */ array_t *operator [](Int_t i) { return At(i); }
911 /* const */ array_t *operator [](UInt_t i) { return At(i); }
912 };
913
914 //TImpProxy<TObject> d;
915 typedef TImpProxy<Double_t> TDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are double
916 typedef TImpProxy<Double32_t> TDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are double32
917 typedef TImpProxy<Float_t> TFloatProxy; // Concrete Implementation of the branch proxy around the data members which are float
918 typedef TImpProxy<Float16_t> TFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are float16
919 typedef TImpProxy<UInt_t> TUIntProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned int
920 typedef TImpProxy<ULong_t> TULongProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long
921 typedef TImpProxy<ULong64_t> TULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long long
922 typedef TImpProxy<UShort_t> TUShortProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned short
923 typedef TImpProxy<UChar_t> TUCharProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned char
924 typedef TImpProxy<Int_t> TIntProxy; // Concrete Implementation of the branch proxy around the data members which are int
925 typedef TImpProxy<Long_t> TLongProxy; // Concrete Implementation of the branch proxy around the data members which are long
926 typedef TImpProxy<Long64_t> TLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are long long
927 typedef TImpProxy<Short_t> TShortProxy; // Concrete Implementation of the branch proxy around the data members which are short
928 typedef TImpProxy<Char_t> TCharProxy; // Concrete Implementation of the branch proxy around the data members which are char
929 typedef TImpProxy<bool> TBoolProxy; // Concrete Implementation of the branch proxy around the data members which are bool
930
931 typedef TArrayProxy<TArrayType<Double_t> > TArrayDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are array of double
932 typedef TArrayProxy<TArrayType<Double32_t> > TArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are array of double32
933 typedef TArrayProxy<TArrayType<Float_t> > TArrayFloatProxy; // Concrete Implementation of the branch proxy around the data members which are array of float
934 typedef TArrayProxy<TArrayType<Float16_t> > TArrayFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are array of float16
935 typedef TArrayProxy<TArrayType<UInt_t> > TArrayUIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned int
936 typedef TArrayProxy<TArrayType<ULong_t> > TArrayULongProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long
937 typedef TArrayProxy<TArrayType<ULong64_t> > TArrayULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long long
938 typedef TArrayProxy<TArrayType<UShort_t> > TArrayUShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned short
939 typedef TArrayProxy<TArrayType<UChar_t> > TArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned char
940 typedef TArrayProxy<TArrayType<Int_t> > TArrayIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of int
941 typedef TArrayProxy<TArrayType<Long_t> > TArrayLongProxy; // Concrete Implementation of the branch proxy around the data members which are array of long
942 typedef TArrayProxy<TArrayType<Long64_t> > TArrayLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of long long
943 typedef TArrayProxy<TArrayType<UShort_t> > TArrayShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of short
944 //specialized ! typedef TArrayProxy<TArrayType<Char_t> > TArrayCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of char
945 typedef TArrayProxy<TArrayType<bool> > TArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members which are array of bool
946
947 typedef TClaImpProxy<Double_t> TClaDoubleProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double
948 typedef TClaImpProxy<Double32_t> TClaDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double32
949 typedef TClaImpProxy<Float_t> TClaFloatProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float
950 typedef TClaImpProxy<Float16_t> TClaFloat16Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float16
951 typedef TClaImpProxy<UInt_t> TClaUIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned int
952 typedef TClaImpProxy<ULong_t> TClaULongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long
953 typedef TClaImpProxy<ULong64_t> TClaULong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long long
954 typedef TClaImpProxy<UShort_t> TClaUShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned short
955 typedef TClaImpProxy<UChar_t> TClaUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned char
956 typedef TClaImpProxy<Int_t> TClaIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are int
957 typedef TClaImpProxy<Long_t> TClaLongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long
958 typedef TClaImpProxy<Long64_t> TClaLong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long long
959 typedef TClaImpProxy<Short_t> TClaShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are short
960 typedef TClaImpProxy<Char_t> TClaCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are char
961 typedef TClaImpProxy<bool> TClaBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are bool
962
963 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
964 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
965 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
966 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
967 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
968 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
969 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
970 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
971 typedef TClaArrayProxy<TArrayType<UChar_t> > TClaArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of unsigned char
972 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
973 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
974 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
975 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
976 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
977 typedef TClaArrayProxy<TArrayType<bool> > TClaArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of bool
978 //specialized ! typedef TClaArrayProxy<TArrayType<Char_t> > TClaArrayCharProxy;
979
980 typedef TStlImpProxy<Double_t> TStlDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
981 typedef TStlImpProxy<Double32_t> TStlDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
982 typedef TStlImpProxy<Float_t> TStlFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
983 typedef TStlImpProxy<Float16_t> TStlFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
984 typedef TStlImpProxy<UInt_t> TStlUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
985 typedef TStlImpProxy<ULong_t> TStlULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
986 typedef TStlImpProxy<ULong64_t> TStlULong64Proxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long long
987 typedef TStlImpProxy<UShort_t> TStlUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
988 typedef TStlImpProxy<UChar_t> TStlUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
989 typedef TStlImpProxy<Int_t> TStlIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
990 typedef TStlImpProxy<Long_t> TStlLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
991 typedef TStlImpProxy<Long64_t> TStlLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
992 typedef TStlImpProxy<Short_t> TStlShortProxy; // Concrete Implementation of the branch proxy around an stl container of short
993 typedef TStlImpProxy<Char_t> TStlCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
994 typedef TStlImpProxy<bool> TStlBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
995
996 typedef TStlArrayProxy<TArrayType<Double_t> > TStlArrayDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
997 typedef TStlArrayProxy<TArrayType<Double32_t> > TStlArrayDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
998 typedef TStlArrayProxy<TArrayType<Float_t> > TStlArrayFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
999 typedef TStlArrayProxy<TArrayType<Float16_t> > TStlArrayFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
1000 typedef TStlArrayProxy<TArrayType<UInt_t> > TStlArrayUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
1001 typedef TStlArrayProxy<TArrayType<ULong_t> > TStlArrayULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
1002 typedef TStlArrayProxy<TArrayType<ULong64_t> > TStlArrayULong64Proxy; // Concrete Implementation of the branch proxy around an stl contained of unsigned long long
1003 typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
1004 typedef TStlArrayProxy<TArrayType<UChar_t> > TStlArrayUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
1005 typedef TStlArrayProxy<TArrayType<Int_t> > TStlArrayIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
1006 typedef TStlArrayProxy<TArrayType<Long_t> > TStlArrayLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
1007 typedef TStlArrayProxy<TArrayType<Long64_t> > TStlArrayLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
1008 typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayShortProxy; // Concrete Implementation of the branch proxy around an stl container of UShort_t
1009 typedef TStlArrayProxy<TArrayType<Char_t> > TStlArrayCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
1010 typedef TStlArrayProxy<TArrayType<bool> > TStlArrayBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
1011
1012} // namespace Internal
1013
1014// Reasonably backward compatible.
1016
1017} // namespace ROOT
1018
1019#endif
1020
#define R__unlikely(expr)
Definition RConfig.hxx:594
#define d(i)
Definition RSha256.hxx:102
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:125
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:208
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
char name[80]
Definition TGX11.cxx:110
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2496
Base class for all the proxy object.
TNotifyLink< TBranchProxy > fNotify
Internal::TBranchProxyDirector * fDirector
TVirtualCollectionProxy * fCollection
void * GetClaStart(UInt_t i=0)
void * GetStlStart(UInt_t i=0)
TBranchElement * fBranchCount
const char * GetBranchName() const
virtual void * GetStart(UInt_t=0)
virtual Int_t GetArrayLength()
std::size_t GetValueSize() const
bool Setup()
Initialize/cache the necessary information.
void Reset()
Completely reset the object.
virtual void * GetAddressOfElement(UInt_t)
Return the address of the element number i.
TBranchProxy * GetProxy()
bool GetSuppressErrorsForMissingBranch() const
virtual void Print()
Display the content of the object.
bool ReadNoParentBranchCountCollectionPointer()
TVirtualCollectionProxy * GetCollection()
TStreamerElement * fElement
bool ReadNoParentNoBranchCountCollectionNoPointer()
bool ReadNoParentNoBranchCountCollectionPointer()
virtual ~TBranchProxy()
Typical Destructor.
bool ReadNoParentBranchCountCollectionNoPointer()
Concrete Implementation of the branch proxy around the data members which are array of char.
~TArrayCharProxy() override=default
void Print() override
Display the content of the object.
unsigned char At(UInt_t i)
unsigned char operator[](Int_t i)
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
Template for concrete implementation of proxy around array of T.
void Print() override
Display the content of the object.
~TArrayProxy() override=default
const array_t & At(UInt_t i)
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
const array_t & operator[](Int_t i)
Int_t GetEntries() override
Long64_t GetReadEntry() const
Return the current 'local' entry number; i.e.
String builder to be used in the constructors.
TBranchProxyHelper(const char *left, const char *right=nullptr)
Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T.
array_t * operator[](Int_t i)
~TClaArrayProxy() override=default
Template of the Concrete Implementation of the branch proxy around TClonesArray of T.
~TClaImpProxy() override=default
TClaImpProxy & operator=(T)=delete
const T & operator[](Int_t i)
Base class for the proxy around object in TClonesArray.
Int_t GetEntries() override
const TClonesArray * operator->()
const TClonesArray * GetPtr()
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
~TClaProxy() override=default
void Print() override
Display the content of the object.
Template of the proxy around objects.
void Print() override
Display the content of the object.
~TImpProxy() override=default
TImpProxy & operator=(T)=delete
Template of the Concrete Implementation of the branch proxy around an stl container of array of T.
~TStlArrayProxy() override=default
array_t * operator[](Int_t i)
Template of the Concrete Implementation of the branch proxy around an stl container of T.
TStlImpProxy & operator=(T)=delete
const T & operator[](Int_t i)
~TStlImpProxy() override=default
Base class for the proxy around STL containers.
~TStlProxy() override=default
void * GetAddressOfElement(UInt_t i) final
Return the address of the element number i.
const TVirtualCollectionProxy * operator->()
Int_t GetEntries() override
void Print() override
Display the content of the object.
TVirtualCollectionProxy * GetPtr()
Base class of TTreeReaderValue.
A Branch for the case of an object.
Int_t GetEntry(Long64_t entry=0, Int_t getall=0) override
Read all branches of a BranchElement and return total number of bytes.
Int_t GetNdata() const
A TTree is a list of TBranches.
Definition TBranch.h:93
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:1706
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
An array of clone (identical) objects.
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
virtual void * GetValuePointer() const
Definition TLeaf.h:138
TBranch * GetBranch() const
Definition TLeaf.h:116
Describe one element (data member) to be Streamed.
Basic string class.
Definition TString.h:138
Ssiz_t Length() const
Definition TString.h:425
const char * Data() const
Definition TString.h:384
Defines a common interface to inspect/change the contents of an object that represents a collection.
virtual void PushProxy(void *objectstart)=0
Set the address of the container being proxied and keep track of the previous one.
virtual void PopProxy()=0
Reset the address of the container being proxied to the previous container.
virtual void * At(UInt_t idx)=0
Return the address of the value at index idx
virtual UInt_t Size() const =0
Return the current number of elements in the container.
TImpProxy< Long_t > TLongProxy
TClaArrayProxy< TArrayType< ULong64_t > > TClaArrayULong64Proxy
TClaArrayProxy< TArrayType< Long64_t > > TClaArrayLong64Proxy
TClaArrayProxy< TArrayType< UChar_t > > TClaArrayUCharProxy
TStlImpProxy< UInt_t > TStlUIntProxy
TStlArrayProxy< TArrayType< Long64_t > > TStlArrayLong64Proxy
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayShortProxy
TClaArrayProxy< TArrayType< Double32_t > > TClaArrayDouble32Proxy
TArrayProxy< TArrayType< Int_t > > TArrayIntProxy
TArrayProxy< TArrayType< UShort_t > > TArrayUShortProxy
TStlArrayProxy< TArrayType< ULong_t > > TStlArrayULongProxy
TStlImpProxy< ULong64_t > TStlULong64Proxy
TClaArrayProxy< TArrayType< Char_t > > TClaArrayCharProxy
TStlImpProxy< Double_t > TStlDoubleProxy
TStlArrayProxy< TArrayType< Int_t > > TStlArrayIntProxy
TStlArrayProxy< TArrayType< Float_t > > TStlArrayFloatProxy
TStlArrayProxy< TArrayType< Char_t > > TStlArrayCharProxy
TImpProxy< UShort_t > TUShortProxy
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayShortProxy
TStlImpProxy< UChar_t > TStlUCharProxy
TClaImpProxy< Long_t > TClaLongProxy
TImpProxy< Double_t > TDoubleProxy
TImpProxy< ULong_t > TULongProxy
TStlArrayProxy< TArrayType< UChar_t > > TStlArrayUCharProxy
TArrayProxy< TArrayType< UChar_t > > TArrayUCharProxy
TClaImpProxy< Char_t > TClaCharProxy
TStlImpProxy< Char_t > TStlCharProxy
TClaImpProxy< Int_t > TClaIntProxy
TImpProxy< Long64_t > TLong64Proxy
TStlImpProxy< Float16_t > TStlFloat16Proxy
TClaArrayProxy< TArrayType< Long_t > > TClaArrayLongProxy
TStlImpProxy< Float_t > TStlFloatProxy
TStlArrayProxy< TArrayType< Float16_t > > TStlArrayFloat16Proxy
TStlImpProxy< Long_t > TStlLongProxy
TArrayProxy< TArrayType< UInt_t > > TArrayUIntProxy
TImpProxy< UChar_t > TUCharProxy
TClaArrayProxy< TArrayType< Float_t > > TClaArrayFloatProxy
TImpProxy< Char_t > TCharProxy
TArrayProxy< TArrayType< UShort_t > > TArrayShortProxy
TClaArrayProxy< TArrayType< Int_t > > TClaArrayIntProxy
TImpProxy< ULong64_t > TULong64Proxy
TArrayProxy< TArrayType< Double_t > > TArrayDoubleProxy
TClaImpProxy< Long64_t > TClaLong64Proxy
TArrayProxy< TArrayType< ULong64_t > > TArrayULong64Proxy
TImpProxy< Int_t > TIntProxy
TClaArrayProxy< TArrayType< UInt_t > > TClaArrayUIntProxy
TClaImpProxy< Short_t > TClaShortProxy
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayUShortProxy
TArrayProxy< TArrayType< bool > > TArrayBoolProxy
TArrayProxy< TArrayType< Float_t > > TArrayFloatProxy
TImpProxy< Float16_t > TFloat16Proxy
TStlArrayProxy< TArrayType< UInt_t > > TStlArrayUIntProxy
TClaImpProxy< Double32_t > TClaDouble32Proxy
TStlArrayProxy< TArrayType< Double32_t > > TStlArrayDouble32Proxy
TClaImpProxy< UInt_t > TClaUIntProxy
TArrayProxy< TArrayType< ULong_t > > TArrayULongProxy
TStlImpProxy< Int_t > TStlIntProxy
TClaImpProxy< Double_t > TClaDoubleProxy
TStlArrayProxy< TArrayType< bool > > TStlArrayBoolProxy
TClaImpProxy< ULong_t > TClaULongProxy
TArrayProxy< TArrayType< Long64_t > > TArrayLong64Proxy
TClaImpProxy< ULong64_t > TClaULong64Proxy
TImpProxy< Double32_t > TDouble32Proxy
TClaArrayProxy< TArrayType< ULong_t > > TClaArrayULongProxy
TImpProxy< bool > TBoolProxy
TImpProxy< UInt_t > TUIntProxy
TClaImpProxy< UChar_t > TClaUCharProxy
TClaImpProxy< Float_t > TClaFloatProxy
TStlImpProxy< bool > TStlBoolProxy
TImpProxy< Float_t > TFloatProxy
TClaImpProxy< UShort_t > TClaUShortProxy
TArrayProxy< TArrayType< Float16_t > > TArrayFloat16Proxy
TImpProxy< Short_t > TShortProxy
TClaImpProxy< bool > TClaBoolProxy
TArrayProxy< TArrayType< Long_t > > TArrayLongProxy
TStlImpProxy< Double32_t > TStlDouble32Proxy
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayUShortProxy
TClaArrayProxy< TArrayType< Double_t > > TClaArrayDoubleProxy
TStlArrayProxy< TArrayType< ULong64_t > > TStlArrayULong64Proxy
TStlArrayProxy< TArrayType< Long_t > > TStlArrayLongProxy
TStlImpProxy< UShort_t > TStlUShortProxy
TClaImpProxy< Float16_t > TClaFloat16Proxy
TStlImpProxy< Long64_t > TStlLong64Proxy
TStlImpProxy< Short_t > TStlShortProxy
TClaArrayProxy< TArrayType< Float16_t > > TClaArrayFloat16Proxy
TClaArrayProxy< TArrayType< bool > > TClaArrayBoolProxy
TStlImpProxy< ULong_t > TStlULongProxy
TStlArrayProxy< TArrayType< Double_t > > TStlArrayDoubleProxy
TArrayProxy< TArrayType< Double32_t > > TArrayDouble32Proxy
Namespace for new ROOT classes and functions.
Helper template to be able to determine and use array dimensions.
static constexpr int gSize
Helper class for proxy around multi dimension array.