ROOT logo
// @(#)root/cont:$Id: TClonesArray.cxx 27920 2009-03-24 14:21:20Z pcanal $
// Author: Rene Brun   11/02/96

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// An array of clone (identical) objects. Memory for the objects        //
// stored in the array is allocated only once in the lifetime of the    //
// clones array. All objects must be of the same class. For the rest    //
// this class has the same properties as TObjArray.                     //
//                                                                      //
// To reduce the very large number of new and delete calls in large     //
// loops like this (O(100000) x O(10000) times new/delete):             //
//                                                                      //
//   TObjArray a(10000);                                                //
//   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   //
//      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    //
//         a[i] = new TTrack(x,y,z,...);                                //
//         ...                                                          //
//         ...                                                          //
//      }                                                               //
//      ...                                                             //
//      a.Delete();                                                     //
//   }                                                                  //
//                                                                      //
// One better uses a TClonesArray which reduces the number of           //
// new/delete calls to only O(10000):                                   //
//                                                                      //
//   TClonesArray a("TTrack", 10000);                                   //
//   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   //
//      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    //
//         new(a[i]) TTrack(x,y,z,...);                                 //
//         ...                                                          //
//         ...                                                          //
//      }                                                               //
//      ...                                                             //
//      a.Delete();                                                     //
//   }                                                                  //
//                                                                      //
// Note: the only supported way to add objects to a TClonesArray is     //
// via the new with placement method. The diffrent Add() methods of     //
// TObjArray and its base classes are not allowed.                      //
//                                                                      //
// Considering that a new/delete costs about 70 mus on a 300 MHz HP,    //
// O(10^9) new/deletes will save about 19 hours.                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <stdlib.h>
#include "TClonesArray.h"
#include "TError.h"
#include "TROOT.h"
#include "TClass.h"
#include "TObjectTable.h"


ClassImp(TClonesArray)

//______________________________________________________________________________
TClonesArray::TClonesArray() : TObjArray()
{
   // Default Constructor.

   fClass      = 0;
   fKeep       = 0;
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const char *classname, Int_t s, Bool_t) : TObjArray(s)
{
   // 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.

   fKeep = 0;
   SetClass(classname,s);
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const TClass *cl, Int_t s, Bool_t) : TObjArray(s)
{
   // 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.

   fKeep = 0;
   SetClass(cl,s);
}

//______________________________________________________________________________
TClonesArray::TClonesArray(const TClonesArray& tc): TObjArray(tc)
{
   // Copy ctor.

   fKeep = new TObjArray(tc.fSize);
   fClass = tc.fClass;

   BypassStreamer(kTRUE);

   for (Int_t i = 0; i < fSize; i++) {
      if (tc.fCont[i]) fCont[i] = tc.fCont[i]->Clone();
      fKeep->fCont[i] = fCont[i];
   }
}

//______________________________________________________________________________
TClonesArray& TClonesArray::operator=(const TClonesArray& tc)
{
   // Assignment operator.

   if (this == &tc) return *this;

   if (fClass != tc.fClass) {
      Error("operator=", "cannot copy TClonesArray's when classes are different");
      return *this;
   }

   if (tc.fSize > fSize)
      Expand(TMath::Max(tc.fSize, GrowBy(fSize)));

   Int_t i;

   for (i = 0; i < fSize; i++)
      if (fKeep->fCont[i]) {
         if (TObject::GetObjectStat() && gObjectTable)
            gObjectTable->RemoveQuietly(fKeep->fCont[i]);
         ::operator delete(fKeep->fCont[i]);
         fKeep->fCont[i] = 0;
         fCont[i] = 0;
      }

   BypassStreamer(kTRUE);

   for (i = 0; i < tc.fSize; i++) {
      if (tc.fCont[i]) fKeep->fCont[i] = tc.fCont[i]->Clone();
      fCont[i] = fKeep->fCont[i];
   }

   fLast = tc.fSize - 1;
   Changed();
   return *this;
}

//______________________________________________________________________________
TClonesArray::~TClonesArray()
{
   // Delete a clones array.

   if (fKeep) {
      for (Int_t i = 0; i < fKeep->fSize; i++) {
         TObject* p = fKeep->fCont[i];
         if (p && p->TestBit(kNotDeleted)) {
            // -- The TObject destructor has not been called.
            fClass->Destructor(p);
            fKeep->fCont[i] = 0;
         } else {
            // -- The TObject destructor was called, just free memory.
            //
            // remove any possible entries from the ObjectTable
            if (TObject::GetObjectStat() && gObjectTable) {
               gObjectTable->RemoveQuietly(p);
            }
            ::operator delete(p);
            fKeep->fCont[i] = 0;
         }
      }
   }
   SafeDelete(fKeep);

   // Protect against erroneously setting of owner bit
   SetOwner(kFALSE);
}

//______________________________________________________________________________
void TClonesArray::BypassStreamer(Bool_t bypass)
{
   // 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.

   if (bypass)
      SetBit(kBypassStreamer);
   else
      ResetBit(kBypassStreamer);
}

//______________________________________________________________________________
void TClonesArray::Compress()
{
   // Remove empty slots from array.

   Int_t j = 0, je = 0;

   TObject **tmp = new TObject* [fSize];

   for (Int_t i = 0; i < fSize; i++) {
      if (fCont[i]) {
         fCont[j] = fCont[i];
         fKeep->fCont[j] = fKeep->fCont[i];
         j++;
      } else {
         tmp[je] = fKeep->fCont[i];
         je++;
      }
   }

   fLast = j - 1;

   Int_t jf = 0;
   for ( ; j < fSize; j++) {
      fCont[j] = 0;
      fKeep->fCont[j] = tmp[jf];
      jf++;
   }

   delete [] tmp;

   R__ASSERT(je == jf);
}

