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:611
#define d(i)
Definition RSha256.hxx:102
int Int_t
Definition RtypesCore.h:45
long long Long64_t
Definition RtypesCore.h:80
#define R__ASSERT(e)
Definition TError.h:118
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:2467
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:419
const char * Data() const
Definition TString.h:378
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
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
Helper template to be able to determine and use array dimensions.
static constexpr int gSize
Helper class for proxy around multi dimension array.