class TBranchElement: public TBranch

 -- Default and I/O 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: 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.

 -- Init 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.

 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.

 -- Init 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.

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

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

 -- Init 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.

 Find the immediate sub-branch with passed name.

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

 -- 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.

 Set branch address to zero and free all allocated memory.

 -- Release ownership of any allocated objects.

 Note: This interface was added so that clone trees could
       be told they do not own the allocated objects.

 -- Point this branch at an object.

 For a sub-branch, addr is a pointer to the branch object.

 For a top-level branch the meaning of addr is as follows:

 If addr is zero, then we allocate a branch object
 internally and the branch is the owner of the allocated
 object, not the caller.  However the caller may obtain
 a pointer to the branch object with GetObject().

 Example:

    branch->SetAddress(0);
    Event* event = branch->GetObject();
    ... Do some work.

 If addr is not zero, but the pointer addr points at is
 zero, then we allocate a branch object and set the passed
 pointer to point at the allocated object.  The caller
 owns the allocated object and is responsible for deleting
 it when it is no longer needed.

 Example:

    Event* event = 0;
    branch->SetAddress(&event);
    ... Do some work.
    delete event;
    event = 0;

 If addr is not zero and the pointer addr points at is
 also not zero, then the caller has allocated a branch
 object and is asking us to use it.  The caller owns it
 and must delete it when it is no longer needed.

 Example:

    Event* event = new Event();
    branch->SetAddress(&event);
    ... Do some work.
    delete event;
    event = 0;

 These rules affect users of TTree::Branch(),
 TTree::SetBranchAddress(), and TChain::SetBranchAddress()
 as well because those routines call this one.

 An example of a tree with branches with objects allocated
 and owned by us:

    TFile* f1 = new TFile("myfile_original.root");
    TTree* t1 = (TTree*) f->Get("MyTree");
    TFile* f2 = new TFile("myfile_copy.root", "recreate");
    TTree* t2 = t1->Clone(0);
    for (Int_t i = 0; i < 10; ++i) {
       t1->GetEntry(i);
       t2->Fill();
    }
    t2->Write()
    delete f2;
    f2 = 0;
    delete f1;
    f1 = 0;

 An example of a branch with an object allocated by us,
 but owned by the caller:

    TFile* f = new TFile("myfile.root", "recreate");
    TTree* t = new TTree("t", "A test tree.")
    Event* event = 0;
    TBranchElement* br = t->Branch("event.", &event);
    for (Int_t i = 0; i < 10; ++i) {
       ... Fill event with meaningful data in some way.
       t->Fill();
    }
    t->Write();
    delete event;
    event = 0;
    delete f;
    f = 0;

 Notice that the only difference between this example
 and the following example is that the event pointer
 is zero when the branch is created.

 An example of a branch with an object allocated and
 owned by the caller:

    TFile* f = new TFile("myfile.root", "recreate");
    TTree* t = new TTree("t", "A test tree.")
    Event* event = new Event();
    TBranchElement* br = t->Branch("event.", &event);
    for (Int_t i = 0; i < 10; ++i) {
       ... Fill event with meaningful data in some way.
       t->Fill();
    }
    t->Write();
    delete event;
    event = 0;
    delete f;
    f = 0;

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

 -- Set the branch counter for this branch.

 Set object this branch is pointing to.

 -- 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.

 Not implemented