//______________________________________________________________________________
void TClonesArray::Clear(Option_t *option)
{
   // 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().

   if (option && option[0] == 'C') {
      Int_t n = GetEntriesFast();
      for (Int_t i = 0; i < n; i++) {
         TObject *obj = UncheckedAt(i);
         if (obj) obj->Clear();
      }
   }

   // Protect against erroneously setting of owner bit
   SetOwner(kFALSE);

   TObjArray::Clear();
}

//______________________________________________________________________________
void TClonesArray::Delete(Option_t *)
{
   // 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.

   Long_t dtoronly = TObject::GetDtorOnly();
   for (Int_t i = 0; i < fSize; i++) {
      if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
         // Tell custom operator delete() not to delete space when
         // object fCont[i] is deleted. Only destructors are called
         // for this object.
         TObject::SetDtorOnly(fCont[i]);
         delete fCont[i];
      }
   }
   // Restore the state.
   TObject::SetDtorOnly((void*)dtoronly);

   // Protect against erroneously setting of owner bit.
   SetOwner(kFALSE);

   TObjArray::Clear();
}

//______________________________________________________________________________
void TClonesArray::Expand(Int_t newSize)
{
   // Expand or shrink the array to newSize elements.

   if (newSize < 0) {
      Error ("Expand", "newSize must be positive (%d)", newSize);
      return;
   }
   if (newSize == fSize)
      return;
   if (newSize < fSize) {
      // release allocated space in fKeep and set to 0 so
      // Expand() will shrink correctly
      for (int i = newSize; i < fSize; i++)
         if (fKeep->fCont[i]) {
            if (TObject::GetObjectStat() && gObjectTable)
               gObjectTable->RemoveQuietly(fKeep->fCont[i]);
            ::operator delete(fKeep->fCont[i]);
            fKeep->fCont[i] = 0;
         }
   }

   TObjArray::Expand(newSize);
   fKeep->Expand(newSize);
}

//______________________________________________________________________________
void TClonesArray::ExpandCreate(Int_t n)
{
   // 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 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).

   if (n < 0) {
      Error("ExpandCreate", "n must be positive (%d)", n);
      return ;
   }
   if (n > fSize)
      Expand(TMath::Max(n, GrowBy(fSize)));

   Int_t i;
   for (i = 0; i < n; i++) {
      if (!fKeep->fCont[i]) {
         fKeep->fCont[i] = (TObject*)fClass->New();
      } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
         // The object has been delete (or never initilized)
         fClass->New(fKeep->fCont[i]);
      }
      fCont[i] = fKeep->fCont[i];
   }

   for (i = n; i < fSize; i++)
      if (fKeep->fCont[i]) {
         if (TObject::GetObjectStat() && gObjectTable)
            gObjectTable->RemoveQuietly(fKeep->fCont[i]);
         ::operator delete(fKeep->fCont[i]);
         fKeep->fCont[i] = 0;
         fCont[i] = 0;
      }

   fLast = n - 1;
   Changed();
}

//______________________________________________________________________________
void TClonesArray::ExpandCreateFast(Int_t n)
{
   // 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.

   if (n > fSize)
      Expand(TMath::Max(n, GrowBy(fSize)));

   Int_t i;
   for (i = 0; i < n; i++) {
      if (!fKeep->fCont[i]) {
         fKeep->fCont[i] = (TObject*)fClass->New();
      } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
         // The object has been delete (or never initilized)
         fClass->New(fKeep->fCont[i]);
      }
      fCont[i] = fKeep->fCont[i];
   }
   fLast = n - 1;
   Changed();
}

//______________________________________________________________________________
TObject *TClonesArray::RemoveAt(Int_t idx)
{
   // Remove object at index idx.

   if (!BoundsOk("RemoveAt", idx)) return 0;

   int i = idx-fLowerBound;

   if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
      // Tell custom operator delete() not to delete space when
      // object fCont[i] is deleted. Only destructors are called
      // for this object.
      Long_t dtoronly = TObject::GetDtorOnly();
      TObject::SetDtorOnly(fCont[i]);
      delete fCont[i];
      TObject::SetDtorOnly((void*)dtoronly);
   }

   if (fCont[i]) {
      fCont[i] = 0;
      // recalculate array size
      if (i == fLast)
         do { fLast--; } while (fLast >= 0 && fCont[fLast] == 0);
      Changed();
   }

   return 0;
}

//______________________________________________________________________________
TObject *TClonesArray::Remove(TObject *obj)
{
   // Remove object from array.

   if (!obj) return 0;

   Int_t i = IndexOf(obj) - fLowerBound;

   if (i == -1) return 0;

   if (fCont[i] && fCont[i]->TestBit(kNotDeleted)) {
      // Tell custom operator delete() not to delete space when
      // object fCont[i] is deleted. Only destructors are called
      // for this object.
      Long_t dtoronly = TObject::GetDtorOnly();
      TObject::SetDtorOnly(fCont[i]);
      delete fCont[i];
      TObject::SetDtorOnly((void*)dtoronly);
   }

   fCont[i] = 0;
   // recalculate array size
   if (i == fLast)
      do { fLast--; } while (fLast >= 0 && fCont[fLast] == 0);
   Changed();
   return obj;
}

//______________________________________________________________________________
void TClonesArray::SetClass(const TClass *cl, Int_t s)
{
   // 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.

   if (fKeep) {
      Error("SetClass", "TClonesArray already initialized with another class");
      return;
   }
   fClass = (TClass*)cl;
   if (!fClass) {
      MakeZombie();
      Error("SetClass", "called with a null pointer");
      return;
   }
   const char *classname = fClass->GetName();
   if (!fClass->InheritsFrom(TObject::Class())) {
      MakeZombie();
      Error("SetClass", "%s does not inherit from TObject", classname);
      return;
   }
   char *name = new char[strlen(classname)+2];
   sprintf(name, "%ss", classname);
   SetName(name);
   delete [] name;

   fKeep = new TObjArray(s);

   BypassStreamer(kTRUE);
}

