ROOT logo
// @(#)root/treeplayer:$Id: TBranchProxy.h 27129 2009-01-13 08:22:29Z pcanal $
// Author: Philippe Canal 01/06/2004

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al.        *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TBranchProxy
#define ROOT_TBranchProxy

#ifndef ROOT_TBranchProxyDirector
#include "TBranchProxyDirector.h"
#endif
#ifndef ROOT_TTree
#include "TTree.h"
#endif
#ifndef ROOT_TBranch
#include "TBranch.h"
#endif
#ifndef ROOT_TClonesArray
#include "TClonesArray.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_Riostream
#include "Riostream.h"
#endif
#ifndef ROOT_TError
#include "TError.h"
#endif
#ifndef ROOT_TVirtualCollectionProxy
#include "TVirtualCollectionProxy.h"
#endif

#include <list>
#include <algorithm>

class TBranch;
class TStreamerElement;

// Note we could protect the arrays more by introducing a class TArrayWrapper<class T> which somehow knows
// its internal dimensions and check for them ...
// template <class T> TArrayWrapper {
// public:
//    TArrayWrapper(void *where, int dim1);
//    const T operator[](int i) {
//       if (i>=dim1) return 0;
//       return where[i];
//    };
// };
// 2D array would actually be a wrapper of a wrapper i.e. has a method TArrayWrapper<T> operator[](int i);

namespace ROOT {

   //_______________________________________________
   // String builder to be used in the constructors.
   class TBranchProxyHelper {
   public:
      TString fName;
      TBranchProxyHelper(const char *left,const char *right = 0) :
         fName() {
         if (left) {
            fName = left;
            if (strlen(left)&&right && fName[fName.Length()-1]!='.') fName += ".";
         }
         if (right) {
            fName += right;
         }
      }
      operator const char*() { return fName.Data(); };
   };


   class TBranchProxy {
   protected:
      TBranchProxyDirector *fDirector; // contain pointer to TTree and entry to be read

      Bool_t   fInitialized;

      const TString fBranchName;  // name of the branch to read
      TBranchProxy *fParent;      // Proxy to a parent object

      const TString fDataMember;  // name of the (eventual) data member being proxied

      const Bool_t  fIsMember;    // true if we proxy an unsplit data member
      Bool_t        fIsClone;     // true if we proxy the inside of a TClonesArray
      Bool_t        fIsaPointer;  // true if we proxy a data member of pointer type


      TString           fClassName;     // class name of the object pointed to by the branch
      TClass           *fClass;         // class name of the object pointed to by the branch
      TStreamerElement *fElement;
      Int_t             fMemberOffset;
      Int_t             fOffset;        // Offset inside the object

      TBranch *fBranch;       // branch to read
      TBranch *fBranchCount;  // eventual auxiliary branch (for example holding the size)

      TTree   *fLastTree; // TTree containing the last entry read
      Long64_t fRead;     // Last entry read

      void    *fWhere;    // memory location of the data
      TVirtualCollectionProxy *fCollection; // Handle to the collection containing the data chunk.

   public:
      virtual void Print();

      TBranchProxy();
      TBranchProxy(TBranchProxyDirector* boss, const char* top, const char* name = 0);
      TBranchProxy(TBranchProxyDirector* boss, const char *top, const char *name, const char *membername);
      TBranchProxy(TBranchProxyDirector* boss, TBranchProxy *parent, const char* membername, const char* top = 0, const char* name = 0);
      virtual ~TBranchProxy();

      TBranchProxy* GetProxy() { return this; }

      void Reset();

      Bool_t Setup();

      Bool_t IsInitialized() {
         return fLastTree && (fLastTree == fDirector->GetTree());
      }

      Bool_t IsaPointer() const {
         return fIsaPointer;
      }

      Bool_t Read() {
         if (fDirector==0) return false;

         if (fDirector->GetReadEntry()!=fRead) {
            if (!IsInitialized()) {
               if (!Setup()) {
                  Error("Read",Form("Unable to initialize %s\n",fBranchName.Data()));
                  return false;
               }
            }
            if (fParent) fParent->Read();
            else {
               if (fBranchCount) {
                  fBranchCount->GetEntry(fDirector->GetReadEntry());
               }
               fBranch->GetEntry(fDirector->GetReadEntry());
            }
            fRead = fDirector->GetReadEntry();
            return kTRUE;
         } else {
            return IsInitialized();
         }
      }

      Bool_t ReadEntries() {
         if (fDirector==0) return false;

         if (fDirector->GetReadEntry()!=fRead) {
            if (!IsInitialized()) {
               if (!Setup()) {
                  Error("Read",Form("Unable to initialize %s\n",fBranchName.Data()));
                  return false;
               }
            }
            if (fParent) fParent->ReadEntries();
            else {
               if (fBranchCount) {
                  fBranchCount->TBranch::GetEntry(fDirector->GetReadEntry());
               }
               fBranch->TBranch::GetEntry(fDirector->GetReadEntry());
            }
            // NO - we only read the entries, not the contained objects!
            // fRead = fDirector->GetReadEntry();
         }
         return IsInitialized();
      }

      TClass *GetClass() {
         if (fDirector==0) return 0;
         if (fDirector->GetReadEntry()!=fRead) {
            if (!IsInitialized()) {
               if (!Setup()) {
                  return 0;
               }
            }
         }
         return fClass;
      }

      void* GetWhere() const { return fWhere; } // intentionally non-virtual
      
      TVirtualCollectionProxy *GetCollection() { return fCollection; }

      // protected:
      virtual  void *GetStart(UInt_t /*i*/=0) {
         // return the address of the start of the object being proxied. Assumes
         // that Setup() has been called.

         if (fParent) {
            fWhere = ((unsigned char*)fParent->GetStart()) + fMemberOffset;
         }
         if (IsaPointer()) {
            if (fWhere) return *(void**)fWhere;
            else return 0;
         } else {
            return fWhere;
         }
      }

      virtual void *GetClaStart(UInt_t i=0) {
         // return the address of the start of the object being proxied. Assumes
         // that Setup() has been called.  Assumes the object containing this data
         // member is held in TClonesArray.

         char *location;

         if (fIsClone) {

            TClonesArray *tca;
            tca = (TClonesArray*)GetStart();

            if (tca->GetLast()<(Int_t)i) return 0;

            location = (char*)tca->At(i);

            return location;

         } else if (fParent) {

            //tcaloc = ((unsigned char*)fParent->GetStart());
            location = (char*)fParent->GetClaStart(i);

         } else {

            void *tcaloc;
            tcaloc = fWhere;
            TClonesArray *tca;
            tca = (TClonesArray*)tcaloc;

            if (tca->GetLast()<(Int_t)i) return 0;

            location = (char*)tca->At(i);
         }

         if (location) location += fOffset;
         else return 0;

         if (IsaPointer()) {
            return *(void**)(location);
         } else {
            return location;
         }

      }

