class TBranchElement: public TBranch

 -- Modify the container type of the branches

 -- Default and I/O constructor.

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

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

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

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

 -- Write leaves into i/o buffers for this branch.
 For the case where the branch is set in MakeClass mode (decomposed object).

 -- Write leaves into i/o buffers for this branch.
 Case of a collection (fType == 4).

 -- Write leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Write leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Write leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Write leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Write leaves into i/o buffers for this branch.
 Case of a TClonesArray (fType == 3).

 -- Write leaves into i/o buffers for this branch.
 Case of a data member within a TClonesArray (fType == 31).

 -- Write leaves into i/o buffers for this branch.
 Case of a non  TObject, non collection class with a custom streamer

 -- Write leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do have a branch count and are not a counter.

 -- Write leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do not have a branch count and are a counter.

 -- Write leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do not have a branch count and are not a counter.

 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.

 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 icon name depending on type of branch element.

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

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

 -- Prints values of leaves.

 -- Unconfiguration Read Leave function.

 -- Read leaves into i/o buffers for this branch.
 For the case where the branch is set in MakeClass mode (decomposed object).

 -- Read leaves into i/o buffers for this branch.
 Case of a collection (fType == 4).

 -- Read leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Read leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Read leaves into i/o buffers for this branch.
 Case of a data member within a collection (fType == 41).

 -- Read leaves into i/o buffers for this branch.
 Case of a TClonesArray (fType == 3).

 -- Read leaves into i/o buffers for this branch.
 Case of a data member within a TClonesArray (fType == 31).

 -- Read leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do not have a branch count and are not a counter.

 -- Read leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do have a branch count and are not a counter.

 -- Read leaves into i/o buffers for this branch.
 For split-class branch, base class branch, data member branch, or top-level branch.
 which do not have a branch count and are a counter.

 -- Read leaves into i/o buffers for this branch.
 Non TObject, Non collection classes with a custom streamer.

 -- Unconfiguration Fill Leave function.

 -- 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 a Branch after a Merge operation (drop data but keep customizations)

 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;

 If AutoDelete is on (see TBranch::SetAutoDelete),
 the top level objet will be deleted and recreate
 each time an entry is read, whether or not the
 TTree owns the object.

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

 -- Set the branch counter for this branch.

 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 offset of the object (to which the data member represented by this
 branch belongs) inside its containing object (if any).

 Set the sequence of actions needed to read the data out of the buffer.

 Set the ReadLeaves pointer to execute the expected operations.

 Set the sequence of actions needed to write the data out from the buffer.

 Set the FillLeaves pointer to execute the expected operations.

 Set the name of the class of the in-memory object into which the data will
 loaded.

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

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

 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.

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

 Not implemented