TBranchElement

 -- Default constructor.

 FIXME: What if the streamer info is optimized here?
 -- Constructor when the branch object is not a TClonesArray nor an STL container.

 If splitlevel > 0 this branch in turn is split into sub-branches.

 FIXME: Bad, the streamer info will be optimized here.
 -- Constructor when the branch object is a TClonesArray.

 If splitlevel > 0 this branch in turn is split into sub branches.

 -- Constructor when the branch object is an STL collection.

 If splitlevel > 0 this branch in turn is split into sub branches.

 -- Destructor.

 -- Get streamer info for the branch class.

 -- Browse the branch content.

 -- Set branch and leaf name and title in the case of a container sub-branch.

 -- Loop on all leaves of this branch to fill the basket buffer.

 The function returns the number of bytes committed to the
 individual branches.  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.

 Note: We not not use any member functions from TLeafElement!

 -- Fill a buffer from the leaves of this branch.

 Note:  We do not use any member functions from TLeafElement!
        Except in the MakeClass case of a TClonesArray sub-branch.

 -- Get the branch address.

 If we are *not* owned by a MakeClass() tree:

      If we are a top-level branch, return a pointer
      to the pointer to our object.

      If we are *not* a top-level branch, return a pointer
      to our object.

 If we are owned by a MakeClass() tree:

      Return a pointer to our object.

 -- Init the streamer info for the branch class, try to compensate for class code unload/reload and schema evolution.

 -- Return the collection proxy describing the branch content, if any.

 -- Return a pointer to the current type of the data member corresponding to branch element.

 -- Read all branches of a BranchElement and return total number of bytes.

 If entry = 0, then use current entry number + 1.
 If entry < 0, then reset entry number to 0.

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

 See IMPORTANT REMARKS in TTree::GetEntry.

 -- Return icon name depending on type of branch element.

 -- Return maximum count value of the branchcount if any.

 -- Return a pointer to our object.

 -- Return a pointer to the parent class of the branch element.

 -- Return type name of element in the branch.

 -- Returns the branch value.

 If the leaf is an array, j is the index in the array.

 If leaf is an array inside a TClonesArray, len should be the length
 of the array.

 If subarr is true, then len is actually the index within the sub-array.

 -- Returns pointer to first data element of this branch.
 Currently used only for members of type character.

 -- Initialize the base class subobjects offsets of our sub-branches and set fOffset if we are a container sub-branch.

 Note: The offsets are zero for data members so that when
       SetAddress recursively sets their address, they will get the
       same address as their containing class because i/o is based
       on streamer info offsets from the addresss of the containing
       class.

       Offsets are non-zero for base-class sub-branches that are
       not the leftmost direct base class.  They are laid out in
       memory sequentially and only the leftmost direct base class
       has the same address as the derived class.  The streamer
       offsets need to be added to the address of the base class
       subobject which is not the same as the address of the
       derived class for the non-leftmost direct base classes.

 -- Return kTRUE if more than one leaf, kFALSE otherwise.

 -- Detect a collection written using a zero pointer in old versions of root.
 In versions of ROOT older than 4.00/03, if a collection (TClonesArray
 or STL container) was split but the pointer to the collection was zeroed
 out, nothing was saved.  Hence there is no __easy__ way to detect the
 case.  In newer versions, a zero is written so that a 'missing' collection
 appears to be an empty collection.

 -- Print TBranch parameters.

 -- Prints values of leaves.

 -- Read leaves into i/o buffers for this branch.

 -- Delete any object we may have allocated on a previous call to SetAddress.

 -- Reset a Branch.

 Existing i/o buffers are deleted.
 Entries, max and min are reset.

 -- Reset the branch user i/o buffer address.

 -- Clear the kDeleteObject flag (clones should not delete shared i/o buffers).

 -- Set user i/o buffer address of this branch.

 -- Reset the basket size for all sub-branches of this branch element.

 -- Set the branch counter for this branch.

 -- If the branch address is not set,  we set all addresses starting with
 the top level parent branch.  This is required to be done in order for
 GetOffset to be correct and for GetEntry to run.

 -- Stream an object of class TBranchElement.

 -- Split class cl into sub-branches of this branch.

 Create a sub-branch of this branch for each non-empty,
 non-abstract base class of cl (unless we are a sub-branch
 of a TClonesArray or an STL container, in which case we
 do *not* create a sub-branch), and for each non-split data
 member of cl.

 Note: We do *not* create sub-branches for base classes of cl
       if we are a sub-branch of a TClonesArray or an STL container.

 Note: We do *not* create sub-branches for data members which
       have a class type and which we are splitting.

 Note: The above rules imply that the branch heirarchy increases
       in depth only for base classes of cl (unless we are inside
       of a TClonesArray or STL container, in which case the depth
       does *not* increase, the base class is elided) and for
       TClonesArray or STL container data members (which have one
       additional level of sub-branches).  The only other way the
       depth increases is when the top-level branch has a split
       class data member, in that case the constructor will create
       a sub-branch for it.  In other words, the interior nodes of
       the branch tree are all either: base class nodes; split
       class nodes which are direct sub-branches of top-level nodes
       (created by TClass::Bronch usually); or TClonesArray or STL
       container master nodes.

 Note: The exception to the above is for the top-level branches,
       Tree::Bronch creates nodes for everything in that case,
       except for a TObject base class of a class which has the
       can ignore tobject streamer flag set.

 -- Check to see if the user changed the object pointer without telling us.