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
84 const TString fBranchName; // name of the branch to read
85 TBranchProxy *fParent; // Proxy to a parent object
86
87 const TString fDataMember; // name of the (eventual) data member being proxied
88
89
90 TString fClassName; // class name of the object pointed to by the branch
91 TClass *fClass; // class name of the object pointed to by the branch
94 Int_t fOffset; // Offset inside the object
95 Int_t fArrayLength; // Number of element if the data is an array
96
97 TBranch *fBranch; // branch to read
98 union {
99 TBranchElement *fBranchCount; // eventual auxiliary branch (for example holding the size)
100 TLeaf *fLeafCount; // eventual auxiliary leaf (for example holding the size)
101 };
102
103 TNotifyLink<TBranchProxy> fNotify; // Callback object used by the TChain to update this proxy
104
105 Long64_t fRead; // Last entry read
106
107 void *fWhere; // memory location of the data
108 TVirtualCollectionProxy *fCollection; // Handle to the collection containing the data chunk.
109
110 public:
111 virtual void Print();
112
113 TBranchProxy();
114 TBranchProxy(Internal::TBranchProxyDirector* boss, const char* top, const char* name = nullptr);
115 TBranchProxy(Internal::TBranchProxyDirector* boss, const char *top, const char *name, const char *membername);
116 TBranchProxy(Internal::TBranchProxyDirector* boss, TBranchProxy *parent, const char* membername, const char* top = nullptr, const char* name = nullptr);
117 TBranchProxy(Internal::TBranchProxyDirector* boss, TBranch* branch, const char* membername);
118 TBranchProxy(Internal::TBranchProxyDirector* boss, const char* branchname, TBranch* branch, const char* membername);
119 virtual ~TBranchProxy();
120
121 TBranchProxy* GetProxy() { return this; }
122 const char* GetBranchName() const { return fBranchName; }
123
124 void Reset();
125
126 bool Notify() {
127 fRead = -1;
128 return Setup();
129 }
130
131 bool Setup();
132
134 return fInitialized;
135 // return fLastTree && fCurrentTreeNumber == fDirector->GetTree()->GetTreeNumber() && fLastTree == fDirector->GetTree();
136 }
137
138 bool IsaPointer() const {
139 return fIsaPointer;
140 }
141
142 bool Read() {
143 if (R__unlikely(fDirector == nullptr)) return false;
144
145 auto treeEntry = fDirector->GetReadEntry();
146 if (treeEntry != fRead) {
147 if (!IsInitialized()) {
148 if (!Setup()) {
149 ::Error("TBranchProxy::Read","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
150 return false;
151 }
152 }
153 bool result = true;
154 if (fParent) {
155 result = fParent->Read();
156 } else {
157 if (fHasLeafCount) {
158 if (fBranch != fLeafCount->GetBranch())
159 result &= (-1 != fLeafCount->GetBranch()->GetEntry(treeEntry));
160 } else if (fBranchCount) {
161 result &= (-1 != fBranchCount->GetEntry(treeEntry));
162 }
163 result &= (-1 != fBranch->GetEntry(treeEntry));
164 }
165 fRead = treeEntry;
167 fCollection->PopProxy(); // works even if no proxy env object was set.
168 if (IsaPointer()) {
169 fCollection->PushProxy( *(void**)fWhere );
170 } else {
172 }
173 }
174 return result;
175 } else {
176 return IsInitialized();
177 }
178 }
179
180private:
182
183 enum class EReadType {
184 kDefault,
195 };
196
198 {
199 if (fParent) {
200 if (!fCollection) {
202 }
203 if (IsaPointer()) {
205 }
207 }
208 if (fHasLeafCount) {
209 return EReadType::kDefault;
210 }
211 if (fBranchCount) {
212 if (fCollection) {
213 if (IsaPointer()) {
215 }
217 }
219 }
220 if (fCollection) {
221 if (IsaPointer()) {
223 }
225 }
227 }
228
230 return false;
231 }
232
234 auto treeEntry = fDirector->GetReadEntry();
235 if (treeEntry != fRead) {
236 const bool result = fParent->Read();
237 fRead = treeEntry;
238 return result;
239 } else {
240 return IsInitialized();
241 }
242 }
243
245 auto treeEntry = fDirector->GetReadEntry();
246 if (treeEntry != fRead) {
247 const bool result = fParent->Read();
248 fRead = treeEntry;
249 fCollection->PopProxy(); // works even if no proxy env object was set.
251 return result;
252 } else {
253 return IsInitialized();
254 }
255 }
256
258 auto treeEntry = fDirector->GetReadEntry();
259 if (treeEntry != fRead) {
260 const bool result = fParent->Read();
261 fRead = treeEntry;
262 fCollection->PopProxy(); // works even if no proxy env object was set.
263 fCollection->PushProxy( *(void**)fWhere );
264 return result;
265 } else {
266 return IsInitialized();
267 }
268 }
269
271 auto treeEntry = fDirector->GetReadEntry();
272 if (treeEntry != fRead) {
273 bool result = (-1 != fBranch->GetEntry(treeEntry));
274 fRead = treeEntry;
275 fCollection->PopProxy(); // works even if no proxy env object was set.
276 fCollection->PushProxy( *(void**)fWhere );
277 return result;
278 } else {
279 return IsInitialized();
280 }
281 }
282
284 auto treeEntry = fDirector->GetReadEntry();
285 if (treeEntry != fRead) {
286 bool result = (-1 != fBranch->GetEntry(treeEntry));
287 fRead = treeEntry;
288 fCollection->PopProxy(); // works even if no proxy env object was set.
290 return result;
291 } else {
292 return IsInitialized();
293 }
294 }
295
297 auto treeEntry = fDirector->GetReadEntry();
298 if (treeEntry != fRead) {
299 bool result = (-1 != fBranch->GetEntry(treeEntry));
300 fRead = treeEntry;
301 return result;
302 } else {
303 return IsInitialized();
304 }
305 }
306
308 auto treeEntry = fDirector->GetReadEntry();
309 if (treeEntry != fRead) {
310 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
311 result &= (-1 != fBranch->GetEntry(treeEntry));
312 fRead = treeEntry;
313 fCollection->PopProxy(); // works even if no proxy env object was set.
314 fCollection->PushProxy( *(void**)fWhere );
315 return result;
316 } else {
317 return IsInitialized();
318 }
319 }
320
322 auto treeEntry = fDirector->GetReadEntry();
323 if (treeEntry != fRead) {
324 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
325 result &= (-1 != fBranch->GetEntry(treeEntry));
326 fRead = treeEntry;
327 fCollection->PopProxy(); // works even if no proxy env object was set.
329 return result;
330 } else {
331 return IsInitialized();
332 }
333 }
334
336 auto treeEntry = fDirector->GetReadEntry();
337 if (treeEntry != fRead) {
338 bool result = (-1 != fBranchCount->GetEntry(treeEntry));
339 result &= (-1 != fBranch->GetEntry(treeEntry));
340 fRead = treeEntry;
341 return result;
342 } else {
343 return IsInitialized();
344 }
345 }
346
347public:
348
349 bool ReadEntries() {
350 if (R__unlikely(fDirector == nullptr)) return false;
351
352 auto treeEntry = fDirector->GetReadEntry();
353 if (treeEntry != fRead) {
354 if (!IsInitialized()) {
355 if (!Setup()) {
356 ::Error("TBranchProxy::ReadEntries","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
357 return false;
358 }
359 }
361 else {
362 if (fBranchCount) {
363 fBranchCount->TBranch::GetEntry(treeEntry);
364 }
365 fBranch->TBranch::GetEntry(treeEntry);
366 }
367 // NO - we only read the entries, not the contained objects!
368 // fRead = treeEntry;
369 }
370 return IsInitialized();
371 }
372
373 virtual Int_t GetEntries() {
374 if (!ReadEntries()) return 0;
375 if (fHasLeafCount) {
376 return *(Int_t*)fLeafCount->GetValuePointer();
377 } else if (fBranchCount) {
378 return fBranchCount->GetNdata();
379 } else {
380 return 1;
381 }
382 }
383
385 return fArrayLength;
386 }
387
389 if (!fDirector) return nullptr;
390
391 if (fDirector->GetReadEntry() != fRead) {
392 if (!IsInitialized()) {
393 if (!Setup()) {
394 return nullptr;
395 }
396 }
397 }
398 return fClass;
399 }
400
401 void* GetWhere() const { return fWhere; } // intentionally non-virtual
402
403 /// Return the address of the element number i. Returns `nullptr` for non-collections. It assumed that Setip() has
404 /// been called.
405 virtual void *GetAddressOfElement(UInt_t /*i*/) {
406 return nullptr;
407 }
408
410
411 // protected:
412 virtual void *GetStart(UInt_t /*i*/=0) {
413 // return the address of the start of the object being proxied. Assumes
414 // that Setup() has been called.
415
416 if (fParent) {
417 fWhere = ((unsigned char*)fParent->GetStart()) + fMemberOffset;
418 }
419 if (IsaPointer()) {
420 if (fWhere) return *(void**)fWhere;
421 else return nullptr;
422 } else {
423 return fWhere;
424 }
425 }
426
427 void *GetClaStart(UInt_t i=0) {
428 // return the address of the start of the object being proxied. Assumes
429 // that Setup() has been called. Assumes the object containing this data
430 // member is held in TClonesArray.
431
432 char *location;
433
434 if (fIsClone) {
435
436 TClonesArray *tca;
437 tca = (TClonesArray*)GetStart();
438
439 if (!tca || tca->GetLast()<(Int_t)i) return nullptr;
440
441 location = (char*)tca->At(i);
442
443 return location;
444
445 } else if (fParent) {
446
447 //tcaloc = ((unsigned char*)fParent->GetStart());
448 location = (char*)fParent->GetClaStart(i);
449
450 } else {
451
452 void *tcaloc;
453 tcaloc = fWhere;
454 TClonesArray *tca;
455 tca = (TClonesArray*)tcaloc;
456
457 if (tca->GetLast()<(Int_t)i) return nullptr;
458
459 location = (char*)tca->At(i);
460 }
461
462 if (location) location += fOffset;
463 else return nullptr;
464
465 if (IsaPointer()) {
466 return *(void**)(location);
467 } else {
468 return location;
469 }
470
471 }
472
473 void *GetStlStart(UInt_t i=0) {
474 // return the address of the start of the object being proxied. Assumes
475 // that Setup() has been called. Assumes the object containing this data
476 // member is held in STL Collection.
477
478 char *location = nullptr;
479
480 if (fCollection) {
481
482 if (fCollection->Size()<i) return nullptr;
483
484 location = (char*)fCollection->At(i);
485
486 // return location;
487
488 } else if (fParent) {
489
490 //tcaloc = ((unsigned char*)fParent->GetStart());
491 location = (char*)fParent->GetStlStart(i);
492
493 } else {
494
495 R__ASSERT(0);
496 //void *tcaloc;
497 //tcaloc = fWhere;
498 //TClonesArray *tca;
499 //tca = (TClonesArray*)tcaloc;
500
501 //if (tca->GetLast()<i) return nullptr;
502
503 //location = (char*)tca->At(i);
504 }
505
506 if (location) location += fOffset;
507 else return nullptr;
508
509 if (IsaPointer()) {
510 return *(void**)(location);
511 } else {
512 return location;
513 }
514
515 }
516
517 Int_t GetOffset() { return fOffset; }
518 };
519} // namespace Detail
520
521#if defined(_MSC_VER) && !defined(__clang__)
522#pragma optimize("", on)
523#endif
524
525namespace Internal {
526
527 ////////////////////////////////////////////////////////////////////////////////
528 /// Concrete Implementation of the branch proxy around the data members which are array of char
530 public:
531 void Print() override {
533 std::cout << "fWhere " << fWhere << std::endl;
534 if (fWhere) std::cout << "value? " << *(unsigned char*)GetStart() << std::endl;
535 }
536
538 TArrayCharProxy() = default; // work around bug in GCC < 7
539 ~TArrayCharProxy() override = default;
540
542 if (!Read()) return nullptr;
543 unsigned char* str = (unsigned char*)GetStart();
544 return str + i;
545 }
546
547 unsigned char At(UInt_t i) {
548 static unsigned char default_val = {};
549 if (unsigned char* elAddr = (unsigned char*)GetAddressOfElement(i)) {
550 // should add out-of bound test
551 return *elAddr;
552 }
553 return default_val;
554 }
555
556 unsigned char operator [](Int_t i) {
557 return At(i);
558 }
559
560 unsigned char operator [](UInt_t i) {
561 return At(i);
562 }
563
564 operator const char*() {
565 if (!Read()) return "";
566 return (const char*)GetStart();
567 }
568
569 const char* Data() {
570 if (!Read()) return "";
571 return (const char*)GetStart();
572 }
573
574 const char* c_str() {
575 if (!Read()) return "";
576 return (const char*)GetStart();
577 }
578
579 operator std::string() {
580 if (!Read()) return "";
581 return std::string((const char*)GetStart());
582 }
583
584 };
585
586 ////////////////////////////////////////////////////////////////////////////////
587 /// Base class for the proxy around object in TClonesArray.
589 public:
590 void Print() override {
592 std::cout << "fWhere " << fWhere << std::endl;
593 if (fWhere) {
594 if (IsaPointer()) {
595 std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
596 } else {
597 std::cout << "location " << fWhere << std::endl;
598 }
599 }
600 }
601
603 TClaProxy() = default; // work around bug in GCC < 7
604 ~TClaProxy() override = default;
605
607 if (!Read()) return nullptr;
608 return (TClonesArray*)GetStart();
609 }
610
611 Int_t GetEntries() override {
612 if (!ReadEntries()) return 0;
614 if (arr) return arr->GetEntries();
615 return 0;
616 }
617
619 if (!Read()) return nullptr;
620 if (!fWhere) return nullptr;
621 return GetClaStart(i);
622 }
623
624 const TClonesArray* operator->() { return GetPtr(); }
625
626 };
627
628 ////////////////////////////////////////////////////////////////////////////////
629 /// Base class for the proxy around STL containers.
631 public:
632 void Print() override {
634 std::cout << "fWhere " << fWhere << std::endl;
635 if (fWhere) {
636 if (IsaPointer()) {
637 std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
638 } else {
639 std::cout << "location " << fWhere << std::endl;
640 }
641 }
642 }
643
645 TStlProxy() = default; // work around bug in GCC < 7
646 ~TStlProxy() override = default;
647
649 if (!Read()) return nullptr;
650 return GetCollection();
651 }
652
653 Int_t GetEntries() override {
654 if (!ReadEntries()) return 0;
655 return GetPtr()->Size();
656 }
657
659 if (!Read()) return nullptr;
660 if (!fWhere) return nullptr;
661 return GetStlStart(i);
662 }
663
665
666 };
667
668 ////////////////////////////////////////////////////////////////////////////////
669 /// Template of the proxy around objects.
670 template <class T>
672 public:
673 void Print() override {
675 std::cout << "fWhere " << fWhere << std::endl;
676 if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
677 }
678
680 TImpProxy() = default; // work around bug in GCC < 7
681 ~TImpProxy() override = default;
682
683 operator T() {
684 if (!Read()) return 0;
685 return *(T*)GetStart();
686 }
687
688 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
689 TImpProxy(T) = delete;
690 TImpProxy &operator=(T) = delete;
691
692 };
693
694 ////////////////////////////////////////////////////////////////////////////////
695 /// Helper template to be able to determine and
696 /// use array dimensions.
697 template <class T, int d = 0> struct TArrayType {
698 typedef T type_t;
699 typedef T array_t[d];
700 static constexpr int gSize = d;
701 };
702 ////////////////////////////////////////////////////////////////////////////////
703 /// Helper class for proxy around multi dimension array
704 template <class T> struct TArrayType<T,0> {
705 typedef T type_t;
706 typedef T array_t;
707 static constexpr int gSize = 0;
708 };
709 ////////////////////////////////////////////////////////////////////////////////
710 /// Helper class for proxy around multi dimension array
711 template <class T, int d> struct TMultiArrayType {
712 typedef typename T::type_t type_t;
713 typedef typename T::array_t array_t[d];
714 static constexpr int gSize = d;
715 };
716
717 ////////////////////////////////////////////////////////////////////////////////
718 /// Template for concrete implementation of proxy around array of T
719 template <class T>
721 public:
723 TArrayProxy() = default; // work around bug in GCC < 7
724 ~TArrayProxy() override = default;
725
726 typedef typename T::array_t array_t;
727 typedef typename T::type_t type_t;
728
729 void Print() override {
731 std::cout << "fWhere " << GetWhere() << std::endl;
732 if (GetWhere()) std::cout << "value? " << *(type_t*)GetWhere() << std::endl;
733 }
734
735 Int_t GetEntries() override {
736 return T::gSize;
737 }
738
740 if (!Read()) return nullptr;
741 if (array_t *arr = (array_t*)((type_t*)(GetStart())))
742 return &arr[i];
743 return nullptr;
744 }
745
746 const array_t &At(UInt_t i) {
747 static array_t default_val;
748 // should add out-of bound test
749 if (array_t *arr = (array_t*)GetAddressOfElement(i))
750 return *arr;
751 return default_val;
752 }
753
754 const array_t &operator [](Int_t i) { return At(i); }
755 const array_t &operator [](UInt_t i) { return At(i); }
756 };
757
758 ////////////////////////////////////////////////////////////////////////////////
759 /// Template of the Concrete Implementation of the branch proxy around TClonesArray of T
760 template <class T>
761 class TClaImpProxy : public TClaProxy {
762 public:
763
764 // void Print() override {
765 // TClaProxy::Print();
766 // }
767
769 TClaImpProxy() = default; // work around bug in GCC < 7
770 ~TClaImpProxy() override = default;
771
772 const T& At(UInt_t i) {
773 static T default_val;
774 if (void* addr = GetAddressOfElement(i))
775 return *(T*)addr;
776 return default_val;
777 }
778
779 const T& operator [](Int_t i) { return At(i); }
780 const T& operator [](UInt_t i) { return At(i); }
781
782 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
783 TClaImpProxy(T) = delete;
785
786 };
787
788 ////////////////////////////////////////////////////////////////////////////////
789 /// Template of the Concrete Implementation of the branch proxy around an stl container of T
790 template <class T>
791 class TStlImpProxy : public TStlProxy {
792 public:
793
794 // void Print() override {
795 // TBranchProxy::Print();
796 // }
797
799 TStlImpProxy() = default; // work around bug in GCC < 7
800 ~TStlImpProxy() override = default;
801
802 const T& At(UInt_t i) {
803 static T default_val;
804 if (void* addr = GetAddressOfElement(i))
805 return *(T*)addr;
806 return default_val;
807 }
808
809 const T& operator [](Int_t i) { return At(i); }
810 const T& operator [](UInt_t i) { return At(i); }
811
812 // For now explicitly disable copying into the value (i.e. the proxy is read-only).
813 TStlImpProxy(T) = delete;
815
816 };
817
818 ////////////////////////////////////////////////////////////////////////////////
819 /// Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
820 template <class T>
821 class TClaArrayProxy : public TClaProxy {
822 public:
823 typedef typename T::array_t array_t;
824 typedef typename T::type_t type_t;
825
826 // void Print() override {
827 // TClaProxy::Print();
828 // }
829
831 TClaArrayProxy() = default; // work around bug in GCC < 7
832 ~TClaArrayProxy() override = default;
833
834 /* const */ array_t *At(UInt_t i) {
835 static array_t default_val;
836 if (array_t* ptr = (array_t*)GetAddressOfElement(i))
837 return ptr; // no de-ref!
838
839 return &default_val;
840 }
841
842 /* const */ array_t *operator [](Int_t i) { return At(i); }
843 /* const */ array_t *operator [](UInt_t i) { return At(i); }
844 };
845
846
847 ////////////////////////////////////////////////////////////////////////////////
848 /// Template of the Concrete Implementation of the branch proxy around an stl container of array of T
849 template <class T>
850 class TStlArrayProxy : public TStlProxy {
851 public:
852 typedef typename T::array_t array_t;
853 typedef typename T::type_t type_t;
854
855 // void Print() override {
856 // TBranchProxy::Print();
857 // }
858
860 TStlArrayProxy() = default; // work around bug in GCC < 7
861 ~TStlArrayProxy() override = default;
862
863 /* const */ array_t *At(UInt_t i) {
864 static array_t default_val;
865 if (array_t* ptr = (array_t*)GetAddressOfElement(i))
866 return ptr; // no de-ref!
867 return &default_val;
868 }
869
870 /* const */ array_t *operator [](Int_t i) { return At(i); }
871 /* const */ array_t *operator [](UInt_t i) { return At(i); }
872 };
873
874 //TImpProxy<TObject> d;
875 typedef TImpProxy<Double_t> TDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are double
876 typedef TImpProxy<Double32_t> TDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are double32
877 typedef TImpProxy<Float_t> TFloatProxy; // Concrete Implementation of the branch proxy around the data members which are float
878 typedef TImpProxy<Float16_t> TFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are float16
879 typedef TImpProxy<UInt_t> TUIntProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned int
880 typedef TImpProxy<ULong_t> TULongProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long
881 typedef TImpProxy<ULong64_t> TULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long long
882 typedef TImpProxy<UShort_t> TUShortProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned short
883 typedef TImpProxy<UChar_t> TUCharProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned char
884 typedef TImpProxy<Int_t> TIntProxy; // Concrete Implementation of the branch proxy around the data members which are int
885 typedef TImpProxy<Long_t> TLongProxy; // Concrete Implementation of the branch proxy around the data members which are long
886 typedef TImpProxy<Long64_t> TLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are long long
887 typedef TImpProxy<Short_t> TShortProxy; // Concrete Implementation of the branch proxy around the data members which are short
888 typedef TImpProxy<Char_t> TCharProxy; // Concrete Implementation of the branch proxy around the data members which are char
889 typedef TImpProxy<bool> TBoolProxy; // Concrete Implementation of the branch proxy around the data members which are bool
890
891 typedef TArrayProxy<TArrayType<Double_t> > TArrayDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are array of double
892 typedef TArrayProxy<TArrayType<Double32_t> > TArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are array of double32
893 typedef TArrayProxy<TArrayType<Float_t> > TArrayFloatProxy; // Concrete Implementation of the branch proxy around the data members which are array of float
894 typedef TArrayProxy<TArrayType<Float16_t> > TArrayFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are array of float16
895 typedef TArrayProxy<TArrayType<UInt_t> > TArrayUIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned int
896 typedef TArrayProxy<TArrayType<ULong_t> > TArrayULongProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long
897 typedef TArrayProxy<TArrayType<ULong64_t> > TArrayULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long long
898 typedef TArrayProxy<TArrayType<UShort_t> > TArrayUShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned short
899 typedef TArrayProxy<TArrayType<UChar_t> > TArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned char
900 typedef TArrayProxy<TArrayType<Int_t> > TArrayIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of int
901 typedef TArrayProxy<TArrayType<Long_t> > TArrayLongProxy; // Concrete Implementation of the branch proxy around the data members which are array of long
902 typedef TArrayProxy<TArrayType<Long64_t> > TArrayLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of long long
903 typedef TArrayProxy<TArrayType<UShort_t> > TArrayShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of short
904 //specialized ! typedef TArrayProxy<TArrayType<Char_t> > TArrayCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of char
905 typedef TArrayProxy<TArrayType<bool> > TArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members which are array of bool
906
907 typedef TClaImpProxy<Double_t> TClaDoubleProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double
908 typedef TClaImpProxy<Double32_t> TClaDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double32
909 typedef TClaImpProxy<Float_t> TClaFloatProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float
910 typedef TClaImpProxy<Float16_t> TClaFloat16Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float16
911 typedef TClaImpProxy<UInt_t> TClaUIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned int
912 typedef TClaImpProxy<ULong_t> TClaULongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long
913 typedef TClaImpProxy<ULong64_t> TClaULong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long long
914 typedef TClaImpProxy<UShort_t> TClaUShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned short
915 typedef TClaImpProxy<UChar_t> TClaUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned char
916 typedef TClaImpProxy<Int_t> TClaIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are int
917 typedef TClaImpProxy<Long_t> TClaLongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long
918 typedef TClaImpProxy<Long64_t> TClaLong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long long
919 typedef TClaImpProxy<Short_t> TClaShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are short
920 typedef TClaImpProxy<Char_t> TClaCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are char
921 typedef TClaImpProxy<bool> TClaBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are bool
922
923 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
924 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
925 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
926 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
927 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
928 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
929 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
930 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
931 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
932 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
933 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
934 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
935 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
936 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
937 typedef TClaArrayProxy<TArrayType<bool> > TClaArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of bool
938 //specialized ! typedef TClaArrayProxy<TArrayType<Char_t> > TClaArrayCharProxy;
939
940 typedef TStlImpProxy<Double_t> TStlDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
941 typedef TStlImpProxy<Double32_t> TStlDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
942 typedef TStlImpProxy<Float_t> TStlFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
943 typedef TStlImpProxy<Float16_t> TStlFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
944 typedef TStlImpProxy<UInt_t> TStlUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
945 typedef TStlImpProxy<ULong_t> TStlULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
946 typedef TStlImpProxy<ULong64_t> TStlULong64Proxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long long
947 typedef TStlImpProxy<UShort_t> TStlUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
948 typedef TStlImpProxy<UChar_t> TStlUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
949 typedef TStlImpProxy<Int_t> TStlIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
950 typedef TStlImpProxy<Long_t> TStlLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
951 typedef TStlImpProxy<Long64_t> TStlLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
952 typedef TStlImpProxy<Short_t> TStlShortProxy; // Concrete Implementation of the branch proxy around an stl container of short
953 typedef TStlImpProxy<Char_t> TStlCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
954 typedef TStlImpProxy<bool> TStlBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
955
956 typedef TStlArrayProxy<TArrayType<Double_t> > TStlArrayDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
957 typedef TStlArrayProxy<TArrayType<Double32_t> > TStlArrayDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
958 typedef TStlArrayProxy<TArrayType<Float_t> > TStlArrayFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
959 typedef TStlArrayProxy<TArrayType<Float16_t> > TStlArrayFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
960 typedef TStlArrayProxy<TArrayType<UInt_t> > TStlArrayUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
961 typedef TStlArrayProxy<TArrayType<ULong_t> > TStlArrayULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
962 typedef TStlArrayProxy<TArrayType<ULong64_t> > TStlArrayULong64Proxy; // Concrete Implementation of the branch proxy around an stl contained of unsigned long long
963 typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
964 typedef TStlArrayProxy<TArrayType<UChar_t> > TStlArrayUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
965 typedef TStlArrayProxy<TArrayType<Int_t> > TStlArrayIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
966 typedef TStlArrayProxy<TArrayType<Long_t> > TStlArrayLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
967 typedef TStlArrayProxy<TArrayType<Long64_t> > TStlArrayLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
968 typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayShortProxy; // Concrete Implementation of the branch proxy around an stl container of UShort_t
969 typedef TStlArrayProxy<TArrayType<Char_t> > TStlArrayCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
970 typedef TStlArrayProxy<TArrayType<bool> > TStlArrayBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
971
972} // namespace Internal
973
974// Reasonably backward compatible.
976
977} // namespace ROOT
978
979#endif
980
#define R__unlikely(expr)
Definition RConfig.hxx:586
#define d(i)
Definition RSha256.hxx:102
int Int_t
Definition RtypesCore.h:45
long long Long64_t
Definition RtypesCore.h:69
#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:185
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:2489
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()
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()
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:81
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
Int_t GetEntries() const override
Return the number of objects in array (i.e.
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
Int_t GetLast() const override
Return index of last object in array.
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
const char * Data() const
Definition TString.h:376
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
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Helper template to be able to determine and use array dimensions.
static constexpr int gSize
Helper class for proxy around multi dimension array.