      virtual void *GetStlStart(UInt_t i=0) {
         // return the address of the start of the object being proxied. Assumes
         // that Setup() has been called.  Assumes the object containing this data
         // member is held in TClonesArray.

         char *location=0;

         if (fCollection) {

            if (fCollection->Size()<i) return 0;

            location = (char*)fCollection->At(i);

            // return location;

         } else if (fParent) {

            //tcaloc = ((unsigned char*)fParent->GetStart());
            location = (char*)fParent->GetStlStart(i);

         } else {

            R__ASSERT(0);
            //void *tcaloc;
            //tcaloc = fWhere;
            //TClonesArray *tca;
            //tca = (TClonesArray*)tcaloc;

            //if (tca->GetLast()<i) return 0;

            //location = (char*)tca->At(i);
         }

         if (location) location += fOffset;
         else return 0;

         if (IsaPointer()) {
            return *(void**)(location);
         } else {
            return location;
         }

      }
   };

   //____________________________________________________________________________________________
   // Concrete Implementation of the branch proxy around the data members which are array of char
   class TArrayCharProxy : public TBranchProxy {
   public:
      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(unsigned char*)GetStart() << endl;
      }

      TArrayCharProxy() : TBranchProxy() {}
      TArrayCharProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TArrayCharProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TArrayCharProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TArrayCharProxy() {};

      unsigned char At(UInt_t i) {
         static unsigned char default_val;
         if (!Read()) return default_val;
         // should add out-of bound test
         unsigned char* str = (unsigned char*)GetStart();
         return str[i];
      }

      unsigned char operator [](Int_t i) {
         return At(i);
      }

      unsigned char operator [](UInt_t i) {
         return At(i);
      }

      const char* c_str() {
         if (!Read()) return "";
         return (const char*)GetStart();
      }

      operator std::string() {
         if (!Read()) return "";
         return std::string((const char*)GetStart());
      }

   };

   //_______________________________________________________
   // Base class for the proxy around object in TClonesArray.
   class TClaProxy : public TBranchProxy {
   public:
      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) {
            if (IsaPointer()) {
               cout << "location " << *(TClonesArray**)fWhere << endl;
            } else {
               cout << "location " << fWhere << endl;
            }
         }
      }

      TClaProxy() : TBranchProxy() {}
      TClaProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TClaProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TClaProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TClaProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TClaProxy() {};

      const TClonesArray* GetPtr() {
         if (!Read()) return 0;
         return (TClonesArray*)GetStart();
      }

      Int_t GetEntries() {
         if (!ReadEntries()) return 0;
         TClonesArray *arr = (TClonesArray*)GetStart();
         if (arr) return arr->GetEntries();
         return 0;
      }

      const TClonesArray* operator->() { return GetPtr(); }

   };

   //_______________________________________________
   // Base class for the proxy around STL containers.
   class TStlProxy : public TBranchProxy {
   public:
      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) {
            if (IsaPointer()) {
               cout << "location " << *(TClonesArray**)fWhere << endl;
            } else {
               cout << "location " << fWhere << endl;
            }
         }
      }

      TStlProxy() : TBranchProxy() {}
      TStlProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TStlProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TStlProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TStlProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TStlProxy() {};

      const TVirtualCollectionProxy* GetPtr() {
         if (!Read()) return 0;
         return GetCollection();;
      }

      Int_t GetEntries() {
         if (!ReadEntries()) return 0;
         return GetPtr()->Size();
      }

      const TVirtualCollectionProxy* operator->() { return GetPtr(); }

   };

   //______________________________________
   // Template of the proxy around objects.
   template <class T>
   class TImpProxy : public TBranchProxy {
   public:
      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(T*)GetStart() << endl;
      }

      TImpProxy() : TBranchProxy() {};
      TImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TImpProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TImpProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) : 
         TBranchProxy(director,parent, name, top, mid) {};
      ~TImpProxy() {};

      operator T() {
         if (!Read()) return 0;
         return *(T*)GetStart();
      }

      // Make sure that the copy methods are really private
#ifdef private
#undef private
#define private_was_replaced
#endif
      // For now explicitly disable copying into the value (i.e. the proxy is read-only).
   private:
      TImpProxy(T);
      TImpProxy &operator=(T);