//______________________________________________________________________________
void TClonesArray::SetClass(const char *classname, Int_t s)
{
   //see TClonesArray::SetClass(const TClass*)

   SetClass(TClass::GetClass(classname),s);
}


//______________________________________________________________________________
void TClonesArray::SetOwner(Bool_t /* enable */)
{
   // 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.

   // Nothing to be done.
}

//______________________________________________________________________________
void TClonesArray::Sort(Int_t upto)
{
   // If objects in array are sortable (i.e. IsSortable() returns true
   // for all objects) then sort array.

   Int_t nentries = GetAbsLast()+1;
   if (nentries <= 0 || fSorted) return;
   for (Int_t i = 0; i < fSize; i++)
      if (fCont[i]) {
         if (!fCont[i]->IsSortable()) {
            Error("Sort", "objects in array are not sortable");
            return;
         }
      }

   QSort(fCont, fKeep->fCont, 0, TMath::Min(nentries, upto-fLowerBound));

   fLast   = -2;
   fSorted = kTRUE;
}

//_______________________________________________________________________
void TClonesArray::Streamer(TBuffer &b)
{
   // 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.

   // Important Note: if you modify this function, remember to also modify
   // TConvertClonesArrayToProxy accordingly

   Int_t   nobjects;
   char    nch;
   TString s, classv;
   UInt_t R__s, R__c;

   if (b.IsReading()) {
      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v == 3) {
         const Int_t kOldBypassStreamer = BIT(14);
         if (TestBit(kOldBypassStreamer)) BypassStreamer();
      }
      if (v > 2)
         TObject::Streamer(b);
      if (v > 1)
         fName.Streamer(b);
      s.Streamer(b);
      classv = s;
      Int_t clv = 0;
      Ssiz_t pos = s.Index(";");
      if (pos != kNPOS) {
         classv = s(0, pos);
         s = s(pos+1, s.Length()-pos-1);
         clv = s.Atoi();
      }
      TClass *cl = TClass::GetClass(classv);
      if (!cl) {
         printf("TClonesArray::Streamer expecting class %s\n", classv.Data());
         b.CheckByteCount(R__s, R__c,TClonesArray::IsA());
         return;
      }

      b >> nobjects;
      if (nobjects < 0)
         nobjects = -nobjects;  // still there for backward compatibility
      b >> fLowerBound;
      if (fClass == 0 && fKeep == 0) {
         fClass = cl;
         fKeep  = new TObjArray(fSize);
         Expand(nobjects);
      }
      if (cl != fClass) {
         fClass = cl;
         //this case may happen when switching from an emulated class to the real class
         //may not be an error. fClass may point to a deleted object
         //Error("Streamer", "expecting objects of type %s, finding objects"
         //   " of type %s", fClass->GetName(), cl->GetName());
         //return;
      }

      // make sure there are enough slots in the fKeep array
      if (fKeep->GetSize() < nobjects)
         Expand(nobjects);

      //reset fLast. nobjects may be 0
      Int_t oldLast = fLast;
      fLast = nobjects-1;

      //TStreamerInfo *sinfo = fClass->GetStreamerInfo(clv);
      if (CanBypassStreamer() && !b.TestBit(TBuffer::kCannotHandleMemberWiseStreaming)) {
         for (Int_t i = 0; i < nobjects; i++) {
            if (!fKeep->fCont[i]) {
               fKeep->fCont[i] = (TObject*)fClass->New();
            } else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
               // The object has been delete (or never initialized)
               fClass->New(fKeep->fCont[i]);
            }

            fCont[i] = fKeep->fCont[i];
         }
         //sinfo->ReadBufferClones(b,this,nobjects,-1,0);
         b.ReadClones(this,nobjects,clv);

      } else {
         for (Int_t i = 0; i < nobjects; i++) {
            b >> nch;
            if (nch) {
               if (!fKeep->fCont[i])
                  fKeep->fCont[i] = (TObject*)fClass->New();
               else if (!fKeep->fCont[i]->TestBit(kNotDeleted)) {
                  // The object has been deleted (or never initialized)
                  fClass->New(fKeep->fCont[i]);
               }

               fCont[i] = fKeep->fCont[i];
               b.StreamObject(fKeep->fCont[i]);
            }
         }
      }
      for (Int_t i = TMath::Max(nobjects,0); i < oldLast+1; ++i) fCont[i] = 0;
      Changed();
      b.CheckByteCount(R__s, R__c,TClonesArray::IsA());
   } else {
      //Make sure TStreamerInfo is not optimized, otherwise it will not be
      //possible to support schema evolution in read mode.
      //In case the StreamerInfo has already been computed and optimized,
      //one must disable the option BypassStreamer
      //Bool_t optim = TStreamerInfo::CanOptimize();
      //if (optim) TStreamerInfo::Optimize(kFALSE);
      //TStreamerInfo *sinfo = fClass->GetStreamerInfo();
      //sinfo->ForceWriteInfo((TFile *)b.GetParent());
      //if (optim) TStreamerInfo::Optimize(kTRUE);
      //if (sinfo->IsOptimized()) BypassStreamer(kFALSE);
      b.ForceWriteInfoClones(this);

      // make sure the status of bypass streamer is part of the buffer
      // (bits in TObject), so that when reading the object the right
      // mode is used, independent of the method (e.g. written via
      // TMessage, received and stored to a file and then later read via
      // TBufferFile)
      Bool_t bypass = kFALSE;
      if (b.TestBit(TBuffer::kCannotHandleMemberWiseStreaming)) {
         bypass = CanBypassStreamer();
         BypassStreamer(kFALSE);
      }

      R__c = b.WriteVersion(TClonesArray::IsA(), kTRUE);
      TObject::Streamer(b);
      fName.Streamer(b);
      s.Form("%s;%d", fClass->GetName(), fClass->GetClassVersion());
      s.Streamer(b);
      nobjects = GetEntriesFast();
      b << nobjects;
      b << fLowerBound;
      if (CanBypassStreamer()) {
         b.WriteClones(this,nobjects);
      } else {
         for (Int_t i = 0; i < nobjects; i++) {
            if (!fCont[i]) {
               nch = 0;
               b << nch;
            } else {
               nch = 1;
               b << nch;
               b.StreamObject(fCont[i]);
            }
         }
      }
      b.SetByteCount(R__c, kTRUE);

      if (bypass)
         BypassStreamer();
   }
}

