class TBranch: public TNamed, public TAttFill

 Default constructor.  Used for I/O by default.

 Create a Branch as a child of a Tree

       * address is the address of the first item of a structure
         or the address of a pointer to an object (see example in TTree.cxx).
       * leaflist is the concatenation of all the variable names and types
         separated by a colon character :
         The variable name and the variable type are separated by a
         slash (/). The variable type must be 1 character. (Characters
         after the first are legal and will be appended to the visible
         name of the leaf, but have no effect.) If no type is given, the
         type of the variable is assumed to be the same as the previous
         variable. If the first variable does not have a type, it is
         assumed of type F by default. The list of currently supported
         types is given below:
            - C : a character string terminated by the 0 character
            - B : an 8 bit signed integer (Char_t)
            - b : an 8 bit unsigned integer (UChar_t)
            - S : a 16 bit signed integer (Short_t)
            - s : a 16 bit unsigned integer (UShort_t)
            - I : a 32 bit signed integer (Int_t)
            - i : a 32 bit unsigned integer (UInt_t)
            - F : a 32 bit floating point (Float_t)
            - D : a 64 bit floating point (Double_t)
            - L : a 64 bit signed integer (Long64_t)
            - l : a 64 bit unsigned integer (ULong64_t)
            - O : [the letter 'o', not a zero] a boolean (Bool_t)

         Arrays of values are supported with the following syntax:
         If leaf name has the form var[nelem], where nelem is alphanumeric, then
            if nelem is a leaf name, it is used as the variable size of the array,
            otherwise return 0.
            The leaf referred to by nelem **MUST** be an int (/I),
         If leaf name has the form var[nelem], where nelem is a non-negative integers, then
            it is used as the fixed size of the array.
         If leaf name has the form of a multi dimension array (e.g. var[nelem][nelem2])
            where nelem and nelem2 are non-negative integers) then
            it is used as a 2 dimensional array of fixed size.
         Any of other form is not supported.

    Note that the TTree will assume that all the item are contiguous in memory.
    On some platform, this is not always true of the member of a struct or a class,
    due to padding and alignment.  Sorting your data member in order of decreasing
    sizeof usually leads to their being contiguous in memory.

       * bufsize is the buffer size in bytes for this branch
         The default value is 32000 bytes and should be ok for most cases.
         You can specify a larger value (e.g. 256000) if your Tree is not split
         and each entry is large (Megabytes)
         A small value for bufsize is optimum if you intend to access
         the entries in the Tree randomly and your Tree is in split mode.

   See an example of a Branch definition in the TTree constructor.

   Note that in case the data type is an object, this branch can contain
   only this object.

    Note that this function is invoked by TTree::Branch

 Create a Branch as a child of another Branch

 See documentation for
 TBranch::TBranch(TTree *, const char *, void *, const char *, Int_t, Int_t)

 Initialization routine called from the constructor.  This should NOT be made virtual.

 Destructor.

 Add the basket to this branch.

 Add the start entry of the write basket (not yet created)

 Browser interface.

 Loop on all branch baskets. If the file where branch buffers reside is
 writable, free the disk space associated to the baskets of the branch,
 then call Reset(). If the option contains "all", delete also the baskets
 for the subbranches.
 The branch is reset.
 NOTE that this function must be used with extreme care. Deleting branch baskets
 fragments the file and may introduce inefficiencies when adding new entries
 in the Tree or later on when reading the Tree.

 Loop on all branch baskets. Drop all baskets from memory except readbasket.
 If the option contains "all", drop all baskets including
 read- and write-baskets (unless they are not stored individually on disk).
 The option "all" also lead to DropBaskets being called on the sub-branches.

 Increase BasketEntry buffer of a minimum of 10 locations
 and a maximum of 50 per cent of current size.

 Loop on all leaves of this branch to fill Basket buffer.

 The function returns the number of bytes committed to the memory basket.
 If a write error occurs, the number of bytes returned is -1.
 If no data are written, because e.g. the branch is disabled,
 the number of bytes returned is 0.

 Copy the data from fEntryBuffer into the current basket.

 -- Find the immediate sub-branch with passed name.

 -- Find the leaf corresponding to the name 'searchname'.

 Flush to disk all the baskets of this branch and any of subbranches.
 Return the number of bytes written or -1 in case of write error.

 If we have a write basket in memory and it contains some entries and
 has not yet been written to disk, we write it and delete it from memory.
 Return the number of bytes written;

         Return pointer to basket basketnumber in this Branch

         Return address of basket in the file

 Returns (and, if 0, creates) browsable objects for this branch
 See TVirtualBranchBrowsable::FillListOfBrowsables.

 Return the name of the user class whose content is stored in this branch,
 if any.  If this branch was created using the 'leaflist' technique, this
 function returns an empty string.

 Return icon name depending on type of branch.

 Read all leaves of entry and return total number of bytes read.

 The input argument "entry" is the entry number in the current tree.
 In case of a TChain, the entry number in the current Tree must be found
 before calling this function. For example:

     TChain* chain = ...;
     Long64_t localEntry = chain->LoadTree(entry);
     branch->GetEntry(localEntry);

 The function returns the number of bytes read from the input buffer.
 If entry does not exist, the function returns 0.
 If an I/O error occurs, the function returns -1.

 See IMPORTANT REMARKS in TTree::GetEntry.

 Read all leaves of an entry and export buffers to real objects in a TClonesArray list.

 Returns total number of bytes read.

 Fill expectedClass and expectedType with information on the data type of the
 object/values contained in this branch (and thus the type of pointers
 expected to be passed to Set[Branch]Address
 return 0 in case of success and > 0 in case of failure.

 Return pointer to the file where branch buffers reside, returns 0
 in case branch buffers reside in the same file as tree header.
 If mode is 1 the branch buffer file is recreated.

 Return a fresh basket by either resusing an existing basket that needs
 to be drop (according to TTree::MemoryFull) or create a new one.

           Return pointer to the 1st Leaf named name in thisBranch

 Return all elements of one row unpacked in internal array fValues
 [Actually just returns 1 (?)]

 Return whether this branch is in a mode where the object are decomposed
 or not (Also known as MakeClass mode).

 Get our top-level parent branch in the tree.

 Find the parent branch of child.
 Return 0 if child is not in this branch hierarchy.

 Return total number of bytes in the branch (including current buffer)

 Return total number of bytes in the branch (excluding current buffer)
 if option ="*" includes all sub-branches of this branch too

 Return total number of zip bytes in the branch
 if option ="*" includes all sub-branches of this branch too

 Return kTRUE if an existing object in a TBranchObject must be deleted.

 Return kTRUE if more than one leaf or browsables, kFALSE otherwise.

 keep a maximum of fMaxEntries in memory

  Baskets associated to this branch are forced to be in memory.
  You can call TTree::SetMaxVirtualSize(maxmemory) to instruct
  the system that the total size of the imported baskets does not
  exceed maxmemory bytes.
  The function returns the number of baskets that have been put in memory.
  This method may be called to force all baskets of one or more branches
  in memory when random access to entries in this branch is required.
  See also TTree::LoadBaskets to load all baskets of all branches in memory.

 Print TBranch parameters

 Loop on all leaves of this branch to read Basket buffer.

 Loop on all leaves of this branch to read Basket buffer.

 Read zero leaves without the overhead of a loop.

 Read one leaf without the overhead of a loop.

 Read two leaves without the overhead of a loop.

 Loop on all leaves of this branch to fill Basket buffer.

  refresh this branch using new information in b
  This function is called by TTree::Refresh

 Reset a Branch.

 Existing buffers are deleted.
 Entries, max and min are reset.

 Reset a Branch.

 Existing buffers are deleted.
 Entries, max and min are reset.

 Reset the address of the branch.

 Static function resetting fgCount

 Set address of this branch.

 Set the automatic delete bit.

 This bit is used by TBranchObject::ReadBasket to decide if an object
 referenced by a TBranchObject must be deleted or not before reading
 a new entry.

 If autodel is kTRUE, this existing object will be deleted, a new object
 created by the default constructor, then read from disk by the streamer.

 If autodel is kFALSE, the existing object is not deleted.  Root assumes
 that the user is taking care of deleting any internal object or array
 (this can be done in the streamer).

 Set the basket size
 The function makes sure that the basket size is greater than fEntryOffsetlen

 -- Set address of this branch directly from a TBuffer to avoid streaming.

 Note: We do not take ownership of the buffer.

 Update the default value for the branch's fEntryOffsetLen if and only if
 it was already non zero (and the new value is not zero)
 If updateExisting is true, also update all the existing branches.

 Set the number of entries in this branch.

 Set file where this branch writes/reads its buffers.
 By default the branch buffers reside in the file where the
 Tree was created.
 If the file name where the tree was created is an absolute
 path name or an URL (e.g. /castor/... or root://host/...)
 and if the fname is not an absolute path name or an URL then
 the path of the tree file is prepended to fname to make the
 branch file relative to the tree file. In this case one can
 move the tree + all branch files to a different location in
 the file system and still access the branch files.
 The ROOT file will be connected only when necessary.
 If called by TBranch::Fill (via TBasket::WriteFile), the file
 will be created with the option "recreate".
 If called by TBranch::GetEntry (via TBranch::GetBasket), the file
 will be opened in read mode.
 To open a file in "update" mode or with a certain compression
 level, use TBranch::SetFile(TFile *file).

 Set file where this branch writes/reads its buffers.
 By default the branch buffers reside in the file where the
 Tree was created.
 If the file name where the tree was created is an absolute
 path name or an URL (e.g. /castor/... or root://host/...)
 and if the fname is not an absolute path name or an URL then
 the path of the tree file is prepended to fname to make the
 branch file relative to the tree file. In this case one can
 move the tree + all branch files to a different location in
 the file system and still access the branch files.
 The ROOT file will be connected only when necessary.
 If called by TBranch::Fill (via TBasket::WriteFile), the file
 will be created with the option "recreate".
 If called by TBranch::GetEntry (via TBranch::GetBasket), the file
 will be opened in read mode.
 To open a file in "update" mode or with a certain compression
 level, use TBranch::SetFile(TFile *file).

 Set the branch in a mode where the object are decomposed
 (Also known as MakeClass mode).
 Return whether the setting was possible (it is not possible for
 TBranch and TBranchObject).

 Set object this branch is pointing to.

 Set branch status to Process or DoNotProcess.

 Stream a class object

 Write the current basket to disk and return the number of bytes
 written to the file.

set the first entry number (case of TBranchSTL)

 -- If the branch address is not set,  we set all addresses starting with
 the top level parent branch.

 Refresh the value of fDirectory (i.e. where this branch writes/reads its buffers)
 with the current value of fTree->GetCurrentFile unless this branch has been
 redirected to a different file.  Also update the sub-branches.