#ifdef private_was_replaced
#define private public
#endif

   };

   //____________________________________________
   // Helper template to be able to determine and
   // use array dimentsions.
   template <class T, int d = 0> struct TArrayType {
      typedef T type_t;
      typedef T array_t[d];
   }; 
   //____________________________________________
   // Helper class for proxy around multi dimension array
   template <class T> struct TArrayType<T,0> {
      typedef T type_t;
      typedef T array_t;
   };
   //____________________________________________
   // Helper class for proxy around multi dimension array
   template <class T, int d> struct TMultiArrayType {
      typedef typename T::type_t type_t;
      typedef typename T::array_t array_t[d];
   };

   //____________________________________________
   // Template for concrete implementation of proxy around array of T
   template <class T>
   class TArrayProxy : public TBranchProxy {
   public:
      TArrayProxy() : TBranchProxy() {}
      TArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TArrayProxy() {};

      typedef typename T::array_t array_t;
      typedef typename T::type_t type_t;

      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << GetWhere() << endl;
         if (GetWhere()) cout << "value? " << *(type_t*)GetWhere() << endl;
      }

      const array_t &At(UInt_t i) {
         static array_t default_val;
         if (!Read()) return default_val;
         // should add out-of bound test
         array_t *arr = 0;
         arr = (array_t*)((type_t*)(GetStart()));
         if (arr) return arr[i];
         else return default_val;
      }

      const array_t &operator [](Int_t i) { return At(i); }
      const array_t &operator [](UInt_t i) { return At(i); }
   };

   //_____________________________________________________________________________________
   // Template of the Concrete Implementation of the branch proxy around TClonesArray of T
   template <class T>
   class TClaImpProxy : public TBranchProxy {
   public:

      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(T*)GetStart() << endl;
      }

      TClaImpProxy() : TBranchProxy() {};
      TClaImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TClaImpProxy(TBranchProxyDirector *director,  const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TClaImpProxy(TBranchProxyDirector *director,  const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TClaImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) : 
         TBranchProxy(director,parent, name, top, mid) {};
      ~TClaImpProxy() {};

      const T& At(UInt_t i) {
         static T default_val;
         if (!Read()) return default_val;
         if (fWhere==0) return default_val;

         T *temp = (T*)GetClaStart(i);

         if (temp) return *temp;
         else return default_val;

      }

      const T& operator [](Int_t i) { return At(i); }
      const T& operator [](UInt_t i) { return At(i); }

      // Make sure that the copy methods are really private
#ifdef private
#undef private
#define private_was_replaced
#endif
      // For now explicitly disable copying into the value (i.e. the proxy is read-only).
   private:
      TClaImpProxy(T);
      TClaImpProxy &operator=(T);
#ifdef private_was_replaced
#define private public
#endif

   };

   //_________________________________________________________________________________________
   // Template of the Concrete Implementation of the branch proxy around an stl container of T
   template <class T>
   class TStlImpProxy : public TBranchProxy {
   public:

      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(T*)GetStart() << endl;
      }

      TStlImpProxy() : TBranchProxy() {};
      TStlImpProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TStlImpProxy(TBranchProxyDirector *director,  const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TStlImpProxy(TBranchProxyDirector *director,  const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TStlImpProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) : 
         TBranchProxy(director,parent, name, top, mid) {};
      ~TStlImpProxy() {};

      const T& At(UInt_t i) {
         static T default_val;
         if (!Read()) return default_val;
         if (fWhere==0) return default_val;

         T *temp = (T*)GetStlStart(i);

         if (temp) return *temp;
         else return default_val;
      }

      const T& operator [](Int_t i) { return At(i); }
      const T& operator [](UInt_t i) { return At(i); }

      // Make sure that the copy methods are really private
#ifdef private
#undef private
#define private_was_replaced
#endif
      // For now explicitly disable copying into the value (i.e. the proxy is read-only).
   private:
      TStlImpProxy(T);
      TStlImpProxy &operator=(T);
#ifdef private_was_replaced
#define private public
#endif

   };

   //_________________________________________________________________________________________________
   // Template of the Concrete Implementation of the branch proxy around an TClonesArray of array of T
   template <class T>
   class TClaArrayProxy : public TBranchProxy {
   public:
      typedef typename T::array_t array_t;
      typedef typename T::type_t type_t;

      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(type_t*)GetStart() << endl;
      }

      TClaArrayProxy() : TBranchProxy() {}
      TClaArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TClaArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TClaArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TClaArrayProxy() {};

      /* const */  array_t *At(UInt_t i) {
         static array_t default_val;
         if (!Read()) return &default_val;
         if (fWhere==0) return &default_val;

         return (array_t*)GetClaStart(i);
      }

      /* const */ array_t *operator [](Int_t i) { return At(i); }
      /* const */ array_t *operator [](UInt_t i) { return At(i); }
   };

   
   //__________________________________________________________________________________________________
   // Template of the Concrete Implementation of the branch proxy around an stl container of array of T
   template <class T>
   class TStlArrayProxy : public TBranchProxy {
   public:
      typedef typename T::array_t array_t;
      typedef typename T::type_t type_t;

      void Print() {
         TBranchProxy::Print();
         cout << "fWhere " << fWhere << endl;
         if (fWhere) cout << "value? " << *(type_t*)GetStart() << endl;
      }

      TStlArrayProxy() : TBranchProxy() {}
      TStlArrayProxy(TBranchProxyDirector *director, const char *name) : TBranchProxy(director,name) {};
      TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name) :
         TBranchProxy(director,top,name) {};
      TStlArrayProxy(TBranchProxyDirector *director, const char *top, const char *name, const char *data) :
         TBranchProxy(director,top,name,data) {};
      TStlArrayProxy(TBranchProxyDirector *director, TBranchProxy *parent, const char *name, const char* top = 0, const char* mid = 0) :
         TBranchProxy(director,parent, name, top, mid) {};
      ~TStlArrayProxy() {};

      /* const */  array_t *At(UInt_t i) {
         static array_t default_val;
         if (!Read()) return &default_val;
         if (fWhere==0) return &default_val;

         return (array_t*)GetStlStart(i);
      }

      /* const */ array_t *operator [](Int_t i) { return At(i); }
      /* const */ array_t *operator [](UInt_t i) { return At(i); }
   };

   //TImpProxy<TObject> d;
   typedef TImpProxy<Double_t>   TDoubleProxy;   // Concrete Implementation of the branch proxy around the data members which are double
   typedef TImpProxy<Double32_t> TDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are double32
   typedef TImpProxy<Float_t>    TFloatProxy;    // Concrete Implementation of the branch proxy around the data members which are float
   typedef TImpProxy<Float16_t>  TFloat16Proxy;  // Concrete Implementation of the branch proxy around the data members which are float16
   typedef TImpProxy<UInt_t>     TUIntProxy;     // Concrete Implementation of the branch proxy around the data members which are unsigned int
   typedef TImpProxy<ULong_t>    TULongProxy;    // Concrete Implementation of the branch proxy around the data members which are unsigned long
   typedef TImpProxy<ULong64_t>  TULong64Proxy;  // Concrete Implementation of the branch proxy around the data members which are unsigned long long
   typedef TImpProxy<UShort_t>   TUShortProxy;   // Concrete Implementation of the branch proxy around the data members which are unsigned short
   typedef TImpProxy<UChar_t>    TUCharProxy;    // Concrete Implementation of the branch proxy around the data members which are unsigned char
   typedef TImpProxy<Int_t>      TIntProxy;      // Concrete Implementation of the branch proxy around the data members which are int
   typedef TImpProxy<Long_t>     TLongProxy;     // Concrete Implementation of the branch proxy around the data members which are long
   typedef TImpProxy<Long64_t>   TLong64Proxy;   // Concrete Implementation of the branch proxy around the data members which are long long
   typedef TImpProxy<Short_t>    TShortProxy;    // Concrete Implementation of the branch proxy around the data members which are short
   typedef TImpProxy<Char_t>     TCharProxy;     // Concrete Implementation of the branch proxy around the data members which are char
   typedef TImpProxy<Bool_t>     TBoolProxy;     // Concrete Implementation of the branch proxy around the data members which are bool

   typedef TArrayProxy<TArrayType<Double_t> >   TArrayDoubleProxy;   // Concrete Implementation of the branch proxy around the data members which are array of double
   typedef TArrayProxy<TArrayType<Double32_t> > TArrayDouble32Proxy; // Concrete Implementation of the branch proxy around the data members which are array of double32
   typedef TArrayProxy<TArrayType<Float_t> >    TArrayFloatProxy;    // Concrete Implementation of the branch proxy around the data members which are array of float
   typedef TArrayProxy<TArrayType<Float16_t> >  TArrayFloat16Proxy;  // Concrete Implementation of the branch proxy around the data members which are array of float16
   typedef TArrayProxy<TArrayType<UInt_t> >     TArrayUIntProxy;     // Concrete Implementation of the branch proxy around the data members which are array of unsigned int
   typedef TArrayProxy<TArrayType<ULong_t> >    TArrayULongProxy;    // Concrete Implementation of the branch proxy around the data members which are array of unsigned long
   typedef TArrayProxy<TArrayType<ULong64_t> >  TArrayULong64Proxy;  // Concrete Implementation of the branch proxy around the data members which are array of unsigned long long
   typedef TArrayProxy<TArrayType<UShort_t> >   TArrayUShortProxy;   // Concrete Implementation of the branch proxy around the data members which are array of unsigned short
   typedef TArrayProxy<TArrayType<UChar_t> >    TArrayUCharProxy;    // Concrete Implementation of the branch proxy around the data members which are array of unsigned char
   typedef TArrayProxy<TArrayType<Int_t> >      TArrayIntProxy;      // Concrete Implementation of the branch proxy around the data members which are array of int
   typedef TArrayProxy<TArrayType<Long_t> >     TArrayLongProxy;     // Concrete Implementation of the branch proxy around the data members which are array of long
   typedef TArrayProxy<TArrayType<Long64_t> >   TArrayLong64Proxy;   // Concrete Implementation of the branch proxy around the data members which are array of long long
   typedef TArrayProxy<TArrayType<UShort_t> >   TArrayShortProxy;    // Concrete Implementation of the branch proxy around the data members which are array of short
   //specialized ! typedef TArrayProxy<TArrayType<Char_t> >  TArrayCharProxy; // Concrete Implementation of the branch proxy around the data members which are array of char
   typedef TArrayProxy<TArrayType<Bool_t> >     TArrayBoolProxy;     // Concrete Implementation of the branch proxy around the data members which are array of bool

   typedef TClaImpProxy<Double_t>   TClaDoubleProxy;   // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double
   typedef TClaImpProxy<Double32_t> TClaDouble32Proxy; // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are double32
   typedef TClaImpProxy<Float_t>    TClaFloatProxy;    // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float
   typedef TClaImpProxy<Float16_t>  TClaFloat16Proxy;  // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are float16
   typedef TClaImpProxy<UInt_t>     TClaUIntProxy;     // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned int
   typedef TClaImpProxy<ULong_t>    TClaULongProxy;    // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long
   typedef TClaImpProxy<ULong64_t>  TClaULong64Proxy;  // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned long long
   typedef TClaImpProxy<UShort_t>   TClaUShortProxy;   // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned short
   typedef TClaImpProxy<UChar_t>    TClaUCharProxy;    // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are unsigned char
   typedef TClaImpProxy<Int_t>      TClaIntProxy;      // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are int
   typedef TClaImpProxy<Long_t>     TClaLongProxy;     // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long
   typedef TClaImpProxy<Long64_t>   TClaLong64Proxy;   // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are long long
   typedef TClaImpProxy<Short_t>    TClaShortProxy;    // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are short
   typedef TClaImpProxy<Char_t>     TClaCharProxy;     // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are char
   typedef TClaImpProxy<Bool_t>     TClaBoolProxy;     // Concrete Implementation of the branch proxy around the data members of object in TClonesArray which are bool

   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   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
   //specialized ! typedef TClaArrayProxy<TArrayType<Char_t> >  TClaArrayCharProxy;

   typedef TStlImpProxy<Double_t>   TStlDoubleProxy;   // Concrete Implementation of the branch proxy around an stl container of double
   typedef TStlImpProxy<Double32_t> TStlDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
   typedef TStlImpProxy<Float_t>    TStlFloatProxy;    // Concrete Implementation of the branch proxy around an stl container of float
   typedef TStlImpProxy<Float16_t>  TStlFloat16Proxy;  // Concrete Implementation of the branch proxy around an stl container of float16_t
   typedef TStlImpProxy<UInt_t>     TStlUIntProxy;     // Concrete Implementation of the branch proxy around an stl container of unsigned int
   typedef TStlImpProxy<ULong_t>    TStlULongProxy;    // Concrete Implementation of the branch proxy around an stl container of unsigned long
   typedef TStlImpProxy<ULong64_t>  TStlULong64Proxy;  // Concrete Implementation of the branch proxy around an stl container of unsigned long long
   typedef TStlImpProxy<UShort_t>   TStlUShortProxy;   // Concrete Implementation of the branch proxy around an stl container of unsigned short
   typedef TStlImpProxy<UChar_t>    TStlUCharProxy;    // Concrete Implementation of the branch proxy around an stl container of unsigned char
   typedef TStlImpProxy<Int_t>      TStlIntProxy;      // Concrete Implementation of the branch proxy around an stl container of int
   typedef TStlImpProxy<Long_t>     TStlLongProxy;     // Concrete Implementation of the branch proxy around an stl container of long
   typedef TStlImpProxy<Long64_t>   TStlLong64Proxy;   // Concrete Implementation of the branch proxy around an stl container of long long
   typedef TStlImpProxy<Short_t>    TStlShortProxy;    // Concrete Implementation of the branch proxy around an stl container of short
   typedef TStlImpProxy<Char_t>     TStlCharProxy;     // Concrete Implementation of the branch proxy around an stl container of char
   typedef TStlImpProxy<Bool_t>     TStlBoolProxy;     // Concrete Implementation of the branch proxy around an stl container of bool

   typedef TStlArrayProxy<TArrayType<Double_t> >    TStlArrayDoubleProxy;   // Concrete Implementation of the branch proxy around an stl container of double
   typedef TStlArrayProxy<TArrayType<Double32_t> >  TStlArrayDouble32Proxy; // Concrete Implementation of the branch proxy around an stl container of double32
   typedef TStlArrayProxy<TArrayType<Float_t> >     TStlArrayFloatProxy;    // Concrete Implementation of the branch proxy around an stl container of float
   typedef TStlArrayProxy<TArrayType<Float16_t> >   TStlArrayFloat16Proxy;  // Concrete Implementation of the branch proxy around an stl container of float16_t
   typedef TStlArrayProxy<TArrayType<UInt_t> >      TStlArrayUIntProxy;     // Concrete Implementation of the branch proxy around an stl container of unsigned int
   typedef TStlArrayProxy<TArrayType<ULong_t> >     TStlArrayULongProxy;    // Concrete Implementation of the branch proxy around an stl container of usigned long
   typedef TStlArrayProxy<TArrayType<ULong64_t> >   TStlArrayULong64Proxy;  // Concrete Implementation of the branch proxy around an stl contained of unsigned long long
   typedef TStlArrayProxy<TArrayType<UShort_t> >    TStlArrayUShortProxy;   // Concrete Implementation of the branch proxy around an stl container of unisgned short
   typedef TStlArrayProxy<TArrayType<UChar_t> >     TStlArrayUCharProxy;    // Concrete Implementation of the branch proxy around an stl container of unsingned char
   typedef TStlArrayProxy<TArrayType<Int_t> >       TStlArrayIntProxy;      // Concrete Implementation of the branch proxy around an stl container of int
   typedef TStlArrayProxy<TArrayType<Long_t> >      TStlArrayLongProxy;     // Concrete Implementation of the branch proxy around an stl container of long
   typedef TStlArrayProxy<TArrayType<Long64_t> >    TStlArrayLong64Proxy;   // Concrete Implementation of the branch proxy around an stl container of long long
   typedef TStlArrayProxy<TArrayType<UShort_t> >    TStlArrayShortProxy;    // Concrete Implementation of the branch proxy around an stl container of UShort_t
   typedef TStlArrayProxy<TArrayType<Char_t> >      TStlArrayCharProxy;     // Concrete Implementation of the branch proxy around an stl container of char
   typedef TStlArrayProxy<TArrayType<Bool_t> >      TStlArrayBoolProxy;     // Concrete Implementation of the branch proxy around an stl container of bool

} // namespace ROOT

