ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
TBranchProxy.h
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Philippe Canal 01/06/2004
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TBranchProxy
13 #define ROOT_TBranchProxy
14 
15 #ifndef ROOT_TBranchProxyDirector
16 #include "TBranchProxyDirector.h"
17 #endif
18 #ifndef ROOT_TTree
19 #include "TTree.h"
20 #endif
21 #ifndef ROOT_TBranch
22 #include "TBranch.h"
23 #endif
24 #ifndef ROOT_TClonesArray
25 #include "TClonesArray.h"
26 #endif
27 #ifndef ROOT_TString
28 #include "TString.h"
29 #endif
30 #ifndef ROOT_Riostream
31 #include "Riostream.h"
32 #endif
33 #ifndef ROOT_TError
34 #include "TError.h"
35 #endif
36 #ifndef ROOT_TVirtualCollectionProxy
38 #endif
39 
40 #include <list>
41 #include <algorithm>
42 
43 class TBranch;
44 class TStreamerElement;
45 
46 // Note we could protect the arrays more by introducing a class TArrayWrapper<class T> which somehow knows
47 // its internal dimensions and check for them ...
48 // template <class T> TArrayWrapper {
49 // public:
50 // TArrayWrapper(void *where, int dim1);
51 // const T operator[](int i) {
52 // if (i>=dim1) return 0;
53 // return where[i];
54 // };
55 // };
56 // 2D array would actually be a wrapper of a wrapper i.e. has a method TArrayWrapper<T> operator[](int i);
57 
58 namespace ROOT {
59 namespace Internal {
60  //_______________________________________________
61  // String builder to be used in the constructors.
63  public:
65  TBranchProxyHelper(const char *left,const char *right = 0) :
66  fName() {
67  if (left) {
68  fName = left;
69  if (left[0]&&right && fName[fName.Length()-1]!='.') fName += ".";
70  }
71  if (right) {
72  fName += right;
73  }
74  }
75  operator const char*() { return fName.Data(); };
76  };
77 } // namespace Internal
78 
79 
80 namespace Detail {
81  class TBranchProxy {
82  protected:
83  Internal::TBranchProxyDirector *fDirector; // contain pointer to TTree and entry to be read
84 
86 
87  const TString fBranchName; // name of the branch to read
88  TBranchProxy *fParent; // Proxy to a parent object
89 
90  const TString fDataMember; // name of the (eventual) data member being proxied
91 
92  const Bool_t fIsMember; // true if we proxy an unsplit data member
93  Bool_t fIsClone; // true if we proxy the inside of a TClonesArray
94  Bool_t fIsaPointer; // true if we proxy a data member of pointer type
95 
96 
97  TString fClassName; // class name of the object pointed to by the branch
98  TClass *fClass; // class name of the object pointed to by the branch
101  Int_t fOffset; // Offset inside the object
102 
103  TBranch *fBranch; // branch to read
104  TBranch *fBranchCount; // eventual auxiliary branch (for example holding the size)
105 
106  TTree *fLastTree; // TTree containing the last entry read
107  Long64_t fRead; // Last entry read
108 
109  void *fWhere; // memory location of the data
110  TVirtualCollectionProxy *fCollection; // Handle to the collection containing the data chunk.
111 
113 
114  public:
115  virtual void Print();
116 
117  TBranchProxy();
118  TBranchProxy(Internal::TBranchProxyDirector* boss, const char* top, const char* name = 0);
119  TBranchProxy(Internal::TBranchProxyDirector* boss, const char *top, const char *name, const char *membername);
120  TBranchProxy(Internal::TBranchProxyDirector* boss, TBranchProxy *parent, const char* membername, const char* top = 0, const char* name = 0);
121  TBranchProxy(Internal::TBranchProxyDirector* boss, TBranch* branch, const char* membername);
122  virtual ~TBranchProxy();
123 
124  TBranchProxy* GetProxy() { return this; }
125  const char* GetBranchName() const { return fBranchName; }
126 
127  void Reset();
128 
129  Bool_t Setup();
130 
133  }
134 
135  Bool_t IsaPointer() const {
136  return fIsaPointer;
137  }
138 
140  if (fDirector==0) return false;
141 
142  if (fDirector->GetReadEntry()!=fRead) {
143  if (!IsInitialized()) {
144  if (!Setup()) {
145  ::Error("TBranchProxy::Read","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
146  return kFALSE;
147  }
148  }
149  Bool_t result = kTRUE;
150  if (fParent) {
151  result = fParent->Read();
152  } else {
153  if (fBranchCount) {
154  result &= (-1 != fBranchCount->GetEntry(fDirector->GetReadEntry()));
155  }
156  result &= (-1 != fBranch->GetEntry(fDirector->GetReadEntry()));
157  }
159  return result;
160  } else {
161  return IsInitialized();
162  }
163  }
164 
166  if (fDirector==0) return false;
167 
168  if (fDirector->GetReadEntry()!=fRead) {
169  if (!IsInitialized()) {
170  if (!Setup()) {
171  ::Error("TBranchProxy::ReadEntries","%s",Form("Unable to initialize %s\n",fBranchName.Data()));
172  return false;
173  }
174  }
175  if (fParent) fParent->ReadEntries();
176  else {
177  if (fBranchCount) {
178  fBranchCount->TBranch::GetEntry(fDirector->GetReadEntry());
179  }
180  fBranch->TBranch::GetEntry(fDirector->GetReadEntry());
181  }
182  // NO - we only read the entries, not the contained objects!
183  // fRead = fDirector->GetReadEntry();
184  }
185  return IsInitialized();
186  }
187 
189  if (fDirector==0) return 0;
190  if (fDirector->GetReadEntry()!=fRead) {
191  if (!IsInitialized()) {
192  if (!Setup()) {
193  return 0;
194  }
195  }
196  }
197  return fClass;
198  }
199 
200  void* GetWhere() const { return fWhere; } // intentionally non-virtual
201 
203 
204  // protected:
205  virtual void *GetStart(UInt_t /*i*/=0) {
206  // return the address of the start of the object being proxied. Assumes
207  // that Setup() has been called.
208 
209  if (fParent) {
210  fWhere = ((unsigned char*)fParent->GetStart()) + fMemberOffset;
211  }
212  if (IsaPointer()) {
213  if (fWhere) return *(void**)fWhere;
214  else return 0;
215  } else {
216  return fWhere;
217  }
218  }
219 
220  virtual void *GetClaStart(UInt_t i=0) {
221  // return the address of the start of the object being proxied. Assumes
222  // that Setup() has been called. Assumes the object containing this data
223  // member is held in TClonesArray.
224 
225  char *location;
226 
227  if (fIsClone) {
228 
229  TClonesArray *tca;
230  tca = (TClonesArray*)GetStart();
231 
232  if (!tca || tca->GetLast()<(Int_t)i) return 0;
233 
234  location = (char*)tca->At(i);
235 
236  return location;
237 
238  } else if (fParent) {
239 
240  //tcaloc = ((unsigned char*)fParent->GetStart());
241  location = (char*)fParent->GetClaStart(i);
242 
243  } else {
244 
245  void *tcaloc;
246  tcaloc = fWhere;
247  TClonesArray *tca;
248  tca = (TClonesArray*)tcaloc;
249 
250  if (tca->GetLast()<(Int_t)i) return 0;
251 
252  location = (char*)tca->At(i);
253  }
254 
255  if (location) location += fOffset;
256  else return 0;
257 
258  if (IsaPointer()) {
259  return *(void**)(location);
260  } else {
261  return location;
262  }
263 
264  }
265 
266  virtual void *GetStlStart(UInt_t i=0) {
267  // return the address of the start of the object being proxied. Assumes
268  // that Setup() has been called. Assumes the object containing this data
269  // member is held in STL Collection.
270 
271  char *location=0;
272 
273  if (fCollection) {
274 
275  if (fCollection->Size()<i) return 0;
276 
277  location = (char*)fCollection->At(i);
278 
279  // return location;
280 
281  } else if (fParent) {
282 
283  //tcaloc = ((unsigned char*)fParent->GetStart());
284  location = (char*)fParent->GetStlStart(i);
285 
286  } else {
287 
288  R__ASSERT(0);
289  //void *tcaloc;
290  //tcaloc = fWhere;
291  //TClonesArray *tca;
292  //tca = (TClonesArray*)tcaloc;
293 
294  //if (tca->GetLast()<i) return 0;
295 
296  //location = (char*)tca->At(i);
297  }
298 
299  if (location) location += fOffset;
300  else return 0;
301 
302  if (IsaPointer()) {
303  return *(void**)(location);
304  } else {
305  return location;
306  }
307 
308  }
309 
310  Int_t GetOffset() { return fOffset; }
311  };
312 } // namespace Detail
313 
314 namespace Internal {
315 
316  //____________________________________________________________________________________________
317  // Concrete Implementation of the branch proxy around the data members which are array of char
319  public:
320  void Print() {
322  std::cout << "fWhere " << fWhere << std::endl;
323  if (fWhere) std::cout << "value? " << *(unsigned char*)GetStart() << std::endl;
324  }
325 
327  TArrayCharProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
328  TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name) :
329  TBranchProxy(director,top,name) {};
330  TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
331  TBranchProxy(director,top,name,data) {};
332  TArrayCharProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
333  TBranchProxy(director,parent, name, top, mid) {};
335 
336  unsigned char At(UInt_t i) {
337  static unsigned char default_val;
338  if (!Read()) return default_val;
339  // should add out-of bound test
340  unsigned char* str = (unsigned char*)GetStart();
341  return str[i];
342  }
343 
344  unsigned char operator [](Int_t i) {
345  return At(i);
346  }
347 
348  unsigned char operator [](UInt_t i) {
349  return At(i);
350  }
351 
352  operator const char*() {
353  if (!Read()) return "";
354  return (const char*)GetStart();
355  }
356 
357  const char* Data() {
358  if (!Read()) return "";
359  return (const char*)GetStart();
360  }
361 
362  const char* c_str() {
363  if (!Read()) return "";
364  return (const char*)GetStart();
365  }
366 
367  operator std::string() {
368  if (!Read()) return "";
369  return std::string((const char*)GetStart());
370  }
371 
372  };
373 
374  //_______________________________________________________
375  // Base class for the proxy around object in TClonesArray.
377  public:
378  void Print() {
380  std::cout << "fWhere " << fWhere << std::endl;
381  if (fWhere) {
382  if (IsaPointer()) {
383  std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
384  } else {
385  std::cout << "location " << fWhere << std::endl;
386  }
387  }
388  }
389 
391  TClaProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
392  TClaProxy(TBranchProxyDirector *director, const char *top, const char *name) :
393  TBranchProxy(director,top,name) {};
394  TClaProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
395  TBranchProxy(director,top,name,data) {};
396  TClaProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
397  TBranchProxy(director,parent, name, top, mid) {};
399 
400  const TClonesArray* GetPtr() {
401  if (!Read()) return 0;
402  return (TClonesArray*)GetStart();
403  }
404 
406  if (!ReadEntries()) return 0;
408  if (arr) return arr->GetEntries();
409  return 0;
410  }
411 
412  const TClonesArray* operator->() { return GetPtr(); }
413 
414  };
415 
416  //_______________________________________________
417  // Base class for the proxy around STL containers.
419  public:
420  void Print() {
422  std::cout << "fWhere " << fWhere << std::endl;
423  if (fWhere) {
424  if (IsaPointer()) {
425  std::cout << "location " << *(TClonesArray**)fWhere << std::endl;
426  } else {
427  std::cout << "location " << fWhere << std::endl;
428  }
429  }
430  }
431 
433  TStlProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
434  TStlProxy(TBranchProxyDirector *director, const char *top, const char *name) :
435  TBranchProxy(director,top,name) {};
436  TStlProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
437  TBranchProxy(director,top,name,data) {};
438  TStlProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
439  TBranchProxy(director,parent, name, top, mid) {};
441 
443  if (!Read()) return 0;
444  return GetCollection();
445  }
446 
448  if (!ReadEntries()) return 0;
449  return GetPtr()->Size();
450  }
451 
453 
454  };
455 
456  //______________________________________
457  // Template of the proxy around objects.
458  template <class T>
460  public:
461  void Print() {
463  std::cout << "fWhere " << fWhere << std::endl;
464  if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
465  }
466 
468  TImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
469  TImpProxy(TBranchProxyDirector *director, const char *top, const char *name) :
470  TBranchProxy(director,top,name) {};
471  TImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
472  TBranchProxy(director,top,name,data) {};
473  TImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
474  TBranchProxy(director,parent, name, top, mid) {};
476 
477  operator T() {
478  if (!Read()) return 0;
479  return *(T*)GetStart();
480  }
481 
482  // Make sure that the copy methods are really private
483 #ifdef private
484 #undef private
485 #define private_was_replaced
486 #endif
487  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
488  private:
489  TImpProxy(T);
491 #ifdef private_was_replaced
492 #define private public
493 #endif
494 
495  };
496 
497  //____________________________________________
498  // Helper template to be able to determine and
499  // use array dimentsions.
500  template <class T, int d = 0> struct TArrayType {
501  typedef T type_t;
502  typedef T array_t[d];
503  };
504  //____________________________________________
505  // Helper class for proxy around multi dimension array
506  template <class T> struct TArrayType<T,0> {
507  typedef T type_t;
508  typedef T array_t;
509  };
510  //____________________________________________
511  // Helper class for proxy around multi dimension array
512  template <class T, int d> struct TMultiArrayType {
513  typedef typename T::type_t type_t;
514  typedef typename T::array_t array_t[d];
515  };
516 
517  //____________________________________________
518  // Template for concrete implementation of proxy around array of T
519  template <class T>
521  public:
523  TArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
524  TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
525  TBranchProxy(director,top,name) {};
526  TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
527  TBranchProxy(director,top,name,data) {};
528  TArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
529  TBranchProxy(director,parent, name, top, mid) {};
531 
532  typedef typename T::array_t array_t;
533  typedef typename T::type_t type_t;
534 
535  void Print() {
537  std::cout << "fWhere " << GetWhere() << std::endl;
538  if (GetWhere()) std::cout << "value? " << *(type_t*)GetWhere() << std::endl;
539  }
540 
541  const array_t &At(UInt_t i) {
542  static array_t default_val;
543  if (!Read()) return default_val;
544  // should add out-of bound test
545  array_t *arr = 0;
546  arr = (array_t*)((type_t*)(GetStart()));
547  if (arr) return arr[i];
548  else return default_val;
549  }
550 
551  const array_t &operator [](Int_t i) { return At(i); }
552  const array_t &operator [](UInt_t i) { return At(i); }
553  };
554 
555  //_____________________________________________________________________________________
556  // Template of the Concrete Implementation of the branch proxy around TClonesArray of T
557  template <class T>
559  public:
560 
561  void Print() {
563  std::cout << "fWhere " << fWhere << std::endl;
564  if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
565  }
566 
568  TClaImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
569  TClaImpProxy(TBranchProxyDirector *director, const char *top, const char *name) :
570  TBranchProxy(director,top,name) {};
571  TClaImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
572  TBranchProxy(director,top,name,data) {};
573  TClaImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
574  TBranchProxy(director,parent, name, top, mid) {};
576 
577  const T& At(UInt_t i) {
578  static T default_val;
579  if (!Read()) return default_val;
580  if (fWhere==0) return default_val;
581 
582  T *temp = (T*)GetClaStart(i);
583 
584  if (temp) return *temp;
585  else return default_val;
586 
587  }
588 
589  const T& operator [](Int_t i) { return At(i); }
590  const T& operator [](UInt_t i) { return At(i); }
591 
592  // Make sure that the copy methods are really private
593 #ifdef private
594 #undef private
595 #define private_was_replaced
596 #endif
597  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
598  private:
599  TClaImpProxy(T);
601 #ifdef private_was_replaced
602 #define private public
603 #endif
604 
605  };
606 
607  //_________________________________________________________________________________________
608  // Template of the Concrete Implementation of the branch proxy around an stl container of T
609  template <class T>
611  public:
612 
613  void Print() {
615  std::cout << "fWhere " << fWhere << std::endl;
616  if (fWhere) std::cout << "value? " << *(T*)GetStart() << std::endl;
617  }
618 
620  TStlImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
621  TStlImpProxy(TBranchProxyDirector *director, const char *top, const char *name) :
622  TBranchProxy(director,top,name) {};
623  TStlImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
624  TBranchProxy(director,top,name,data) {};
625  TStlImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
626  TBranchProxy(director,parent, name, top, mid) {};
628 
629  const T& At(UInt_t i) {
630  static T default_val;
631  if (!Read()) return default_val;
632  if (fWhere==0) return default_val;
633 
634  T *temp = (T*)GetStlStart(i);
635 
636  if (temp) return *temp;
637  else return default_val;
638  }
639 
640  const T& operator [](Int_t i) { return At(i); }
641  const T& operator [](UInt_t i) { return At(i); }
642 
643  // Make sure that the copy methods are really private
644 #ifdef private
645 #undef private
646 #define private_was_replaced
647 #endif
648  // For now explicitly disable copying into the value (i.e. the proxy is read-only).
649  private:
650  TStlImpProxy(T);
652 #ifdef private_was_replaced
653 #define private public
654 #endif
655 
656  };
657 
658  //_________________________________________________________________________________________________
659  // Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
660  template <class T>
662  public:
663  typedef typename T::array_t array_t;
664  typedef typename T::type_t type_t;
665 
666  void Print() {
668  std::cout << "fWhere " << fWhere << std::endl;
669  if (fWhere) std::cout << "value? " << *(type_t*)GetStart() << std::endl;
670  }
671 
673  TClaArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
674  TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
675  TBranchProxy(director,top,name) {};
676  TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
677  TBranchProxy(director,top,name,data) {};
678  TClaArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
679  TBranchProxy(director,parent, name, top, mid) {};
681 
682  /* const */ array_t *At(UInt_t i) {
683  static array_t default_val;
684  if (!Read()) return &default_val;
685  if (fWhere==0) return &default_val;
686 
687  return (array_t*)GetClaStart(i);
688  }
689 
690  /* const */ array_t *operator [](Int_t i) { return At(i); }
691  /* const */ array_t *operator [](UInt_t i) { return At(i); }
692  };
693 
694 
695  //__________________________________________________________________________________________________
696  // Template of the Concrete Implementation of the branch proxy around an stl container of array of T
697  template <class T>
699  public:
700  typedef typename T::array_t array_t;
701  typedef typename T::type_t type_t;
702 
703  void Print() {
705  std::cout << "fWhere " << fWhere << std::endl;
706  if (fWhere) std::cout << "value? " << *(type_t*)GetStart() << std::endl;
707  }
708 
710  TStlArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
711  TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
712  TBranchProxy(director,top,name) {};
713  TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
714  TBranchProxy(director,top,name,data) {};
715  TStlArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
716  TBranchProxy(director,parent, name, top, mid) {};
718 
719  /* const */ array_t *At(UInt_t i) {
720  static array_t default_val;
721  if (!Read()) return &default_val;
722  if (fWhere==0) return &default_val;
723 
724  return (array_t*)GetStlStart(i);
725  }
726 
727  /* const */ array_t *operator [](Int_t i) { return At(i); }
728  /* const */ array_t *operator [](UInt_t i) { return At(i); }
729  };
730 
731  //TImpProxy<TObject> d;
732  typedef TImpProxy<Double_t> TDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are double
733  typedef TImpProxy<Double32_t> TDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are double32
734  typedef TImpProxy<Float_t> TFloatProxy; // Concrete Implementation of the branch proxy around the data members which are float
735  typedef TImpProxy<Float16_t> TFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are float16
736  typedef TImpProxy<UInt_t> TUIntProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned int
737  typedef TImpProxy<ULong_t> TULongProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long
738  typedef TImpProxy<ULong64_t> TULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are unsigned long long
739  typedef TImpProxy<UShort_t> TUShortProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned short
740  typedef TImpProxy<UChar_t> TUCharProxy; // Concrete Implementation of the branch proxy around the data members which are unsigned char
741  typedef TImpProxy<Int_t> TIntProxy; // Concrete Implementation of the branch proxy around the data members which are int
742  typedef TImpProxy<Long_t> TLongProxy; // Concrete Implementation of the branch proxy around the data members which are long
743  typedef TImpProxy<Long64_t> TLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are long long
744  typedef TImpProxy<Short_t> TShortProxy; // Concrete Implementation of the branch proxy around the data members which are short
745  typedef TImpProxy<Char_t> TCharProxy; // Concrete Implementation of the branch proxy around the data members which are char
746  typedef TImpProxy<Bool_t> TBoolProxy; // Concrete Implementation of the branch proxy around the data members which are bool
747 
748  typedef TArrayProxy<TArrayType<Double_t> > TArrayDoubleProxy; // Concrete Implementation of the branch proxy around the data members which are array of double
749  typedef TArrayProxy<TArrayType<Double32_t> > TArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are array of double32
750  typedef TArrayProxy<TArrayType<Float_t> > TArrayFloatProxy; // Concrete Implementation of the branch proxy around the data members which are array of float
751  typedef TArrayProxy<TArrayType<Float16_t> > TArrayFloat16Proxy; // Concrete Implementation of the branch proxy around the data members which are array of float16
752  typedef TArrayProxy<TArrayType<UInt_t> > TArrayUIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned int
753  typedef TArrayProxy<TArrayType<ULong_t> > TArrayULongProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long
754  typedef TArrayProxy<TArrayType<ULong64_t> > TArrayULong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned long long
755  typedef TArrayProxy<TArrayType<UShort_t> > TArrayUShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned short
756  typedef TArrayProxy<TArrayType<UChar_t> > TArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of unsigned char
757  typedef TArrayProxy<TArrayType<Int_t> > TArrayIntProxy; // Concrete Implementation of the branch proxy around the data members which are array of int
758  typedef TArrayProxy<TArrayType<Long_t> > TArrayLongProxy; // Concrete Implementation of the branch proxy around the data members which are array of long
759  typedef TArrayProxy<TArrayType<Long64_t> > TArrayLong64Proxy; // Concrete Implementation of the branch proxy around the data members which are array of long long
760  typedef TArrayProxy<TArrayType<UShort_t> > TArrayShortProxy; // Concrete Implementation of the branch proxy around the data members which are array of short
761  //specialized ! typedef TArrayProxy<TArrayType<Char_t> > TArrayCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of char
762  typedef TArrayProxy<TArrayType<Bool_t> > TArrayBoolProxy; // Concrete Implementation of the branch proxy around the data members which are array of bool
763 
764  typedef TClaImpProxy<Double_t> TClaDoubleProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double
765  typedef TClaImpProxy<Double32_t> TClaDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double32
766  typedef TClaImpProxy<Float_t> TClaFloatProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float
767  typedef TClaImpProxy<Float16_t> TClaFloat16Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float16
768  typedef TClaImpProxy<UInt_t> TClaUIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned int
769  typedef TClaImpProxy<ULong_t> TClaULongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long
770  typedef TClaImpProxy<ULong64_t> TClaULong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long long
771  typedef TClaImpProxy<UShort_t> TClaUShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned short
772  typedef TClaImpProxy<UChar_t> TClaUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned char
773  typedef TClaImpProxy<Int_t> TClaIntProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are int
774  typedef TClaImpProxy<Long_t> TClaLongProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long
775  typedef TClaImpProxy<Long64_t> TClaLong64Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long long
776  typedef TClaImpProxy<Short_t> TClaShortProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are short
777  typedef TClaImpProxy<Char_t> TClaCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are char
778  typedef TClaImpProxy<Bool_t> TClaBoolProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are bool
779 
780  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
781  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
782  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
783  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
784  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
785  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
786  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
787  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
788  typedef TClaArrayProxy<TArrayType<UChar_t> > TClaArrayUCharProxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are array of nsigned char
789  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
790  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
791  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
792  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
793  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
794  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
795  //specialized ! typedef TClaArrayProxy<TArrayType<Char_t> > TClaArrayCharProxy;
796 
797  typedef TStlImpProxy<Double_t> TStlDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
798  typedef TStlImpProxy<Double32_t> TStlDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
799  typedef TStlImpProxy<Float_t> TStlFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
800  typedef TStlImpProxy<Float16_t> TStlFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
801  typedef TStlImpProxy<UInt_t> TStlUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
802  typedef TStlImpProxy<ULong_t> TStlULongProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long
803  typedef TStlImpProxy<ULong64_t> TStlULong64Proxy; // Concrete Implementation of the branch proxy around an stl container of unsigned long long
804  typedef TStlImpProxy<UShort_t> TStlUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned short
805  typedef TStlImpProxy<UChar_t> TStlUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned char
806  typedef TStlImpProxy<Int_t> TStlIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
807  typedef TStlImpProxy<Long_t> TStlLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
808  typedef TStlImpProxy<Long64_t> TStlLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
809  typedef TStlImpProxy<Short_t> TStlShortProxy; // Concrete Implementation of the branch proxy around an stl container of short
810  typedef TStlImpProxy<Char_t> TStlCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
811  typedef TStlImpProxy<Bool_t> TStlBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
812 
813  typedef TStlArrayProxy<TArrayType<Double_t> > TStlArrayDoubleProxy; // Concrete Implementation of the branch proxy around an stl container of double
814  typedef TStlArrayProxy<TArrayType<Double32_t> > TStlArrayDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
815  typedef TStlArrayProxy<TArrayType<Float_t> > TStlArrayFloatProxy; // Concrete Implementation of the branch proxy around an stl container of float
816  typedef TStlArrayProxy<TArrayType<Float16_t> > TStlArrayFloat16Proxy; // Concrete Implementation of the branch proxy around an stl container of float16_t
817  typedef TStlArrayProxy<TArrayType<UInt_t> > TStlArrayUIntProxy; // Concrete Implementation of the branch proxy around an stl container of unsigned int
818  typedef TStlArrayProxy<TArrayType<ULong_t> > TStlArrayULongProxy; // Concrete Implementation of the branch proxy around an stl container of usigned long
819  typedef TStlArrayProxy<TArrayType<ULong64_t> > TStlArrayULong64Proxy; // Concrete Implementation of the branch proxy around an stl contained of unsigned long long
820  typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayUShortProxy; // Concrete Implementation of the branch proxy around an stl container of unisgned short
821  typedef TStlArrayProxy<TArrayType<UChar_t> > TStlArrayUCharProxy; // Concrete Implementation of the branch proxy around an stl container of unsingned char
822  typedef TStlArrayProxy<TArrayType<Int_t> > TStlArrayIntProxy; // Concrete Implementation of the branch proxy around an stl container of int
823  typedef TStlArrayProxy<TArrayType<Long_t> > TStlArrayLongProxy; // Concrete Implementation of the branch proxy around an stl container of long
824  typedef TStlArrayProxy<TArrayType<Long64_t> > TStlArrayLong64Proxy; // Concrete Implementation of the branch proxy around an stl container of long long
825  typedef TStlArrayProxy<TArrayType<UShort_t> > TStlArrayShortProxy; // Concrete Implementation of the branch proxy around an stl container of UShort_t
826  typedef TStlArrayProxy<TArrayType<Char_t> > TStlArrayCharProxy; // Concrete Implementation of the branch proxy around an stl container of char
827  typedef TStlArrayProxy<TArrayType<Bool_t> > TStlArrayBoolProxy; // Concrete Implementation of the branch proxy around an stl container of bool
828 
829 } // namespace Internal
830 
831 // Reasonably backward compatible.
833 
834 } // namespace ROOT
835 
836 #endif
837 
TStlArrayProxy< TArrayType< Bool_t > > TStlArrayBoolProxy
Definition: TBranchProxy.h:827
TStlArrayProxy< TArrayType< Int_t > > TStlArrayIntProxy
Definition: TBranchProxy.h:822
TImpProxy< Double32_t > TDouble32Proxy
Definition: TBranchProxy.h:733
TStlArrayProxy< TArrayType< Double_t > > TStlArrayDoubleProxy
Definition: TBranchProxy.h:813
TArrayProxy< TArrayType< Double_t > > TArrayDoubleProxy
Definition: TBranchProxy.h:748
TClaImpProxy< Float_t > TClaFloatProxy
Definition: TBranchProxy.h:766
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayUShortProxy
Definition: TBranchProxy.h:820
const array_t & operator[](Int_t i)
Definition: TBranchProxy.h:551
TArrayCharProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:327
long long Long64_t
Definition: RtypesCore.h:69
TStlArrayProxy< TArrayType< Long64_t > > TStlArrayLong64Proxy
Definition: TBranchProxy.h:824
TStlImpProxy< Float16_t > TStlFloat16Proxy
Definition: TBranchProxy.h:800
TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:524
Ssiz_t Length() const
Definition: TString.h:390
TArrayProxy< TArrayType< Long64_t > > TArrayLong64Proxy
Definition: TBranchProxy.h:759
Int_t GetLast() const
Return index of last object in array.
Definition: TObjArray.cxx:528
const T & At(UInt_t i)
Definition: TBranchProxy.h:629
TStlImpProxy< ULong64_t > TStlULong64Proxy
Definition: TBranchProxy.h:803
TStlImpProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:620
TImpProxy< Double_t > TDoubleProxy
Definition: TBranchProxy.h:732
const TVirtualCollectionProxy * operator->()
Definition: TBranchProxy.h:452
TStlArrayProxy< TArrayType< UChar_t > > TStlArrayUCharProxy
Definition: TBranchProxy.h:821
TImpProxy< ULong64_t > TULong64Proxy
Definition: TBranchProxy.h:738
TStlArrayProxy< TArrayType< UShort_t > > TStlArrayShortProxy
Definition: TBranchProxy.h:825
TArrayProxy< TArrayType< Long_t > > TArrayLongProxy
Definition: TBranchProxy.h:758
TClaImpProxy< UInt_t > TClaUIntProxy
Definition: TBranchProxy.h:768
TClaArrayProxy< TArrayType< Char_t > > TClaArrayCharProxy
Definition: TBranchProxy.h:793
TImpProxy< Char_t > TCharProxy
Definition: TBranchProxy.h:745
TStlImpProxy< Long64_t > TStlLong64Proxy
Definition: TBranchProxy.h:808
TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:676
const TClonesArray * operator->()
Definition: TBranchProxy.h:412
TArrayProxy< TArrayType< UShort_t > > TArrayUShortProxy
Definition: TBranchProxy.h:755
#define R__ASSERT(e)
Definition: TError.h:98
TStreamerElement * fElement
Definition: TBranchProxy.h:99
TArrayProxy< TArrayType< Double32_t > > TArrayDouble32Proxy
Definition: TBranchProxy.h:749
TClaImpProxy< Float16_t > TClaFloat16Proxy
Definition: TBranchProxy.h:767
TStlProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:433
const T & At(UInt_t i)
Definition: TBranchProxy.h:577
Basic string class.
Definition: TString.h:137
virtual void * GetStart(UInt_t=0)
Definition: TBranchProxy.h:205
TImpProxy< Float_t > TFloatProxy
Definition: TBranchProxy.h:734
TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:713
int Int_t
Definition: RtypesCore.h:41
TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:674
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
TClaImpProxy< Long_t > TClaLongProxy
Definition: TBranchProxy.h:774
TImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:471
TStlProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:436
TClaImpProxy< UShort_t > TClaUShortProxy
Definition: TBranchProxy.h:771
TStlProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:434
TArrayProxy< TArrayType< ULong_t > > TArrayULongProxy
Definition: TBranchProxy.h:753
TClaImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:571
TClaArrayProxy< TArrayType< UInt_t > > TClaArrayUIntProxy
Definition: TBranchProxy.h:784
TTree * T
const char * Data() const
Definition: TString.h:349
TStlArrayProxy< TArrayType< ULong_t > > TStlArrayULongProxy
Definition: TBranchProxy.h:818
TStlImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:623
TImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:473
TArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:528
TStlArrayProxy< TArrayType< Float16_t > > TStlArrayFloat16Proxy
Definition: TBranchProxy.h:816
int d
Definition: tornado.py:11
TStlImpProxy< Short_t > TStlShortProxy
Definition: TBranchProxy.h:809
TArrayProxy< TArrayType< UChar_t > > TArrayUCharProxy
Definition: TBranchProxy.h:756
TStlArrayProxy< TArrayType< ULong64_t > > TStlArrayULong64Proxy
Definition: TBranchProxy.h:819
TArrayProxy< TArrayType< Bool_t > > TArrayBoolProxy
Definition: TBranchProxy.h:762
TClaArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:678
TClaProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:392
TClaArrayProxy< TArrayType< UChar_t > > TClaArrayUCharProxy
Definition: TBranchProxy.h:788
TStlImpProxy< Int_t > TStlIntProxy
Definition: TBranchProxy.h:806
TClaImpProxy< UChar_t > TClaUCharProxy
Definition: TBranchProxy.h:772
const T & operator[](Int_t i)
Definition: TBranchProxy.h:589
TImpProxy< Int_t > TIntProxy
Definition: TBranchProxy.h:741
TClaProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:396
array_t * operator[](Int_t i)
Definition: TBranchProxy.h:690
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayShortProxy
Definition: TBranchProxy.h:792
TStlImpProxy & operator=(T)
virtual void * GetClaStart(UInt_t i=0)
Definition: TBranchProxy.h:220
TStlImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:625
TImpProxy & operator=(T)
TClaArrayProxy< TArrayType< Long_t > > TClaArrayLongProxy
Definition: TBranchProxy.h:790
TStlImpProxy< ULong_t > TStlULongProxy
Definition: TBranchProxy.h:802
virtual Int_t GetTreeNumber() const
Definition: TTree.h:438
TStlImpProxy< Char_t > TStlCharProxy
Definition: TBranchProxy.h:810
TArrayProxy< TArrayType< Float16_t > > TArrayFloat16Proxy
Definition: TBranchProxy.h:751
unsigned int UInt_t
Definition: RtypesCore.h:42
TImpProxy< UChar_t > TUCharProxy
Definition: TBranchProxy.h:740
TClaImpProxy< Short_t > TClaShortProxy
Definition: TBranchProxy.h:776
char * Form(const char *fmt,...)
TArrayProxy< TArrayType< Int_t > > TArrayIntProxy
Definition: TBranchProxy.h:757
TArrayCharProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:332
TImpProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:468
TClaArrayProxy< TArrayType< Double_t > > TClaArrayDoubleProxy
Definition: TBranchProxy.h:780
TClaArrayProxy< TArrayType< Float16_t > > TClaArrayFloat16Proxy
Definition: TBranchProxy.h:783
TClaArrayProxy< TArrayType< UShort_t > > TClaArrayUShortProxy
Definition: TBranchProxy.h:787
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:1199
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:81
TClaImpProxy< ULong_t > TClaULongProxy
Definition: TBranchProxy.h:769
TClaImpProxy< Double_t > TClaDoubleProxy
Definition: TBranchProxy.h:764
TImpProxy< Short_t > TShortProxy
Definition: TBranchProxy.h:744
TImpProxy< Long_t > TLongProxy
Definition: TBranchProxy.h:742
TClaImpProxy< ULong64_t > TClaULong64Proxy
Definition: TBranchProxy.h:770
TClaImpProxy< Long64_t > TClaLong64Proxy
Definition: TBranchProxy.h:775
TStlImpProxy< Double32_t > TStlDouble32Proxy
Definition: TBranchProxy.h:798
const T & operator[](Int_t i)
Definition: TBranchProxy.h:640
const TVirtualCollectionProxy * GetPtr()
Definition: TBranchProxy.h:442
TClaImpProxy< Bool_t > TClaBoolProxy
Definition: TBranchProxy.h:778
TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:526
TArrayProxy< TArrayType< ULong64_t > > TArrayULong64Proxy
Definition: TBranchProxy.h:754
TStlImpProxy< Float_t > TStlFloatProxy
Definition: TBranchProxy.h:799
void * GetWhere() const
Definition: TBranchProxy.h:200
TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:330
TClaArrayProxy< TArrayType< Int_t > > TClaArrayIntProxy
Definition: TBranchProxy.h:789
TClaImpProxy< Double32_t > TClaDouble32Proxy
Definition: TBranchProxy.h:765
TVirtualCollectionProxy * GetCollection()
Definition: TBranchProxy.h:202
TImpProxy< ULong_t > TULongProxy
Definition: TBranchProxy.h:737
TStlArrayProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:710
const char * GetBranchName() const
Definition: TBranchProxy.h:125
Bool_t IsaPointer() const
Definition: TBranchProxy.h:135
TStlImpProxy< UInt_t > TStlUIntProxy
Definition: TBranchProxy.h:801
TClaImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:573
TClaArrayProxy< TArrayType< Long64_t > > TClaArrayLong64Proxy
Definition: TBranchProxy.h:791
virtual void * At(UInt_t idx)=0
TStlArrayProxy< TArrayType< Char_t > > TStlArrayCharProxy
Definition: TBranchProxy.h:826
TClaArrayProxy< TArrayType< Double32_t > > TClaArrayDouble32Proxy
Definition: TBranchProxy.h:781
TImpProxy< Bool_t > TBoolProxy
Definition: TBranchProxy.h:746
virtual void * GetStlStart(UInt_t i=0)
Definition: TBranchProxy.h:266
TClaImpProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:569
TClaArrayProxy< TArrayType< Bool_t > > TClaArrayBoolProxy
Definition: TBranchProxy.h:794
TImpProxy< UShort_t > TUShortProxy
Definition: TBranchProxy.h:739
Internal::TBranchProxyDirector * fDirector
Definition: TBranchProxy.h:83
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:494
TClaArrayProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:673
TStlImpProxy< Long_t > TStlLongProxy
Definition: TBranchProxy.h:807
TArrayProxy< TArrayType< Float_t > > TArrayFloatProxy
Definition: TBranchProxy.h:750
#define name(a, b)
Definition: linkTestLib0.cpp:5
TStlImpProxy< UChar_t > TStlUCharProxy
Definition: TBranchProxy.h:805
TArrayProxy< TArrayType< UShort_t > > TArrayShortProxy
Definition: TBranchProxy.h:760
TArrayProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:523
TStlProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:438
TClaProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data)
Definition: TBranchProxy.h:394
TImpProxy< UInt_t > TUIntProxy
Definition: TBranchProxy.h:736
virtual UInt_t Size() const =0
const TClonesArray * GetPtr()
Definition: TBranchProxy.h:400
TArrayProxy< TArrayType< UInt_t > > TArrayUIntProxy
Definition: TBranchProxy.h:752
TStlArrayProxy< TArrayType< Float_t > > TStlArrayFloatProxy
Definition: TBranchProxy.h:815
TClaImpProxy< Int_t > TClaIntProxy
Definition: TBranchProxy.h:773
An array of clone (identical) objects.
Definition: TClonesArray.h:32
TStlImpProxy< Double_t > TStlDoubleProxy
Definition: TBranchProxy.h:797
TImpProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:469
TClaProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:391
TBranchProxyHelper(const char *left, const char *right=0)
Definition: TBranchProxy.h:65
TStlArrayProxy< TArrayType< Long_t > > TStlArrayLongProxy
Definition: TBranchProxy.h:823
TImpProxy< Long64_t > TLong64Proxy
Definition: TBranchProxy.h:743
TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:328
TStlArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char *top=0, const char *mid=0)
Definition: TBranchProxy.h:715
TBranchProxy * GetProxy()
Definition: TBranchProxy.h:124
TClaImpProxy< Char_t > TClaCharProxy
Definition: TBranchProxy.h:777
TClaImpProxy & operator=(T)
TStlArrayProxy< TArrayType< UInt_t > > TStlArrayUIntProxy
Definition: TBranchProxy.h:817
TStlArrayProxy< TArrayType< Double32_t > > TStlArrayDouble32Proxy
Definition: TBranchProxy.h:814
TClaImpProxy(TBranchProxyDirector *director, const char *name)
Definition: TBranchProxy.h:568
A TTree object has a header with a name and a title.
Definition: TTree.h:98
const array_t & At(UInt_t i)
Definition: TBranchProxy.h:541
double result[121]
TStlImpProxy< Bool_t > TStlBoolProxy
Definition: TBranchProxy.h:811
TImpProxy< Float16_t > TFloat16Proxy
Definition: TBranchProxy.h:735
TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:711
TClaArrayProxy< TArrayType< Float_t > > TClaArrayFloatProxy
Definition: TBranchProxy.h:782
TObject * At(Int_t idx) const
Definition: TObjArray.h:167
array_t * operator[](Int_t i)
Definition: TBranchProxy.h:727
A TTree is a list of TBranches.
Definition: TBranch.h:58
const Bool_t kTRUE
Definition: Rtypes.h:91
TClaArrayProxy< TArrayType< ULong64_t > > TClaArrayULong64Proxy
Definition: TBranchProxy.h:786
unsigned char operator[](Int_t i)
Definition: TBranchProxy.h:344
TVirtualCollectionProxy * fCollection
Definition: TBranchProxy.h:110
unsigned char At(UInt_t i)
Definition: TBranchProxy.h:336
TClaArrayProxy< TArrayType< ULong_t > > TClaArrayULongProxy
Definition: TBranchProxy.h:785
void Error(ErrorHandler_t func, int code, const char *va_(fmt),...)
Write error message and call a handler, if required.
TStlImpProxy(TBranchProxyDirector *director, const char *top, const char *name)
Definition: TBranchProxy.h:621
TStlImpProxy< UShort_t > TStlUShortProxy
Definition: TBranchProxy.h:804