//______________________________________________________________________________
TObject *&TClonesArray::operator[](Int_t idx)
{
   // 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().

   if (idx < 0) {
      Error("operator[]", "out of bounds at %d in %lx", idx, this);
      return fCont[0];
   }
   if (!fClass) {
      Error("operator[]", "invalid class specified in TClonesArray ctor");
      return fCont[0];
   }
   if (idx >= fSize)
      Expand(TMath::Max(idx+1, GrowBy(fSize)));

   if (!fKeep->fCont[idx])
      fKeep->fCont[idx] = (TObject*) TStorage::ObjectAlloc(fClass->Size());

   fCont[idx] = fKeep->fCont[idx];

   fLast = TMath::Max(idx, GetAbsLast());
   Changed();

   return fCont[idx];
}

//______________________________________________________________________________
TObject *TClonesArray::operator[](Int_t idx) const
{
   // Return the object at position idx. Returns 0 if idx is out of bounds.

   if (idx < 0 || idx >= fSize) {
      Error("operator[]", "out of bounds at %d in %lx", idx, this);
      return 0;
   }

   return fCont[idx];
}

//______________________________________________________________________________
TObject *TClonesArray::New(Int_t idx)
{
   // Create an object of type fClass with the default ctor at the specified
   // index. Returns 0 in case of error.

   if (idx < 0) {
      Error("New", "out of bounds at %d in %lx", idx, this);
      return 0;
   }
   if (!fClass) {
      Error("New", "invalid class specified in TClonesArray ctor");
      return 0;
   }

   return (TObject *)fClass->New(operator[](idx));
}
 TClonesArray.cxx:1
 TClonesArray.cxx:2
 TClonesArray.cxx:3
 TClonesArray.cxx:4
 TClonesArray.cxx:5
 TClonesArray.cxx:6
 TClonesArray.cxx:7
 TClonesArray.cxx:8
 TClonesArray.cxx:9
 TClonesArray.cxx:10
 TClonesArray.cxx:11
 TClonesArray.cxx:12
 TClonesArray.cxx:13
 TClonesArray.cxx:14
 TClonesArray.cxx:15
 TClonesArray.cxx:16
 TClonesArray.cxx:17
 TClonesArray.cxx:18
 TClonesArray.cxx:19
 TClonesArray.cxx:20
 TClonesArray.cxx:21
 TClonesArray.cxx:22
 TClonesArray.cxx:23
 TClonesArray.cxx:24
 TClonesArray.cxx:25
 TClonesArray.cxx:26
 TClonesArray.cxx:27
 TClonesArray.cxx:28
 TClonesArray.cxx:29
 TClonesArray.cxx:30
 TClonesArray.cxx:31
 TClonesArray.cxx:32
 TClonesArray.cxx:33
 TClonesArray.cxx:34
 TClonesArray.cxx:35
 TClonesArray.cxx:36
 TClonesArray.cxx:37
 TClonesArray.cxx:38
 TClonesArray.cxx:39
 TClonesArray.cxx:40
 TClonesArray.cxx:41
 TClonesArray.cxx:42
 TClonesArray.cxx:43
 TClonesArray.cxx:44
 TClonesArray.cxx:45
 TClonesArray.cxx:46
 TClonesArray.cxx:47
 TClonesArray.cxx:48
 TClonesArray.cxx:49
 TClonesArray.cxx:50
 TClonesArray.cxx:51
 TClonesArray.cxx:52
 TClonesArray.cxx:53
 TClonesArray.cxx:54
 TClonesArray.cxx:55
 TClonesArray.cxx:56
 TClonesArray.cxx:57
 TClonesArray.cxx:58
 TClonesArray.cxx:59
 TClonesArray.cxx:60
 TClonesArray.cxx:61
 TClonesArray.cxx:62
 TClonesArray.cxx:63
 TClonesArray.cxx:64
 TClonesArray.cxx:65
 TClonesArray.cxx:66
 TClonesArray.cxx:67
 TClonesArray.cxx:68
 TClonesArray.cxx:69
 TClonesArray.cxx:70
 TClonesArray.cxx:71
 TClonesArray.cxx:72
 TClonesArray.cxx:73
 TClonesArray.cxx:74
 TClonesArray.cxx:75
 TClonesArray.cxx:76
 TClonesArray.cxx:77
 TClonesArray.cxx:78
 TClonesArray.cxx:79
 TClonesArray.cxx:80
 TClonesArray.cxx:81
 TClonesArray.cxx:82
 TClonesArray.cxx:83
 TClonesArray.cxx:84
 TClonesArray.cxx:85
 TClonesArray.cxx:86
 TClonesArray.cxx:87
 TClonesArray.cxx:88
 TClonesArray.cxx:89
 TClonesArray.cxx:90
 TClonesArray.cxx:91
 TClonesArray.cxx:92
 TClonesArray.cxx:93
 TClonesArray.cxx:94
 TClonesArray.cxx:95
 TClonesArray.cxx:96
 TClonesArray.cxx:97
 TClonesArray.cxx:98
 TClonesArray.cxx:99
 TClonesArray.cxx:100
 TClonesArray.cxx:101
 TClonesArray.cxx:102
 TClonesArray.cxx:103
 TClonesArray.cxx:104
 TClonesArray.cxx:105
 TClonesArray.cxx:106
 TClonesArray.cxx:107
 TClonesArray.cxx:108
 TClonesArray.cxx:109
 TClonesArray.cxx:110
 TClonesArray.cxx:111
 TClonesArray.cxx:112
 TClonesArray.cxx:113
 TClonesArray.cxx:114
 TClonesArray.cxx:115
 TClonesArray.cxx:116
 TClonesArray.cxx:117
 TClonesArray.cxx:118
 TClonesArray.cxx:119
 TClonesArray.cxx:120
 TClonesArray.cxx:121
 TClonesArray.cxx:122
 TClonesArray.cxx:123
 TClonesArray.cxx:124
 TClonesArray.cxx:125
 TClonesArray.cxx:126
 TClonesArray.cxx:127
 TClonesArray.cxx:128
 TClonesArray.cxx:129
 TClonesArray.cxx:130
 TClonesArray.cxx:131
 TClonesArray.cxx:132
 TClonesArray.cxx:133
 TClonesArray.cxx:134
 TClonesArray.cxx:135
 TClonesArray.cxx:136
 TClonesArray.cxx:137
 TClonesArray.cxx:138
 TClonesArray.cxx:139
 TClonesArray.cxx:140
 TClonesArray.cxx:141
 TClonesArray.cxx:142
 TClonesArray.cxx:143
 TClonesArray.cxx:144
 TClonesArray.cxx:145
 TClonesArray.cxx:146
 TClonesArray.cxx:147
 TClonesArray.cxx:148
 TClonesArray.cxx:149
 TClonesArray.cxx:150
 TClonesArray.cxx:151
 TClonesArray.cxx:152
 TClonesArray.cxx:153
 TClonesArray.cxx:154
 TClonesArray.cxx:155
 TClonesArray.cxx:156
 TClonesArray.cxx:157
 TClonesArray.cxx:158
 TClonesArray.cxx:159
 TClonesArray.cxx:160
 TClonesArray.cxx:161
 TClonesArray.cxx:162
 TClonesArray.cxx:163
 TClonesArray.cxx:164
 TClonesArray.cxx:165
 TClonesArray.cxx:166
 TClonesArray.cxx:167
 TClonesArray.cxx:168
 TClonesArray.cxx:169
 TClonesArray.cxx:170
 TClonesArray.cxx:171
 TClonesArray.cxx:172
 TClonesArray.cxx:173
 TClonesArray.cxx:174
 TClonesArray.cxx:175
 TClonesArray.cxx:176
 TClonesArray.cxx:177
 TClonesArray.cxx:178
 TClonesArray.cxx:179
 TClonesArray.cxx:180
 TClonesArray.cxx:181
 TClonesArray.cxx:182
 TClonesArray.cxx:183
 TClonesArray.cxx:184
 TClonesArray.cxx:185
 TClonesArray.cxx:186
 TClonesArray.cxx:187
 TClonesArray.cxx:188
 TClonesArray.cxx:189
 TClonesArray.cxx:190
 TClonesArray.cxx:191
 TClonesArray.cxx:192
 TClonesArray.cxx:193
 TClonesArray.cxx:194
 TClonesArray.cxx:195
 TClonesArray.cxx:196
 TClonesArray.cxx:197
 TClonesArray.cxx:198
 TClonesArray.cxx:199
 TClonesArray.cxx:200
 TClonesArray.cxx:201
 TClonesArray.cxx:202
 TClonesArray.cxx:203
 TClonesArray.cxx:204
 TClonesArray.cxx:205
 TClonesArray.cxx:206
 TClonesArray.cxx:207
 TClonesArray.cxx:208
 TClonesArray.cxx:209
 TClonesArray.cxx:210
 TClonesArray.cxx:211
 TClonesArray.cxx:212
 TClonesArray.cxx:213
 TClonesArray.cxx:214
 TClonesArray.cxx:215
 TClonesArray.cxx:216
 TClonesArray.cxx:217
 TClonesArray.cxx:218
 TClonesArray.cxx:219
 TClonesArray.cxx:220
 TClonesArray.cxx:221
 TClonesArray.cxx:222
 TClonesArray.cxx:223
 TClonesArray.cxx:224
 TClonesArray.cxx:225
 TClonesArray.cxx:226
 TClonesArray.cxx:227
 TClonesArray.cxx:228
 TClonesArray.cxx:229
 TClonesArray.cxx:230
 TClonesArray.cxx:231
 TClonesArray.cxx:232
 TClonesArray.cxx:233
 TClonesArray.cxx:234
 TClonesArray.cxx:235
 TClonesArray.cxx:236
 TClonesArray.cxx:237
 TClonesArray.cxx:238
 TClonesArray.cxx:239
 TClonesArray.cxx:240
 TClonesArray.cxx:241
 TClonesArray.cxx:242
 TClonesArray.cxx:243
 TClonesArray.cxx:244
 TClonesArray.cxx:245
 TClonesArray.cxx:246
 TClonesArray.cxx:247
 TClonesArray.cxx:248
 TClonesArray.cxx:249
 TClonesArray.cxx:250
 TClonesArray.cxx:251
 TClonesArray.cxx:252
 TClonesArray.cxx:253
 TClonesArray.cxx:254
 TClonesArray.cxx:255
 TClonesArray.cxx:256
 TClonesArray.cxx:257
 TClonesArray.cxx:258
 TClonesArray.cxx:259
 TClonesArray.cxx:260
 TClonesArray.cxx:261
 TClonesArray.cxx:262
 TClonesArray.cxx:263
 TClonesArray.cxx:264
 TClonesArray.cxx:265
 TClonesArray.cxx:266
 TClonesArray.cxx:267
 TClonesArray.cxx:268
 TClonesArray.cxx:269
 TClonesArray.cxx:270
 TClonesArray.cxx:271
 TClonesArray.cxx:272
 TClonesArray.cxx:273
 TClonesArray.cxx:274
 TClonesArray.cxx:275
 TClonesArray.cxx:276
 TClonesArray.cxx:277
 TClonesArray.cxx:278
 TClonesArray.cxx:279
 TClonesArray.cxx:280
 TClonesArray.cxx:281
 TClonesArray.cxx:282
 TClonesArray.cxx:283
 TClonesArray.cxx:284
 TClonesArray.cxx:285
 TClonesArray.cxx:286
 TClonesArray.cxx:287
 TClonesArray.cxx:288
 TClonesArray.cxx:289
 TClonesArray.cxx:290
 TClonesArray.cxx:291
 TClonesArray.cxx:292
 TClonesArray.cxx:293
 TClonesArray.cxx:294
 TClonesArray.cxx:295
 TClonesArray.cxx:296
 TClonesArray.cxx:297
 TClonesArray.cxx:298
 TClonesArray.cxx:299
 TClonesArray.cxx:300
 TClonesArray.cxx:301
 TClonesArray.cxx:302
 TClonesArray.cxx:303
 TClonesArray.cxx:304
 TClonesArray.cxx:305
 TClonesArray.cxx:306
 TClonesArray.cxx:307
 TClonesArray.cxx:308
 TClonesArray.cxx:309
 TClonesArray.cxx:310
 TClonesArray.cxx:311
 TClonesArray.cxx:312
 TClonesArray.cxx:313
 TClonesArray.cxx:314
 TClonesArray.cxx:315
 TClonesArray.cxx:316
 TClonesArray.cxx:317
 TClonesArray.cxx:318
 TClonesArray.cxx:319
 TClonesArray.cxx:320
 TClonesArray.cxx:321
 TClonesArray.cxx:322
 TClonesArray.cxx:323
 TClonesArray.cxx:324
 TClonesArray.cxx:325
 TClonesArray.cxx:326
 TClonesArray.cxx:327
 TClonesArray.cxx:328
 TClonesArray.cxx:329
 TClonesArray.cxx:330
 TClonesArray.cxx:331
 TClonesArray.cxx:332
 TClonesArray.cxx:333
 TClonesArray.cxx:334
 TClonesArray.cxx:335
 TClonesArray.cxx:336
 TClonesArray.cxx:337
 TClonesArray.cxx:338
 TClonesArray.cxx:339
 TClonesArray.cxx:340
 TClonesArray.cxx:341
 TClonesArray.cxx:342
 TClonesArray.cxx:343
 TClonesArray.cxx:344
 TClonesArray.cxx:345
 TClonesArray.cxx:346
 TClonesArray.cxx:347
 TClonesArray.cxx:348
 TClonesArray.cxx:349
 TClonesArray.cxx:350
 TClonesArray.cxx:351
 TClonesArray.cxx:352
 TClonesArray.cxx:353
 TClonesArray.cxx:354
 TClonesArray.cxx:355
 TClonesArray.cxx:356
 TClonesArray.cxx:357
 TClonesArray.cxx:358
 TClonesArray.cxx:359
 TClonesArray.cxx:360
 TClonesArray.cxx:361
 TClonesArray.cxx:362
 TClonesArray.cxx:363
 TClonesArray.cxx:364
 TClonesArray.cxx:365
 TClonesArray.cxx:366
 TClonesArray.cxx:367
 TClonesArray.cxx:368
 TClonesArray.cxx:369
 TClonesArray.cxx:370
 TClonesArray.cxx:371
 TClonesArray.cxx:372
 TClonesArray.cxx:373
 TClonesArray.cxx:374
 TClonesArray.cxx:375
 TClonesArray.cxx:376
 TClonesArray.cxx:377
 TClonesArray.cxx:378
 TClonesArray.cxx:379
 TClonesArray.cxx:380
 TClonesArray.cxx:381
 TClonesArray.cxx:382
 TClonesArray.cxx:383
 TClonesArray.cxx:384
 TClonesArray.cxx:385
 TClonesArray.cxx:386
 TClonesArray.cxx:387
 TClonesArray.cxx:388
 TClonesArray.cxx:389
 TClonesArray.cxx:390
 TClonesArray.cxx:391
 TClonesArray.cxx:392
 TClonesArray.cxx:393
 TClonesArray.cxx:394
 TClonesArray.cxx:395
 TClonesArray.cxx:396
 TClonesArray.cxx:397
 TClonesArray.cxx:398
 TClonesArray.cxx:399
 TClonesArray.cxx:400
 TClonesArray.cxx:401
 TClonesArray.cxx:402
 TClonesArray.cxx:403
 TClonesArray.cxx:404
 TClonesArray.cxx:405
 TClonesArray.cxx:406
 TClonesArray.cxx:407
 TClonesArray.cxx:408
 TClonesArray.cxx:409
 TClonesArray.cxx:410
 TClonesArray.cxx:411
 TClonesArray.cxx:412
 TClonesArray.cxx:413
 TClonesArray.cxx:414
 TClonesArray.cxx:415
 TClonesArray.cxx:416
 TClonesArray.cxx:417
 TClonesArray.cxx:418
 TClonesArray.cxx:419
 TClonesArray.cxx:420
 TClonesArray.cxx:421
 TClonesArray.cxx:422
 TClonesArray.cxx:423
 TClonesArray.cxx:424
 TClonesArray.cxx:425
 TClonesArray.cxx:426
 TClonesArray.cxx:427
 TClonesArray.cxx:428
 TClonesArray.cxx:429
 TClonesArray.cxx:430
 TClonesArray.cxx:431
 TClonesArray.cxx:432
 TClonesArray.cxx:433
 TClonesArray.cxx:434
 TClonesArray.cxx:435
 TClonesArray.cxx:436
 TClonesArray.cxx:437
 TClonesArray.cxx:438
 TClonesArray.cxx:439
 TClonesArray.cxx:440
 TClonesArray.cxx:441
 TClonesArray.cxx:442
 TClonesArray.cxx:443
 TClonesArray.cxx:444
 TClonesArray.cxx:445
 TClonesArray.cxx:446
 TClonesArray.cxx:447
 TClonesArray.cxx:448
 TClonesArray.cxx:449
 TClonesArray.cxx:450
 TClonesArray.cxx:451
 TClonesArray.cxx:452
 TClonesArray.cxx:453
 TClonesArray.cxx:454
 TClonesArray.cxx:455
 TClonesArray.cxx:456
 TClonesArray.cxx:457
 TClonesArray.cxx:458
 TClonesArray.cxx:459
 TClonesArray.cxx:460
 TClonesArray.cxx:461
 TClonesArray.cxx:462
 TClonesArray.cxx:463
 TClonesArray.cxx:464
 TClonesArray.cxx:465
 TClonesArray.cxx:466
 TClonesArray.cxx:467
 TClonesArray.cxx:468
 TClonesArray.cxx:469
 TClonesArray.cxx:470
 TClonesArray.cxx:471
 TClonesArray.cxx:472
 TClonesArray.cxx:473
 TClonesArray.cxx:474
 TClonesArray.cxx:475
 TClonesArray.cxx:476
 TClonesArray.cxx:477
 TClonesArray.cxx:478
 TClonesArray.cxx:479
 TClonesArray.cxx:480
 TClonesArray.cxx:481
 TClonesArray.cxx:482
 TClonesArray.cxx:483
 TClonesArray.cxx:484
 TClonesArray.cxx:485
 TClonesArray.cxx:486
 TClonesArray.cxx:487
 TClonesArray.cxx:488
 TClonesArray.cxx:489
 TClonesArray.cxx:490
 TClonesArray.cxx:491
 TClonesArray.cxx:492
 TClonesArray.cxx:493
 TClonesArray.cxx:494
 TClonesArray.cxx:495
 TClonesArray.cxx:496
 TClonesArray.cxx:497
 TClonesArray.cxx:498
 TClonesArray.cxx:499
 TClonesArray.cxx:500
 TClonesArray.cxx:501
 TClonesArray.cxx:502
 TClonesArray.cxx:503
 TClonesArray.cxx:504
 TClonesArray.cxx:505
 TClonesArray.cxx:506
 TClonesArray.cxx:507
 TClonesArray.cxx:508
 TClonesArray.cxx:509
 TClonesArray.cxx:510
 TClonesArray.cxx:511
 TClonesArray.cxx:512
 TClonesArray.cxx:513
 TClonesArray.cxx:514
 TClonesArray.cxx:515
 TClonesArray.cxx:516
 TClonesArray.cxx:517
 TClonesArray.cxx:518
 TClonesArray.cxx:519
 TClonesArray.cxx:520
 TClonesArray.cxx:521
 TClonesArray.cxx:522
 TClonesArray.cxx:523
 TClonesArray.cxx:524
 TClonesArray.cxx:525
 TClonesArray.cxx:526
 TClonesArray.cxx:527
 TClonesArray.cxx:528
 TClonesArray.cxx:529
 TClonesArray.cxx:530
 TClonesArray.cxx:531
 TClonesArray.cxx:532
 TClonesArray.cxx:533
 TClonesArray.cxx:534
 TClonesArray.cxx:535
 TClonesArray.cxx:536
 TClonesArray.cxx:537
 TClonesArray.cxx:538
 TClonesArray.cxx:539
 TClonesArray.cxx:540
 TClonesArray.cxx:541
 TClonesArray.cxx:542
 TClonesArray.cxx:543
 TClonesArray.cxx:544
 TClonesArray.cxx:545
 TClonesArray.cxx:546
 TClonesArray.cxx:547
 TClonesArray.cxx:548
 TClonesArray.cxx:549
 TClonesArray.cxx:550
 TClonesArray.cxx:551
 TClonesArray.cxx:552
 TClonesArray.cxx:553
 TClonesArray.cxx:554
 TClonesArray.cxx:555
 TClonesArray.cxx:556
 TClonesArray.cxx:557
 TClonesArray.cxx:558
 TClonesArray.cxx:559
 TClonesArray.cxx:560
 TClonesArray.cxx:561
 TClonesArray.cxx:562
 TClonesArray.cxx:563
 TClonesArray.cxx:564
 TClonesArray.cxx:565
 TClonesArray.cxx:566
 TClonesArray.cxx:567
 TClonesArray.cxx:568
 TClonesArray.cxx:569
 TClonesArray.cxx:570
 TClonesArray.cxx:571
 TClonesArray.cxx:572
 TClonesArray.cxx:573
 TClonesArray.cxx:574
 TClonesArray.cxx:575
 TClonesArray.cxx:576
 TClonesArray.cxx:577
 TClonesArray.cxx:578
 TClonesArray.cxx:579
 TClonesArray.cxx:580
 TClonesArray.cxx:581
 TClonesArray.cxx:582
 TClonesArray.cxx:583
 TClonesArray.cxx:584
 TClonesArray.cxx:585
 TClonesArray.cxx:586
 TClonesArray.cxx:587
 TClonesArray.cxx:588
 TClonesArray.cxx:589
 TClonesArray.cxx:590
 TClonesArray.cxx:591
 TClonesArray.cxx:592
 TClonesArray.cxx:593
 TClonesArray.cxx:594
 TClonesArray.cxx:595
 TClonesArray.cxx:596
 TClonesArray.cxx:597
 TClonesArray.cxx:598
 TClonesArray.cxx:599
 TClonesArray.cxx:600
 TClonesArray.cxx:601
 TClonesArray.cxx:602
 TClonesArray.cxx:603
 TClonesArray.cxx:604
 TClonesArray.cxx:605
 TClonesArray.cxx:606
 TClonesArray.cxx:607
 TClonesArray.cxx:608
 TClonesArray.cxx:609
 TClonesArray.cxx:610
 TClonesArray.cxx:611
 TClonesArray.cxx:612
 TClonesArray.cxx:613
 TClonesArray.cxx:614
 TClonesArray.cxx:615
 TClonesArray.cxx:616
 TClonesArray.cxx:617
 TClonesArray.cxx:618
 TClonesArray.cxx:619
 TClonesArray.cxx:620
 TClonesArray.cxx:621
 TClonesArray.cxx:622
 TClonesArray.cxx:623
 TClonesArray.cxx:624
 TClonesArray.cxx:625
 TClonesArray.cxx:626
 TClonesArray.cxx:627
 TClonesArray.cxx:628
 TClonesArray.cxx:629
 TClonesArray.cxx:630
 TClonesArray.cxx:631
 TClonesArray.cxx:632
 TClonesArray.cxx:633
 TClonesArray.cxx:634
 TClonesArray.cxx:635
 TClonesArray.cxx:636
 TClonesArray.cxx:637
 TClonesArray.cxx:638
 TClonesArray.cxx:639
 TClonesArray.cxx:640
 TClonesArray.cxx:641
 TClonesArray.cxx:642
 TClonesArray.cxx:643
 TClonesArray.cxx:644
 TClonesArray.cxx:645
 TClonesArray.cxx:646
 TClonesArray.cxx:647
 TClonesArray.cxx:648
 TClonesArray.cxx:649
 TClonesArray.cxx:650
 TClonesArray.cxx:651
 TClonesArray.cxx:652
 TClonesArray.cxx:653
 TClonesArray.cxx:654
 TClonesArray.cxx:655
 TClonesArray.cxx:656
 TClonesArray.cxx:657
 TClonesArray.cxx:658
 TClonesArray.cxx:659
 TClonesArray.cxx:660
 TClonesArray.cxx:661
 TClonesArray.cxx:662
 TClonesArray.cxx:663
 TClonesArray.cxx:664
 TClonesArray.cxx:665
 TClonesArray.cxx:666
 TClonesArray.cxx:667
 TClonesArray.cxx:668
 TClonesArray.cxx:669
 TClonesArray.cxx:670
 TClonesArray.cxx:671
 TClonesArray.cxx:672
 TClonesArray.cxx:673
 TClonesArray.cxx:674
 TClonesArray.cxx:675
 TClonesArray.cxx:676
 TClonesArray.cxx:677
 TClonesArray.cxx:678
 TClonesArray.cxx:679
 TClonesArray.cxx:680
 TClonesArray.cxx:681
 TClonesArray.cxx:682
 TClonesArray.cxx:683
 TClonesArray.cxx:684
 TClonesArray.cxx:685
 TClonesArray.cxx:686
 TClonesArray.cxx:687
 TClonesArray.cxx:688
 TClonesArray.cxx:689
 TClonesArray.cxx:690
 TClonesArray.cxx:691
 TClonesArray.cxx:692
 TClonesArray.cxx:693
 TClonesArray.cxx:694
 TClonesArray.cxx:695
 TClonesArray.cxx:696
 TClonesArray.cxx:697
 TClonesArray.cxx:698
 TClonesArray.cxx:699
 TClonesArray.cxx:700
 TClonesArray.cxx:701
 TClonesArray.cxx:702
 TClonesArray.cxx:703
 TClonesArray.cxx:704
 TClonesArray.cxx:705
 TClonesArray.cxx:706
 TClonesArray.cxx:707
 TClonesArray.cxx:708
 TClonesArray.cxx:709
 TClonesArray.cxx:710
 TClonesArray.cxx:711
 TClonesArray.cxx:712
 TClonesArray.cxx:713
 TClonesArray.cxx:714
 TClonesArray.cxx:715
 TClonesArray.cxx:716
 TClonesArray.cxx:717
 TClonesArray.cxx:718
 TClonesArray.cxx:719
 TClonesArray.cxx:720
 TClonesArray.cxx:721
 TClonesArray.cxx:722
 TClonesArray.cxx:723
 TClonesArray.cxx:724
 TClonesArray.cxx:725
 TClonesArray.cxx:726
 TClonesArray.cxx:727
 TClonesArray.cxx:728
 TClonesArray.cxx:729
 TClonesArray.cxx:730
 TClonesArray.cxx:731
 TClonesArray.cxx:732
 TClonesArray.cxx:733
 TClonesArray.cxx:734
 TClonesArray.cxx:735
 TClonesArray.cxx:736
 TClonesArray.cxx:737
 TClonesArray.cxx:738
 TClonesArray.cxx:739
 TClonesArray.cxx:740
 TClonesArray.cxx:741
 TClonesArray.cxx:742
 TClonesArray.cxx:743
 TClonesArray.cxx:744
 TClonesArray.cxx:745
 TClonesArray.cxx:746
 TClonesArray.cxx:747
 TClonesArray.cxx:748
 TClonesArray.cxx:749
 TClonesArray.cxx:750
 TClonesArray.cxx:751
 TClonesArray.cxx:752
 TClonesArray.cxx:753
 TClonesArray.cxx:754
 TClonesArray.cxx:755
 TClonesArray.cxx:756
 TClonesArray.cxx:757
 TClonesArray.cxx:758
 TClonesArray.cxx:759
 TClonesArray.cxx:760
 TClonesArray.cxx:761
 TClonesArray.cxx:762
 TClonesArray.cxx:763
 TClonesArray.cxx:764
 TClonesArray.cxx:765
 TClonesArray.cxx:766
 TClonesArray.cxx:767
 TClonesArray.cxx:768
 TClonesArray.cxx:769
 TClonesArray.cxx:770
 TClonesArray.cxx:771
 TClonesArray.cxx:772
 TClonesArray.cxx:773
 TClonesArray.cxx:774
 TClonesArray.cxx:775
 TClonesArray.cxx:776
 TClonesArray.cxx:777
 TClonesArray.cxx:778
 TClonesArray.cxx:779
 TClonesArray.cxx:780
 TClonesArray.cxx:781
 TClonesArray.cxx:782
 TClonesArray.cxx:783
 TClonesArray.cxx:784
 TClonesArray.cxx:785
 TClonesArray.cxx:786
 TClonesArray.cxx:787
 TClonesArray.cxx:788
 TClonesArray.cxx:789
 TClonesArray.cxx:790