#endif

 TBranchProxy.h:1
 TBranchProxy.h:2
 TBranchProxy.h:3
 TBranchProxy.h:4
 TBranchProxy.h:5
 TBranchProxy.h:6
 TBranchProxy.h:7
 TBranchProxy.h:8
 TBranchProxy.h:9
 TBranchProxy.h:10
 TBranchProxy.h:11
 TBranchProxy.h:12
 TBranchProxy.h:13
 TBranchProxy.h:14
 TBranchProxy.h:15
 TBranchProxy.h:16
 TBranchProxy.h:17
 TBranchProxy.h:18
 TBranchProxy.h:19
 TBranchProxy.h:20
 TBranchProxy.h:21
 TBranchProxy.h:22
 TBranchProxy.h:23
 TBranchProxy.h:24
 TBranchProxy.h:25
 TBranchProxy.h:26
 TBranchProxy.h:27
 TBranchProxy.h:28
 TBranchProxy.h:29
 TBranchProxy.h:30
 TBranchProxy.h:31
 TBranchProxy.h:32
 TBranchProxy.h:33
 TBranchProxy.h:34
 TBranchProxy.h:35
 TBranchProxy.h:36
 TBranchProxy.h:37
 TBranchProxy.h:38
 TBranchProxy.h:39
 TBranchProxy.h:40
 TBranchProxy.h:41
 TBranchProxy.h:42
 TBranchProxy.h:43
 TBranchProxy.h:44
 TBranchProxy.h:45
 TBranchProxy.h:46
 TBranchProxy.h:47
 TBranchProxy.h:48
 TBranchProxy.h:49
 TBranchProxy.h:50
 TBranchProxy.h:51
 TBranchProxy.h:52
 TBranchProxy.h:53
 TBranchProxy.h:54
 TBranchProxy.h:55
 TBranchProxy.h:56
 TBranchProxy.h:57
 TBranchProxy.h:58
 TBranchProxy.h:59
 TBranchProxy.h:60
 TBranchProxy.h:61
 TBranchProxy.h:62
 TBranchProxy.h:63
 TBranchProxy.h:64
 TBranchProxy.h:65
 TBranchProxy.h:66
 TBranchProxy.h:67
 TBranchProxy.h:68
 TBranchProxy.h:69
 TBranchProxy.h:70
 TBranchProxy.h:71
 TBranchProxy.h:72
 TBranchProxy.h:73
 TBranchProxy.h:74
 TBranchProxy.h:75
 TBranchProxy.h:76
 TBranchProxy.h:77
 TBranchProxy.h:78
 TBranchProxy.h:79
 TBranchProxy.h:80
 TBranchProxy.h:81
 TBranchProxy.h:82
 TBranchProxy.h:83
 TBranchProxy.h:84
 TBranchProxy.h:85
 TBranchProxy.h:86
 TBranchProxy.h:87
 TBranchProxy.h:88
 TBranchProxy.h:89
 TBranchProxy.h:90
 TBranchProxy.h:91
 TBranchProxy.h:92
 TBranchProxy.h:93
 TBranchProxy.h:94
 TBranchProxy.h:95
 TBranchProxy.h:96
 TBranchProxy.h:97
 TBranchProxy.h:98
 TBranchProxy.h:99
 TBranchProxy.h:100
 TBranchProxy.h:101
 TBranchProxy.h:102
 TBranchProxy.h:103
 TBranchProxy.h:104
 TBranchProxy.h:105
 TBranchProxy.h:106
 TBranchProxy.h:107
 TBranchProxy.h:108
 TBranchProxy.h:109
 TBranchProxy.h:110
 TBranchProxy.h:111
 TBranchProxy.h:112
 TBranchProxy.h:113
 TBranchProxy.h:114
 TBranchProxy.h:115
 TBranchProxy.h:116
 TBranchProxy.h:117
 TBranchProxy.h:118
 TBranchProxy.h:119
 TBranchProxy.h:120
 TBranchProxy.h:121
 TBranchProxy.h:122
 TBranchProxy.h:123
 TBranchProxy.h:124
 TBranchProxy.h:125
 TBranchProxy.h:126
 TBranchProxy.h:127
 TBranchProxy.h:128
 TBranchProxy.h:129
 TBranchProxy.h:130
 TBranchProxy.h:131
 TBranchProxy.h:132
 TBranchProxy.h:133
 TBranchProxy.h:134
 TBranchProxy.h:135
 TBranchProxy.h:136
 TBranchProxy.h:137
 TBranchProxy.h:138
 TBranchProxy.h:139
 TBranchProxy.h:140
 TBranchProxy.h:141
 TBranchProxy.h:142
 TBranchProxy.h:143
 TBranchProxy.h:144
 TBranchProxy.h:145
 TBranchProxy.h:146
 TBranchProxy.h:147
 TBranchProxy.h:148
 TBranchProxy.h:149
 TBranchProxy.h:150
 TBranchProxy.h:151
 TBranchProxy.h:152
 TBranchProxy.h:153
 TBranchProxy.h:154
 TBranchProxy.h:155
 TBranchProxy.h:156
 TBranchProxy.h:157
 TBranchProxy.h:158
 TBranchProxy.h:159
 TBranchProxy.h:160
 TBranchProxy.h:161
 TBranchProxy.h:162
 TBranchProxy.h:163
 TBranchProxy.h:164
 TBranchProxy.h:165
 TBranchProxy.h:166
 TBranchProxy.h:167
 TBranchProxy.h:168
 TBranchProxy.h:169
 TBranchProxy.h:170
 TBranchProxy.h:171
 TBranchProxy.h:172
 TBranchProxy.h:173
 TBranchProxy.h:174
 TBranchProxy.h:175
 TBranchProxy.h:176
 TBranchProxy.h:177
 TBranchProxy.h:178
 TBranchProxy.h:179
 TBranchProxy.h:180
 TBranchProxy.h:181
 TBranchProxy.h:182
 TBranchProxy.h:183
 TBranchProxy.h:184
 TBranchProxy.h:185
 TBranchProxy.h:186
 TBranchProxy.h:187
 TBranchProxy.h:188
 TBranchProxy.h:189
 TBranchProxy.h:190
 TBranchProxy.h:191
 TBranchProxy.h:192
 TBranchProxy.h:193
 TBranchProxy.h:194
 TBranchProxy.h:195
 TBranchProxy.h:196
 TBranchProxy.h:197
 TBranchProxy.h:198
 TBranchProxy.h:199
 TBranchProxy.h:200
 TBranchProxy.h:201
 TBranchProxy.h:202
 TBranchProxy.h:203
 TBranchProxy.h:204
 TBranchProxy.h:205
 TBranchProxy.h:206
 TBranchProxy.h:207
 TBranchProxy.h:208
 TBranchProxy.h:209
 TBranchProxy.h:210
 TBranchProxy.h:211
 TBranchProxy.h:212
 TBranchProxy.h:213
 TBranchProxy.h:214
 TBranchProxy.h:215
 TBranchProxy.h:216
 TBranchProxy.h:217
 TBranchProxy.h:218
 TBranchProxy.h:219
 TBranchProxy.h:220
 TBranchProxy.h:221
 TBranchProxy.h:222
 TBranchProxy.h:223
 TBranchProxy.h:224
 TBranchProxy.h:225
 TBranchProxy.h:226
 TBranchProxy.h:227
 TBranchProxy.h:228
 TBranchProxy.h:229
 TBranchProxy.h:230
 TBranchProxy.h:231
 TBranchProxy.h:232
 TBranchProxy.h:233
 TBranchProxy.h:234
 TBranchProxy.h:235
 TBranchProxy.h:236
 TBranchProxy.h:237
 TBranchProxy.h:238
 TBranchProxy.h:239
 TBranchProxy.h:240
 TBranchProxy.h:241
 TBranchProxy.h:242
 TBranchProxy.h:243
 TBranchProxy.h:244
 TBranchProxy.h:245
 TBranchProxy.h:246
 TBranchProxy.h:247
 TBranchProxy.h:248
 TBranchProxy.h:249
 TBranchProxy.h:250
 TBranchProxy.h:251
 TBranchProxy.h:252
 TBranchProxy.h:253
 TBranchProxy.h:254
 TBranchProxy.h:255
 TBranchProxy.h:256
 TBranchProxy.h:257
 TBranchProxy.h:258
 TBranchProxy.h:259
 TBranchProxy.h:260
 TBranchProxy.h:261
 TBranchProxy.h:262
 TBranchProxy.h:263
 TBranchProxy.h:264
 TBranchProxy.h:265
 TBranchProxy.h:266
 TBranchProxy.h:267
 TBranchProxy.h:268
 TBranchProxy.h:269
 TBranchProxy.h:270
 TBranchProxy.h:271
 TBranchProxy.h:272
 TBranchProxy.h:273
 TBranchProxy.h:274
 TBranchProxy.h:275
 TBranchProxy.h:276
 TBranchProxy.h:277
 TBranchProxy.h:278
 TBranchProxy.h:279
 TBranchProxy.h:280
 TBranchProxy.h:281
 TBranchProxy.h:282
 TBranchProxy.h:283
 TBranchProxy.h:284
 TBranchProxy.h:285
 TBranchProxy.h:286
 TBranchProxy.h:287
 TBranchProxy.h:288
 TBranchProxy.h:289
 TBranchProxy.h:290
 TBranchProxy.h:291
 TBranchProxy.h:292
 TBranchProxy.h:293
 TBranchProxy.h:294
 TBranchProxy.h:295
 TBranchProxy.h:296
 TBranchProxy.h:297
 TBranchProxy.h:298
 TBranchProxy.h:299
 TBranchProxy.h:300
 TBranchProxy.h:301
 TBranchProxy.h:302
 TBranchProxy.h:303
 TBranchProxy.h:304
 TBranchProxy.h:305
 TBranchProxy.h:306
 TBranchProxy.h:307
 TBranchProxy.h:308
 TBranchProxy.h:309
 TBranchProxy.h:310
 TBranchProxy.h:311
 TBranchProxy.h:312
 TBranchProxy.h:313
 TBranchProxy.h:314
 TBranchProxy.h:315
 TBranchProxy.h:316
 TBranchProxy.h:317
 TBranchProxy.h:318
 TBranchProxy.h:319
 TBranchProxy.h:320
 TBranchProxy.h:321
 TBranchProxy.h:322
 TBranchProxy.h:323
 TBranchProxy.h:324
 TBranchProxy.h:325
 TBranchProxy.h:326
 TBranchProxy.h:327
 TBranchProxy.h:328
 TBranchProxy.h:329
 TBranchProxy.h:330
 TBranchProxy.h:331
 TBranchProxy.h:332
 TBranchProxy.h:333
 TBranchProxy.h:334
 TBranchProxy.h:335
 TBranchProxy.h:336
 TBranchProxy.h:337
 TBranchProxy.h:338
 TBranchProxy.h:339
 TBranchProxy.h:340
 TBranchProxy.h:341
 TBranchProxy.h:342
 TBranchProxy.h:343
 TBranchProxy.h:344
 TBranchProxy.h:345
 TBranchProxy.h:346
 TBranchProxy.h:347
 TBranchProxy.h:348
 TBranchProxy.h:349
 TBranchProxy.h:350
 TBranchProxy.h:351
 TBranchProxy.h:352
 TBranchProxy.h:353
 TBranchProxy.h:354
 TBranchProxy.h:355
 TBranchProxy.h:356
 TBranchProxy.h:357
 TBranchProxy.h:358
 TBranchProxy.h:359
 TBranchProxy.h:360
 TBranchProxy.h:361
 TBranchProxy.h:362
 TBranchProxy.h:363
 TBranchProxy.h:364
 TBranchProxy.h:365
 TBranchProxy.h:366
 TBranchProxy.h:367
 TBranchProxy.h:368
 TBranchProxy.h:369
 TBranchProxy.h:370
 TBranchProxy.h:371
 TBranchProxy.h:372
 TBranchProxy.h:373
 TBranchProxy.h:374
 TBranchProxy.h:375
 TBranchProxy.h:376
 TBranchProxy.h:377
 TBranchProxy.h:378
 TBranchProxy.h:379
 TBranchProxy.h:380
 TBranchProxy.h:381
 TBranchProxy.h:382
 TBranchProxy.h:383
 TBranchProxy.h:384
 TBranchProxy.h:385
 TBranchProxy.h:386
 TBranchProxy.h:387
 TBranchProxy.h:388
 TBranchProxy.h:389
 TBranchProxy.h:390
 TBranchProxy.h:391
 TBranchProxy.h:392
 TBranchProxy.h:393
 TBranchProxy.h:394
 TBranchProxy.h:395
 TBranchProxy.h:396
 TBranchProxy.h:397
 TBranchProxy.h:398
 TBranchProxy.h:399
 TBranchProxy.h:400
 TBranchProxy.h:401
 TBranchProxy.h:402
 TBranchProxy.h:403
 TBranchProxy.h:404
 TBranchProxy.h:405
 TBranchProxy.h:406
 TBranchProxy.h:407
 TBranchProxy.h:408
 TBranchProxy.h:409
 TBranchProxy.h:410
 TBranchProxy.h:411
 TBranchProxy.h:412
 TBranchProxy.h:413
 TBranchProxy.h:414
 TBranchProxy.h:415
 TBranchProxy.h:416
 TBranchProxy.h:417
 TBranchProxy.h:418
 TBranchProxy.h:419
 TBranchProxy.h:420
 TBranchProxy.h:421
 TBranchProxy.h:422
 TBranchProxy.h:423
 TBranchProxy.h:424
 TBranchProxy.h:425
 TBranchProxy.h:426
 TBranchProxy.h:427
 TBranchProxy.h:428
 TBranchProxy.h:429
 TBranchProxy.h:430
 TBranchProxy.h:431
 TBranchProxy.h:432
 TBranchProxy.h:433
 TBranchProxy.h:434
 TBranchProxy.h:435
 TBranchProxy.h:436
 TBranchProxy.h:437
 TBranchProxy.h:438
 TBranchProxy.h:439
 TBranchProxy.h:440
 TBranchProxy.h:441
 TBranchProxy.h:442
 TBranchProxy.h:443
 TBranchProxy.h:444
 TBranchProxy.h:445
 TBranchProxy.h:446
 TBranchProxy.h:447
 TBranchProxy.h:448
 TBranchProxy.h:449
 TBranchProxy.h:450
 TBranchProxy.h:451
 TBranchProxy.h:452
 TBranchProxy.h:453
 TBranchProxy.h:454
 TBranchProxy.h:455
 TBranchProxy.h:456
 TBranchProxy.h:457
 TBranchProxy.h:458
 TBranchProxy.h:459
 TBranchProxy.h:460
 TBranchProxy.h:461
 TBranchProxy.h:462
 TBranchProxy.h:463
 TBranchProxy.h:464
 TBranchProxy.h:465
 TBranchProxy.h:466
 TBranchProxy.h:467
 TBranchProxy.h:468
 TBranchProxy.h:469
 TBranchProxy.h:470
 TBranchProxy.h:471
 TBranchProxy.h:472
 TBranchProxy.h:473
 TBranchProxy.h:474
 TBranchProxy.h:475
 TBranchProxy.h:476
 TBranchProxy.h:477
 TBranchProxy.h:478
 TBranchProxy.h:479
 TBranchProxy.h:480
 TBranchProxy.h:481
 TBranchProxy.h:482
 TBranchProxy.h:483
 TBranchProxy.h:484
 TBranchProxy.h:485
 TBranchProxy.h:486
 TBranchProxy.h:487
 TBranchProxy.h:488
 TBranchProxy.h:489
 TBranchProxy.h:490
 TBranchProxy.h:491
 TBranchProxy.h:492
 TBranchProxy.h:493
 TBranchProxy.h:494
 TBranchProxy.h:495
 TBranchProxy.h:496
 TBranchProxy.h:497
 TBranchProxy.h:498
 TBranchProxy.h:499
 TBranchProxy.h:500
 TBranchProxy.h:501
 TBranchProxy.h:502
 TBranchProxy.h:503
 TBranchProxy.h:504
 TBranchProxy.h:505
 TBranchProxy.h:506
 TBranchProxy.h:507
 TBranchProxy.h:508
 TBranchProxy.h:509
 TBranchProxy.h:510
 TBranchProxy.h:511
 TBranchProxy.h:512
 TBranchProxy.h:513
 TBranchProxy.h:514
 TBranchProxy.h:515
 TBranchProxy.h:516
 TBranchProxy.h:517
 TBranchProxy.h:518
 TBranchProxy.h:519
 TBranchProxy.h:520
 TBranchProxy.h:521
 TBranchProxy.h:522
 TBranchProxy.h:523
 TBranchProxy.h:524
 TBranchProxy.h:525
 TBranchProxy.h:526
 TBranchProxy.h:527
 TBranchProxy.h:528
 TBranchProxy.h:529
 TBranchProxy.h:530
 TBranchProxy.h:531
 TBranchProxy.h:532
 TBranchProxy.h:533
 TBranchProxy.h:534
 TBranchProxy.h:535
 TBranchProxy.h:536
 TBranchProxy.h:537
 TBranchProxy.h:538
 TBranchProxy.h:539
 TBranchProxy.h:540
 TBranchProxy.h:541
 TBranchProxy.h:542
 TBranchProxy.h:543
 TBranchProxy.h:544
 TBranchProxy.h:545
 TBranchProxy.h:546
 TBranchProxy.h:547
 TBranchProxy.h:548
 TBranchProxy.h:549
 TBranchProxy.h:550
 TBranchProxy.h:551
 TBranchProxy.h:552
 TBranchProxy.h:553
 TBranchProxy.h:554
 TBranchProxy.h:555
 TBranchProxy.h:556
 TBranchProxy.h:557
 TBranchProxy.h:558
 TBranchProxy.h:559
 TBranchProxy.h:560
 TBranchProxy.h:561
 TBranchProxy.h:562
 TBranchProxy.h:563
 TBranchProxy.h:564
 TBranchProxy.h:565
 TBranchProxy.h:566
 TBranchProxy.h:567
 TBranchProxy.h:568
 TBranchProxy.h:569
 TBranchProxy.h:570
 TBranchProxy.h:571
 TBranchProxy.h:572
 TBranchProxy.h:573
 TBranchProxy.h:574
 TBranchProxy.h:575
 TBranchProxy.h:576
 TBranchProxy.h:577
 TBranchProxy.h:578
 TBranchProxy.h:579
 TBranchProxy.h:580
 TBranchProxy.h:581
 TBranchProxy.h:582
 TBranchProxy.h:583
 TBranchProxy.h:584
 TBranchProxy.h:585
 TBranchProxy.h:586
 TBranchProxy.h:587
 TBranchProxy.h:588
 TBranchProxy.h:589
 TBranchProxy.h:590
 TBranchProxy.h:591
 TBranchProxy.h:592
 TBranchProxy.h:593
 TBranchProxy.h:594
 TBranchProxy.h:595
 TBranchProxy.h:596
 TBranchProxy.h:597
 TBranchProxy.h:598
 TBranchProxy.h:599
 TBranchProxy.h:600
 TBranchProxy.h:601
 TBranchProxy.h:602
 TBranchProxy.h:603
 TBranchProxy.h:604
 TBranchProxy.h:605
 TBranchProxy.h:606
 TBranchProxy.h:607
 TBranchProxy.h:608
 TBranchProxy.h:609
 TBranchProxy.h:610
 TBranchProxy.h:611
 TBranchProxy.h:612
 TBranchProxy.h:613
 TBranchProxy.h:614
 TBranchProxy.h:615
 TBranchProxy.h:616
 TBranchProxy.h:617
 TBranchProxy.h:618
 TBranchProxy.h:619
 TBranchProxy.h:620
 TBranchProxy.h:621
 TBranchProxy.h:622
 TBranchProxy.h:623
 TBranchProxy.h:624
 TBranchProxy.h:625
 TBranchProxy.h:626
 TBranchProxy.h:627
 TBranchProxy.h:628
 TBranchProxy.h:629
 TBranchProxy.h:630
 TBranchProxy.h:631
 TBranchProxy.h:632
 TBranchProxy.h:633
 TBranchProxy.h:634
 TBranchProxy.h:635
 TBranchProxy.h:636
 TBranchProxy.h:637
 TBranchProxy.h:638
 TBranchProxy.h:639
 TBranchProxy.h:640
 TBranchProxy.h:641
 TBranchProxy.h:642
 TBranchProxy.h:643
 TBranchProxy.h:644
 TBranchProxy.h:645
 TBranchProxy.h:646
 TBranchProxy.h:647
 TBranchProxy.h:648
 TBranchProxy.h:649
 TBranchProxy.h:650
 TBranchProxy.h:651
 TBranchProxy.h:652
 TBranchProxy.h:653
 TBranchProxy.h:654
 TBranchProxy.h:655
 TBranchProxy.h:656
 TBranchProxy.h:657
 TBranchProxy.h:658
 TBranchProxy.h:659
 TBranchProxy.h:660
 TBranchProxy.h:661
 TBranchProxy.h:662
 TBranchProxy.h:663
 TBranchProxy.h:664
 TBranchProxy.h:665
 TBranchProxy.h:666
 TBranchProxy.h:667
 TBranchProxy.h:668
 TBranchProxy.h:669
 TBranchProxy.h:670
 TBranchProxy.h:671
 TBranchProxy.h:672
 TBranchProxy.h:673
 TBranchProxy.h:674
 TBranchProxy.h:675
 TBranchProxy.h:676
 TBranchProxy.h:677
 TBranchProxy.h:678
 TBranchProxy.h:679
 TBranchProxy.h:680
 TBranchProxy.h:681
 TBranchProxy.h:682
 TBranchProxy.h:683
 TBranchProxy.h:684
 TBranchProxy.h:685
 TBranchProxy.h:686
 TBranchProxy.h:687
 TBranchProxy.h:688
 TBranchProxy.h:689
 TBranchProxy.h:690
 TBranchProxy.h:691
 TBranchProxy.h:692
 TBranchProxy.h:693
 TBranchProxy.h:694
 TBranchProxy.h:695
 TBranchProxy.h:696
 TBranchProxy.h:697
 TBranchProxy.h:698
 TBranchProxy.h:699
 TBranchProxy.h:700
 TBranchProxy.h:701
 TBranchProxy.h:702
 TBranchProxy.h:703
 TBranchProxy.h:704
 TBranchProxy.h:705
 TBranchProxy.h:706
 TBranchProxy.h:707
 TBranchProxy.h:708
 TBranchProxy.h:709
 TBranchProxy.h:710
 TBranchProxy.h:711
 TBranchProxy.h:712
 TBranchProxy.h:713
 TBranchProxy.h:714
 TBranchProxy.h:715
 TBranchProxy.h:716
 TBranchProxy.h:717
 TBranchProxy.h:718
 TBranchProxy.h:719
 TBranchProxy.h:720
 TBranchProxy.h:721
 TBranchProxy.h:722
 TBranchProxy.h:723
 TBranchProxy.h:724
 TBranchProxy.h:725
 TBranchProxy.h:726
 TBranchProxy.h:727
 TBranchProxy.h:728
 TBranchProxy.h:729
 TBranchProxy.h:730
 TBranchProxy.h:731
 TBranchProxy.h:732
 TBranchProxy.h:733
 TBranchProxy.h:734
 TBranchProxy.h:735
 TBranchProxy.h:736
 TBranchProxy.h:737
 TBranchProxy.h:738
 TBranchProxy.h:739
 TBranchProxy.h:740
 TBranchProxy.h:741
 TBranchProxy.h:742
 TBranchProxy.h:743
 TBranchProxy.h:744
 TBranchProxy.h:745
 TBranchProxy.h:746
 TBranchProxy.h:747
 TBranchProxy.h:748
 TBranchProxy.h:749
 TBranchProxy.h:750
 TBranchProxy.h:751
 TBranchProxy.h:752
 TBranchProxy.h:753
 TBranchProxy.h:754
 TBranchProxy.h:755
 TBranchProxy.h:756
 TBranchProxy.h:757
 TBranchProxy.h:758
 TBranchProxy.h:759
 TBranchProxy.h:760
 TBranchProxy.h:761
 TBranchProxy.h:762
 TBranchProxy.h:763
 TBranchProxy.h:764
 TBranchProxy.h:765
 TBranchProxy.h:766
 TBranchProxy.h:767
 TBranchProxy.h:768
 TBranchProxy.h:769
 TBranchProxy.h:770
 TBranchProxy.h:771
 TBranchProxy.h:772
 TBranchProxy.h:773
 TBranchProxy.h:774
 TBranchProxy.h:775
 TBranchProxy.h:776
 TBranchProxy.h:777
 TBranchProxy.h:778
 TBranchProxy.h:779
 TBranchProxy.h:780
 TBranchProxy.h:781
 TBranchProxy.h:782
 TBranchProxy.h:783
 TBranchProxy.h:784
 TBranchProxy.h:785
 TBranchProxy.h:786
 TBranchProxy.h:787
 TBranchProxy.h:788
 TBranchProxy.h:789
 TBranchProxy.h:790
 TBranchProxy.h:791
 TBranchProxy.h:792
 TBranchProxy.h:793
 TBranchProxy.h:794
 TBranchProxy.h:795
 TBranchProxy.h:796
 TBranchProxy.h:797
 TBranchProxy.h:798
 TBranchProxy.h:799
 TBranchProxy.h:800
 TBranchProxy.h:801
 TBranchProxy.h:802
 TBranchProxy.h:803
 TBranchProxy.h:804
 TBranchProxy.h:805
 TBranchProxy.h:806
 TBranchProxy.h:807
 TBranchProxy.h:808
 TBranchProxy.h:809