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