class TClonesArray: public TObjArray

 Default Constructor.

 Create an array of clone objects of classname. The class must inherit from
 TObject. If the class defines its own operator delete(), make sure that
 it looks like this:

    void MyClass::operator delete(void *vp)
    {
       if ((Long_t) vp != TObject::GetDtorOnly())
          ::operator delete(vp);       // delete space
       else
          TObject::SetDtorOnly(0);
    }

 The second argument s indicates an approximate number of objects
 that will be entered in the array. If more than s objects are entered,
 the array will be automatically expanded.

 The third argument is not used anymore and only there for backward
 compatibility reasons.

 Create an array of clone objects of class cl. The class must inherit from
 TObject. If the class defines an own operator delete(), make sure that
 it looks like this:

    void MyClass::operator delete(void *vp)
    {
       if ((Long_t) vp != TObject::GetDtorOnly())
          ::operator delete(vp);       // delete space
       else
          TObject::SetDtorOnly(0);
    }

 The second argument, s, indicates an approximate number of objects
 that will be entered in the array. If more than s objects are entered,
 the array will be automatically expanded.

 The third argument is not used anymore and only there for backward
 compatibility reasons.

 Copy ctor.

 Assignment operator.

 Delete a clones array.

 When the kBypassStreamer bit is set, the automatically
 generated Streamer can call directly TClass::WriteBuffer.
 Bypassing the Streamer improves the performance when writing/reading
 the objects in the TClonesArray. However there is a drawback:
 When a TClonesArray is written with split=0 bypassing the Streamer,
 the StreamerInfo of the class in the array being optimized,
 one cannot use later the TClonesArray with split>0. For example,
 there is a problem with the following scenario:
  1- A class Foo has a TClonesArray of Bar objects
  2- The Foo object is written with split=0 to Tree T1.
     In this case the StreamerInfo for the class Bar is created
     in optimized mode in such a way that data members of the same type
     are written as an array improving the I/O performance.
  3- In a new program, T1 is read and a new Tree T2 is created
     with the object Foo in split>1
  4- When the T2 branch is created, the StreamerInfo for the class Bar
     is created with no optimization (mandatory for the split mode).
     The optimized Bar StreamerInfo is going to be used to read
     the TClonesArray in T1. The result will be Bar objects with
     data member values not in the right sequence.
 The solution to this problem is to call BypassStreamer(kFALSE)
 for the TClonesArray. In this case, the normal Bar::Streamer function
 will be called. The Bar::Streamer function works OK independently
 if the Bar StreamerInfo had been generated in optimized mode or not.

 Remove empty slots from array.

 Get an object at index 'idx' that is guaranteed to have been constructed.
 It might be either a freshly allocated object or one that had already been
 allocated (and assumingly used).  In the later case, it is the callers
 responsability to insure that the object is returned to a known state,
 usually by calling the Clear method on the TClonesArray.

 Tests to see if the destructor has been called on the object.
 If so, or if the object has never been constructed the class constructor is called using
 New().  If not, return a pointer to the correct memory location.
 This explicitly to deal with TObject classes that allocate memory
 which will be reset (but not deallocated) in their Clear()
 functions.

 Get an object at index 'idx' that is guaranteed to have been constructed.
 It might be either a freshly allocated object or one that had already been
 allocated (and assumingly used).  In the later case, the function Clear
 will be called and passed the value of 'clear_options'

 Tests to see if the destructor has been called on the object.
 If so, or if the object has never been constructed the class constructor is called using
 New().  If not, return a pointer to the correct memory location.
 This explicitly to deal with TObject classes that allocate memory
 which will be reset (but not deallocated) in their Clear()
 functions.

 Clear the clones array. Only use this routine when your objects don't
 allocate memory since it will not call the object dtors.
 However, if the class in the TClonesArray implements the function
 Clear(Option_t *option) and if option = "C" the function Clear()
 is called for all objects in the array. In the function Clear(), one
 can delete objects or dynamic arrays allocated in the class.
 This procedure is much faster than calling TClonesArray::Delete().
 When the option starts with "C+", eg "C+xyz" the objects in the array
 are in turn cleared with the option "xyz"

 Clear the clones array. Use this routine when your objects allocate
 memory (e.g. objects inheriting from TNamed or containing TStrings
 allocate memory). If not you better use Clear() since if is faster.

 Expand or shrink the array to newSize elements.

 Expand or shrink the array to n elements and create the clone
 objects by calling their default ctor. If n is less than the current size
 the array is shrunk and the allocated space is freed.
 This routine is typically used to create a clonesarray into which
 one can directly copy object data without going via the
 "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).

 Expand or shrink the array to n elements and create the clone
 objects by calling their default ctor. If n is less than the current size
 the array is shrinked but the allocated space is _not_ freed.
 This routine is typically used to create a clonesarray into which
 one can directly copy object data without going via the
 "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).
 This is a simplified version of ExpandCreate used in the TTree mechanism.

 Remove object at index idx.

 Remove object from array.

 Remove objects from index idx1 to idx2 included.

 Create an array of clone objects of class cl. The class must inherit from
 TObject. If the class defines an own operator delete(), make sure that
 it looks like this:

    void MyClass::operator delete(void *vp)
    {
       if ((Long_t) vp != TObject::GetDtorOnly())
          ::operator delete(vp);       // delete space
       else
          TObject::SetDtorOnly(0);
    }

 The second argument s indicates an approximate number of objects
 that will be entered in the array. If more than s objects are entered,
 the array will be automatically expanded.

 NB: This function should not be called in the TClonesArray is already
     initialized with a class.

see TClonesArray::SetClass(const TClass*)

 A TClonesArray is always the owner of the object it contains.
 However the collection its inherits from (TObjArray) does not.
 Hence this member function needs to be a nop for TClonesArray.

 If objects in array are sortable (i.e. IsSortable() returns true
 for all objects) then sort array.

 Write all objects in array to the I/O buffer. ATTENTION: empty slots
 are also stored (using one byte per slot). If you don't want this
 use a TOrdCollection or TList.

 Return pointer to reserved area in which a new object of clones
 class can be constructed. This operator should not be used for
 lefthand side assignments, like a[2] = xxx. Only like,
 new (a[2]) myClass, or xxx = a[2]. Of course right hand side usage
 is only legal after the object has been constructed via the
 new operator or via the New() method. To remove elements from
 the clones array use Remove() or RemoveAt().

 Return the object at position idx. Returns 0 if idx is out of bounds.

 Create an object of type fClass with the default ctor at the specified
 index. Returns 0 in case of error.

 Directly move the object pointers from tc without cloning (copying).
 This TClonesArray takes over ownership of all of tc's object
 pointers. The tc array is left empty upon return.

 Directly move the range of object pointers from tc without cloning
 (copying).
 This TClonesArray takes over ownership of all of tc's object pointers
 from idx1 to idx2. The tc array is re-arranged by return.

 Sort multiple TClonesArrays simultaneously with this array.
 If objects in array are sortable (i.e. IsSortable() returns true
 for all objects) then sort array.