ROOT logo
// @(#)root/cont:$Id$
// Author: Fons Rademakers   10/08/95

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TList                                                                //
//                                                                      //
// A doubly linked list. All classes inheriting from TObject can be     //
// inserted in a TList. Before being inserted into the list the object  //
// pointer is wrapped in a TObjLink object which contains, besides      //
// the object pointer also a previous and next pointer.                 //
//                                                                      //
// There are basically four ways to iterate over a TList (in order      //
// of preference, if not forced by other constraints):                  //
//    1) Using the R__FOR_EACH macro:                                   //
//         GetListOfPrimitives()->R__FOR_EACH(TObject,Paint)(option);   //
//                                                                      //
//    2) Using the TList iterator TListIter (via the wrapper class      //
//       TIter):                                                        //
//         TIter next(GetListOfPrimitives());                           //
//         while ((TObject *obj = next()))                              //
//            obj->Draw(next.GetOption());                              //
//                                                                      //
//    3) Using the TList iterator TListIter and std::for_each           //
//       algorithm:                                                     //
//         // A function object, which will be applied to each element  //
//         // of the given range.                                       //
//         struct STestFunctor {                                        //
//            bool operator()(TObject *aObj) {                          //
//               ...                                                    //
//               return true;                                           //
//            }                                                         //
//        }                                                             //
//        ...                                                           //
//        ...                                                           //
//        TIter iter(mylist);                                           //
//        for_each( iter.Begin(), TIter::End(), STestFunctor() );       //
//                                                                      //
//    4) Using the TObjLink list entries (that wrap the TObject*):      //
//         TObjLink *lnk = GetListOfPrimitives()->FirstLink();          //
//         while (lnk) {                                                //
//            lnk->GetObject()->Draw(lnk->GetOption());                 //
//            lnk = lnk->Next();                                        //
//         }                                                            //
//                                                                      //
//    5) Using the TList's After() and Before() member functions:       //
//         TFree *idcur = this;                                         //
//         while (idcur) {                                              //
//            ...                                                       //
//            ...                                                       //
//            idcur = (TFree*)GetListOfFree()->After(idcur);            //
//         }                                                            //
//                                                                      //
//   Methods 2, 3 and 4 can also easily iterate backwards using either  //
//   a backward TIter (using argument kIterBackward) or by using        //
//   LastLink() and lnk->Prev() or by using the Before() member.        //
//Begin_Html <img src=gif/tlist.gif> End_Html                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TList.h"
#include "TClass.h"
#include "TROOT.h"
#include "TVirtualMutex.h"

#include <string>
namespace std {} using namespace std;

ClassImp(TList)

//______________________________________________________________________________
TList::~TList()
{
   // Delete the list. Objects are not deleted unless the TList is the
   // owner (set via SetOwner()).

   Clear();
}

//______________________________________________________________________________
void TList::AddFirst(TObject *obj)
{
   // Add object at the beginning of the list.

   if (IsArgNull("AddFirst", obj)) return;

   if (!fFirst) {
      fFirst = NewLink(obj);
      fLast = fFirst;
   } else {
      TObjLink *t = NewLink(obj);
      t->fNext = fFirst;
      fFirst->fPrev = t;
      fFirst = t;
   }
   fSize++;
   Changed();
}

//______________________________________________________________________________
void TList::AddFirst(TObject *obj, Option_t *opt)
{
   // Add object at the beginning of the list and also store option.
   // Storing an option is useful when one wants to change the behaviour
   // of an object a little without having to create a complete new
   // copy of the object. This feature is used, for example, by the Draw()
   // method. It allows the same object to be drawn in different ways.

   if (IsArgNull("AddFirst", obj)) return;

   if (!fFirst) {
      fFirst = NewOptLink(obj, opt);
      fLast = fFirst;
   } else {
      TObjLink *t = NewOptLink(obj, opt);
      t->fNext = fFirst;
      fFirst->fPrev = t;
      fFirst = t;
   }
   fSize++;
   Changed();
}

//______________________________________________________________________________
void TList::AddLast(TObject *obj)
{
   // Add object at the end of the list.

   if (IsArgNull("AddLast", obj)) return;

   if (!fFirst) {
      fFirst = NewLink(obj);
      fLast  = fFirst;
   } else
      fLast = NewLink(obj, fLast);
   fSize++;
   Changed();
}

//______________________________________________________________________________
void TList::AddLast(TObject *obj, Option_t *opt)
{
   // Add object at the end of the list and also store option.
   // Storing an option is useful when one wants to change the behaviour
   // of an object a little without having to create a complete new
   // copy of the object. This feature is used, for example, by the Draw()
   // method. It allows the same object to be drawn in different ways.

   if (IsArgNull("AddLast", obj)) return;

   if (!fFirst) {
      fFirst = NewOptLink(obj, opt);
      fLast  = fFirst;
   } else
      fLast = NewOptLink(obj, opt, fLast);
   fSize++;
   Changed();
}

//______________________________________________________________________________
void TList::AddBefore(const TObject *before, TObject *obj)
{
   // Insert object before object before in the list.

   if (IsArgNull("AddBefore", obj)) return;

   if (!before)
      TList::AddFirst(obj);
   else {
      Int_t    idx;
      TObjLink *t = FindLink(before, idx);
      if (!t) {
         Error("AddBefore", "before not found, object not added");
         return;
      }
      if (t == fFirst)
         TList::AddFirst(obj);
      else {
         NewLink(obj, t->Prev());
         fSize++;
         Changed();
      }
   }
}

//______________________________________________________________________________
void TList::AddBefore(TObjLink *before, TObject *obj)
{
   // Insert object before the specified ObjLink object. If before = 0 then add
   // to the head of the list. An ObjLink can be obtained by looping over a list
   // using the above describe iterator method 3.

   if (IsArgNull("AddBefore", obj)) return;

   if (!before)
      TList::AddFirst(obj);
   else {
      if (before == fFirst)
         TList::AddFirst(obj);
      else {
         NewLink(obj, before->Prev());
         fSize++;
         Changed();
      }
   }
}

//______________________________________________________________________________
void TList::AddAfter(const TObject *after, TObject *obj)
{
   // Insert object after object after in the list.

   if (IsArgNull("AddAfter", obj)) return;

   if (!after)
      TList::AddLast(obj);
   else {
      Int_t    idx;
      TObjLink *t = FindLink(after, idx);
      if (!t) {
         Error("AddAfter", "after not found, object not added");
         return;
      }
      if (t == fLast)
         TList::AddLast(obj);
      else {
         NewLink(obj, t);
         fSize++;
         Changed();
      }
   }
}

//______________________________________________________________________________
void TList::AddAfter(TObjLink *after, TObject *obj)
{
   // Insert object after the specified ObjLink object. If after = 0 then add
   // to the tail of the list. An ObjLink can be obtained by looping over a list
   // using the above describe iterator method 3.

   if (IsArgNull("AddAfter", obj)) return;

   if (!after)
      TList::AddLast(obj);
   else {
      if (after == fLast)
         TList::AddLast(obj);
      else {
         NewLink(obj, after);
         fSize++;
         Changed();
      }
   }
}

//______________________________________________________________________________
void TList::AddAt(TObject *obj, Int_t idx)
{
   // Insert object at position idx in the list.

   if (IsArgNull("AddAt", obj)) return;

   TObjLink *lnk = LinkAt(idx);
   if (!lnk)
      TList::AddLast(obj);
   else if (lnk == fFirst)
      TList::AddFirst(obj);
   else {
      NewLink(obj, lnk->Prev());
      fSize++;
      Changed();
   }
}

//______________________________________________________________________________
TObject *TList::After(const TObject *obj) const
{
   // Returns the object after object obj. Obj is found using the
   // object's IsEqual() method.  Returns 0 if obj is last in list.

   TObjLink *t;

   if (fCache && fCache->GetObject() && fCache->GetObject()->IsEqual(obj)) {
      t = fCache;
      ((TList*)this)->fCache = fCache->Next();  //cast const away, fCache should be mutable
   } else {
      Int_t idx;
      t = FindLink(obj, idx);
      if (t) ((TList*)this)->fCache = t->Next();
   }

   if (t && t->Next())
      return t->Next()->GetObject();
   else
      return 0;
}

//______________________________________________________________________________
TObject *TList::At(Int_t idx) const
{
   // Returns the object at position idx. Returns 0 if idx is out of range.

   TObjLink *lnk = LinkAt(idx);
   if (lnk) return lnk->GetObject();
   return 0;
}

//______________________________________________________________________________
TObject *TList::Before(const TObject *obj) const
{
   // Returns the object before object obj. Obj is found using the
   // object's IsEqual() method.  Returns 0 if obj is first in list.

   TObjLink *t;

   if (fCache && fCache->GetObject() && fCache->GetObject()->IsEqual(obj)) {
      t = fCache;
      ((TList*)this)->fCache = fCache->Prev();  //cast const away, fCache should be mutable
   } else {
      Int_t idx;
      t = FindLink(obj, idx);
      if (t) ((TList*)this)->fCache = t->Prev();
   }

   if (t && t->Prev())
      return t->Prev()->GetObject();
   else
      return 0;
}

//______________________________________________________________________________
void TList::Clear(Option_t *option)
{
   // Remove all objects from the list. Does not delete the objects
   // unless the TList is the owner (set via SetOwner()) and option
   // "nodelete" is not set.
   // If option="nodelete" then don't delete any heap objects that were
   // marked with the kCanDelete bit, otherwise these objects will be
   // deleted (this option is used by THashTable::Clear()).

   Bool_t nodel = option ? (!strcmp(option, "nodelete") ? kTRUE : kFALSE) : kFALSE;

   if (!nodel && IsOwner()) {
      Delete(option);
      return;
   }

   // In some case, for example TParallelCoord, a list (the pad's list of 
   // primitives) will contain both the container and the containees
   // (the TParallelCoorVar) but if the Clear is being called from
   // the destructor of the container of this list, one of the first
   // thing done will be the remove the container (the pad) for the
   // list (of Primitives of the canvas) that was connecting it 
   // (indirectly) to the list of cleanups.
   // So let's temporarily add the current list and remove it later.
   bool needRegister = fFirst && TROOT::Initialized();
   if(needRegister) {
      R__LOCKGUARD2(gROOTMutex);
      needRegister = needRegister && !gROOT->GetListOfCleanups()->FindObject(this);
   }
   if (needRegister) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfCleanups()->Add(this);
   }
   while (fFirst) {
      TObjLink *tlk = fFirst;
      fFirst = fFirst->Next();
      fSize--;
      // delete only heap objects marked OK to clear
      if (!nodel && tlk->GetObject() && tlk->GetObject()->IsOnHeap()) {
         if (tlk->GetObject()->TestBit(kCanDelete)) {
            if(tlk->GetObject()->TestBit(kNotDeleted)) {
               TCollection::GarbageCollect(tlk->GetObject());
            }
         }
      }
      delete tlk;
   }
   if (needRegister) {
      R__LOCKGUARD2(gROOTMutex);
      ROOT::GetROOT()->GetListOfCleanups()->Remove(this);
   }
   fFirst = fLast = fCache = 0;
   fSize  = 0;
   Changed();
}

//______________________________________________________________________________
void TList::Delete(Option_t *option)
{
   // Remove all objects from the list AND delete all heap based objects.
   // If option="slow" then keep list consistent during delete. This allows
   // recursive list operations during the delete (e.g. during the dtor
   // of an object in this list one can still access the list to search for
   // other not yet deleted objects).

   Bool_t slow = option ? (!strcmp(option, "slow") ? kTRUE : kFALSE) : kFALSE;

   TList removeDirectory; // need to deregistere these from their directory

   if (slow) {

      // In some case, for example TParallelCoord, a list (the pad's list of 
      // primitives) will contain both the container and the containees
      // (the TParallelCoorVar) but if the Clear is being called from
      // the destructor of the container of this list, one of the first
      // thing done will be the remove the container (the pad) for the
      // list (of Primitives of the canvas) that was connecting it 
      // (indirectly) to the list of cleanups.
      // So let's temporarily add the current list and remove it later.
      bool needRegister = fFirst && TROOT::Initialized();
      if(needRegister) {
         R__LOCKGUARD2(gROOTMutex);
         needRegister = needRegister && !gROOT->GetListOfCleanups()->FindObject(this);
      }
      if (needRegister) {
         R__LOCKGUARD2(gROOTMutex);
         gROOT->GetListOfCleanups()->Add(this);
      }
      while (fFirst) {
         TObjLink *tlk = fFirst;
         fFirst = fFirst->Next();
         fSize--;
         // delete only heap objects
         if (tlk->GetObject() && tlk->GetObject()->IsOnHeap())
            TCollection::GarbageCollect(tlk->GetObject());
         else if (tlk->GetObject() && tlk->GetObject()->IsA()->GetDirectoryAutoAdd())
            removeDirectory.Add(tlk->GetObject());

         delete tlk;
      }

      if (needRegister) {
         R__LOCKGUARD2(gROOTMutex);
         ROOT::GetROOT()->GetListOfCleanups()->Remove(this);
      }

      fFirst = fLast = fCache = 0;
      fSize  = 0;

   } else {

      TObjLink *first = fFirst;    //pointer to first entry in linked list
      fFirst = fLast = fCache = 0;
      fSize  = 0;
      while (first) {
         TObjLink *tlk = first;
         first = first->Next();
         // delete only heap objects
         if (tlk->GetObject() && tlk->GetObject()->IsOnHeap())
            TCollection::GarbageCollect(tlk->GetObject());
         else if (tlk->GetObject() && tlk->GetObject()->IsA()->GetDirectoryAutoAdd())
            removeDirectory.Add(tlk->GetObject());

         delete tlk;
      }
   }

   // These objects cannot expect to have a valid TDirectory anymore;
   // e.g. because *this is the TDirectory's list of objects. Even if
   // not, they are supposed to be deleted, so we can as well unregister
   // them from their directory, even if they are stack-based:
   TIter iRemDir(&removeDirectory);
   TObject* dirRem = 0;
   while ((dirRem = iRemDir())) {
      (*dirRem->IsA()->GetDirectoryAutoAdd())(dirRem, 0);
   }
   Changed();
}

//______________________________________________________________________________
void TList::DeleteLink(TObjLink *lnk)
{
   // Delete a TObjLink object.

   lnk->fNext = lnk->fPrev = 0;
   lnk->fObject = 0;
   delete lnk;
}

//______________________________________________________________________________
TObject *TList::FindObject(const char *name) const
{
   // Find an object in this list using its name. Requires a sequential
   // scan till the object has been found. Returns 0 if object with specified
   // name is not found. This method overrides the generic FindObject()
   // of TCollection for efficiency reasons.

   if (!name) return 0;
   TObjLink *lnk = FirstLink();
   while (lnk) {
      TObject *obj = lnk->GetObject();
      const char *objname = obj->GetName();
      if (objname && !strcmp(name, objname)) return obj;
      lnk = lnk->Next();
   }
   return 0;
}

//______________________________________________________________________________
TObject *TList::FindObject(const TObject *obj) const
{
   // Find an object in this list using the object's IsEqual()
   // member function. Requires a sequential scan till the object has
   // been found. Returns 0 if object is not found.
   // This method overrides the generic FindObject() of TCollection for
   // efficiency reasons.

   TObjLink *lnk = FirstLink();

   while (lnk) {
      TObject *ob = lnk->GetObject();
      if (ob->IsEqual(obj)) return ob;
      lnk = lnk->Next();
   }
   return 0;
}

//______________________________________________________________________________
TObjLink *TList::FindLink(const TObject *obj, Int_t &idx) const
{
   // Returns the TObjLink object that contains object obj. In idx it returns
   // the position of the object in the list.

   if (!fFirst) return 0;

   TObject *object;
   TObjLink *lnk = fFirst;
   idx = 0;

   while (lnk) {
      object = lnk->GetObject();
      if (object) {
         if (object->TestBit(kNotDeleted)) {
            if (object->IsEqual(obj)) return lnk;
         }
      }
      lnk = lnk->Next();
      idx++;
   }
   return 0;
}

//______________________________________________________________________________
TObject *TList::First() const
{
   // Return the first object in the list. Returns 0 when list is empty.

   if (fFirst) return fFirst->GetObject();
   return 0;
}

//______________________________________________________________________________
TObject **TList::GetObjectRef(const TObject *obj) const
{
   // Return address of pointer to obj

   TObjLink *lnk = FirstLink();

   while (lnk) {
      TObject *ob = lnk->GetObject();
      if (ob->IsEqual(obj)) return lnk->GetObjectRef();
      lnk = lnk->Next();
   }
   return 0;
}

//______________________________________________________________________________
TObject *TList::Last() const
{
   // Return the last object in the list. Returns 0 when list is empty.

   if (fLast) return fLast->GetObject();
   return 0;
}

//______________________________________________________________________________
TObjLink *TList::LinkAt(Int_t idx) const
{
   // Return the TObjLink object at index idx.

   Int_t    i = 0;
   TObjLink *lnk = fFirst;
   while (i < idx && lnk) {
      i++;
      lnk = lnk->Next();
   }
   return lnk;
}

//______________________________________________________________________________
TIterator *TList::MakeIterator(Bool_t dir) const
{
   // Return a list iterator.

   return new TListIter(this, dir);
}

//______________________________________________________________________________
TObjLink *TList::NewLink(TObject *obj, TObjLink *prev)
{
   // Return a new TObjLink.

   if (prev)
      return new TObjLink(obj, prev);
   else
      return new TObjLink(obj);
}

//______________________________________________________________________________
TObjLink *TList::NewOptLink(TObject *obj, Option_t *opt, TObjLink *prev)
{
   // Return a new TObjOptLink (a TObjLink that also stores the option).

   if (prev)
      return new TObjOptLink(obj, prev, opt);
   else
      return new TObjOptLink(obj, opt);
}

//______________________________________________________________________________
void TList::RecursiveRemove(TObject *obj)
{
   // Remove object from this collection and recursively remove the object
   // from all other objects (and collections).

   if (!obj) return;

   TObjLink *lnk  = fFirst;
   TObjLink *next = 0;
   while (lnk) {
      next = lnk->Next();
      TObject *ob = lnk->GetObject();
      if (ob->TestBit(kNotDeleted)) {
         if (ob->IsEqual(obj)) {
            if (lnk == fFirst) {
               fFirst = next;
               if (lnk == fLast)
                  fLast = fFirst;
               else
                  fFirst->fPrev = 0;
               DeleteLink(lnk);
            } else if (lnk == fLast) {
               fLast = lnk->Prev();
               fLast->fNext = 0;
               DeleteLink(lnk);
            } else {
               lnk->Prev()->fNext = next;
               lnk->Next()->fPrev = lnk->Prev();
               DeleteLink(lnk);
            }
            fSize--;
            fCache = 0;
            Changed();
         } else
            ob->RecursiveRemove(obj);
      }
      lnk = next;
   }
}

//______________________________________________________________________________
TObject *TList::Remove(TObject *obj)
{
   // Remove object from the list.

   if (!obj) return 0;

   Int_t    idx;
   TObjLink *lnk = FindLink(obj, idx);

   if (!lnk) return 0;

   // return object found, which may be (pointer wise) different than the
   // input object (depending on what IsEqual() is doing)

   TObject *ob = lnk->GetObject();
   if (lnk == fFirst) {
      fFirst = lnk->Next();
      if (lnk == fLast)
         fLast = fFirst;
      else
         fFirst->fPrev = 0;
      DeleteLink(lnk);
   } else if (lnk == fLast) {
      fLast = lnk->Prev();
      fLast->fNext = 0;
      DeleteLink(lnk);
   } else {
      lnk->Prev()->fNext = lnk->Next();
      lnk->Next()->fPrev = lnk->Prev();
      DeleteLink(lnk);
   }
   fSize--;
   fCache = 0;
   Changed();

   return ob;
}

//______________________________________________________________________________
TObject *TList::Remove(TObjLink *lnk)
{
   // Remove object link (and therefore the object it contains)
   // from the list.

   if (!lnk) return 0;

   TObject *obj = lnk->GetObject();

   if (lnk == fFirst) {
      fFirst = lnk->Next();
      if (lnk == fLast)
         fLast = fFirst;
      else
         fFirst->fPrev = 0;
      DeleteLink(lnk);
   } else if (lnk == fLast) {
      fLast = lnk->Prev();
      fLast->fNext = 0;
      DeleteLink(lnk);
   } else {
      lnk->Prev()->fNext = lnk->Next();
      lnk->Next()->fPrev = lnk->Prev();
      DeleteLink(lnk);
   }
   fSize--;
   fCache = 0;
   Changed();

   return obj;
}

//______________________________________________________________________________
void TList::RemoveLast()
{
   // Remove the last object of the list.

   TObjLink *lnk = fLast;
   if (!lnk) return;

   if (lnk == fFirst) {
      fFirst = 0;
      fLast = 0;
   } else {
      fLast = lnk->Prev();
      fLast->fNext = 0;
   }
   DeleteLink(lnk);

   fSize--;
   fCache = 0;
   Changed();
}

//______________________________________________________________________________
void TList::Sort(Bool_t order)
{
   // Sort linked list. Real sorting is done in private function DoSort().
   // The list can only be sorted when is contains objects of a sortable
   // class.

   if (!fFirst) return;

   fAscending = order;

   if (!fFirst->GetObject()->IsSortable()) {
      Error("Sort", "objects in list are not sortable");
      return;
   }

   DoSort(&fFirst, fSize);

   // correct back links
   TObjLink *ol, *lnk = fFirst;

   if (lnk) lnk->fPrev = 0;
   while ((ol = lnk)) {
      lnk = lnk->fNext;
      if (lnk)
         lnk->fPrev = ol;
      else
         fLast = ol;
   }
   fSorted = kTRUE;
}

//______________________________________________________________________________
Bool_t TList::LnkCompare(TObjLink *l1, TObjLink *l2)
{
   // Compares the objects stored in the TObjLink objects.
   // Depending on the flag IsAscending() the function returns
   // true if the object in l1 <= l2 (ascending) or l2 <= l1 (descending).

   Int_t cmp = l1->GetObject()->Compare(l2->GetObject());

   if ((IsAscending() && cmp <=0) || (!IsAscending() && cmp > 0))
      return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
TObjLink **TList::DoSort(TObjLink **head, Int_t n)
{
   // Sort linked list.

   TObjLink *p1, *p2, **h2, **t2;

   switch (n) {
      case 0:
         return head;

      case 1:
         return &((*head)->fNext);

      case 2:
         p2 = (p1 = *head)->fNext;
         if (LnkCompare(p1, p2)) return &(p2->fNext);
         p1->fNext = (*head = p2)->fNext;
         return &((p2->fNext = p1)->fNext);
   }

   int m;
   n -= m = n / 2;

   t2 = DoSort(h2 = DoSort(head, n), m);

   if (LnkCompare((p1 = *head), (p2 = *h2))) {
      do {
         if (!--n) return *h2 = p2, t2;
      } while (LnkCompare((p1 = *(head = &(p1->fNext))), p2));
   }

   while (1) {
      *head = p2;
      do {
         if (!--m) return *h2 = *t2, *t2 = p1, h2;
      } while (!LnkCompare(p1, (p2 = *(head = &(p2->fNext)))));
      *head = p1;
      do {
         if (!--n) return *h2 = p2, t2;
      } while (LnkCompare((p1 = *(head = &(p1->fNext))), p2));
   }
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TObjLink                                                             //
//                                                                      //
// Wrapper around a TObject so it can be stored in a TList.             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TObjLink::TObjLink(TObject *obj, TObjLink *prev)
          : fNext(prev->fNext), fPrev(prev), fObject(obj)
{
   // Create a new TObjLink.

   fPrev->fNext = this;
   if (fNext) fNext->fPrev = this;
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TListIter                                                            //
//                                                                      //
// Iterator of linked list.                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

ClassImp(TListIter)

//______________________________________________________________________________
TListIter::TListIter(const TList *l, Bool_t dir)
        : fList(l), fCurCursor(0), fCursor(0), fDirection(dir), fStarted(kFALSE)
{
   // Create a new list iterator. By default the iteration direction
   // is kIterForward. To go backward use kIterBackward.
}

//______________________________________________________________________________
TListIter::TListIter(const TListIter &iter) : TIterator(iter)
{
   // Copy ctor.

   fList      = iter.fList;
   fCurCursor = iter.fCurCursor;
   fCursor    = iter.fCursor;
   fDirection = iter.fDirection;
   fStarted   = iter.fStarted;
}

//______________________________________________________________________________
TIterator &TListIter::operator=(const TIterator &rhs)
{
   // Overridden assignment operator.

   if (this != &rhs && rhs.IsA() == TListIter::Class()) {
      const TListIter &rhs1 = (const TListIter &)rhs;
      fList      = rhs1.fList;
      fCurCursor = rhs1.fCurCursor;
      fCursor    = rhs1.fCursor;
      fDirection = rhs1.fDirection;
      fStarted   = rhs1.fStarted;
   }
   return *this;
}

//______________________________________________________________________________
TListIter &TListIter::operator=(const TListIter &rhs)
{
   // Overloaded assignment operator.

   if (this != &rhs) {
      fList      = rhs.fList;
      fCurCursor = rhs.fCurCursor;
      fCursor    = rhs.fCursor;
      fDirection = rhs.fDirection;
      fStarted   = rhs.fStarted;
   }
   return *this;
}

//______________________________________________________________________________
TObject *TListIter::Next()
{
   // Return next object in the list. Returns 0 when no more objects in list.

   if (!fList) return 0;

   if (fDirection == kIterForward) {
      if (!fStarted) {
         fCursor = fList->fFirst;
         fStarted = kTRUE;
      }
      fCurCursor = fCursor;
      if (fCursor) fCursor = fCursor->Next();
   } else {
      if (!fStarted) {
         fCursor = fList->fLast;
         fStarted = kTRUE;
      }
      fCurCursor = fCursor;
      if (fCursor) fCursor = fCursor->Prev();
   }

   if (fCurCursor) return fCurCursor->GetObject();
   return 0;
}

//______________________________________________________________________________
Option_t *TListIter::GetOption() const
{
   // Returns the object option stored in the list.

   if (fCurCursor) return fCurCursor->GetOption();
   return "";
}

//______________________________________________________________________________
void TListIter::SetOption(Option_t *option)
{
   // Sets the object option stored in the list.

   if (fCurCursor) fCurCursor->SetOption(option);
}

//______________________________________________________________________________
void TListIter::Reset()
{
   // Reset list iterator.

   fStarted = kFALSE;
}

//______________________________________________________________________________
Bool_t TListIter::operator!=(const TIterator &aIter) const
{
   // This operator compares two TIterator objects.

   if (IsA() == aIter.IsA()) {
      // We compared equal only two iterator of the same type.
      // Since this is a function of TListIter, we consequently know that
      // both this and aIter are of type inheriting from TListIter.
      const TListIter &iter(dynamic_cast<const TListIter &>(aIter));
      return (fCurCursor != iter.fCurCursor);
   }
   return false; // for base class we don't implement a comparison
}

//______________________________________________________________________________
Bool_t TListIter::operator!=(const TListIter &aIter) const
{
   // This operator compares two TListIter objects.
   return (fCurCursor != aIter.fCurCursor);
}

//_______________________________________________________________________
void TList::Streamer(TBuffer &b)
{
   // Stream all objects in the collection to or from the I/O buffer.

   Int_t nobjects;
   UChar_t nch;
   Int_t nbig;
   TObject *obj;
   UInt_t R__s, R__c;

   if (b.IsReading()) {
      Clear(); // Get rid of old data if any.
      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v > 3) {
         TObject::Streamer(b);
         fName.Streamer(b);
         b >> nobjects;
         string readOption;
         for (Int_t i = 0; i < nobjects; i++) {
            b >> obj;
            b >> nch;
            if (v > 4 && nch == 255)  {
               b >> nbig;
            } else {
               nbig = nch;
            }
            readOption.resize(nbig,'\0');
            b.ReadFastArray((char*) readOption.data(),nbig);
            if (obj) { // obj can be null if the class had a custom streamer and we do not have the shared library nor a streamerInfo.
               if (nch) {
                  Add(obj,readOption.c_str());
               } else {
                  Add(obj);
               }
            }
         }
         b.CheckByteCount(R__s, R__c,TList::IsA());
         return;
      }

      //  process old versions when TList::Streamer was in TCollection::Streamer
      if (v > 2)
         TObject::Streamer(b);
      if (v > 1)
         fName.Streamer(b);
      b >> nobjects;
      for (Int_t i = 0; i < nobjects; i++) {
         b >> obj;
         Add(obj);
      }
      b.CheckByteCount(R__s, R__c,TList::IsA());

   } else {
      R__c = b.WriteVersion(TList::IsA(), kTRUE);
      TObject::Streamer(b);
      fName.Streamer(b);
      nobjects = GetSize();
      b << nobjects;

      TObjLink *lnk = fFirst;
      while (lnk) {
         obj = lnk->GetObject();
         b << obj;

         nbig = strlen(lnk->GetAddOption());
         if (nbig > 254) {
            nch = 255;
            b << nch;
            b << nbig;
         } else {
            nch = UChar_t(nbig);
            b << nch;
         }
         b.WriteFastArray(lnk->GetAddOption(),nbig);

         lnk = lnk->Next();
      }
      b.SetByteCount(R__c, kTRUE);
   }
}
 TList.cxx:1
 TList.cxx:2
 TList.cxx:3
 TList.cxx:4
 TList.cxx:5
 TList.cxx:6
 TList.cxx:7
 TList.cxx:8
 TList.cxx:9
 TList.cxx:10
 TList.cxx:11
 TList.cxx:12
 TList.cxx:13
 TList.cxx:14
 TList.cxx:15
 TList.cxx:16
 TList.cxx:17
 TList.cxx:18
 TList.cxx:19
 TList.cxx:20
 TList.cxx:21
 TList.cxx:22
 TList.cxx:23
 TList.cxx:24
 TList.cxx:25
 TList.cxx:26
 TList.cxx:27
 TList.cxx:28
 TList.cxx:29
 TList.cxx:30
 TList.cxx:31
 TList.cxx:32
 TList.cxx:33
 TList.cxx:34
 TList.cxx:35
 TList.cxx:36
 TList.cxx:37
 TList.cxx:38
 TList.cxx:39
 TList.cxx:40
 TList.cxx:41
 TList.cxx:42
 TList.cxx:43
 TList.cxx:44
 TList.cxx:45
 TList.cxx:46
 TList.cxx:47
 TList.cxx:48
 TList.cxx:49
 TList.cxx:50
 TList.cxx:51
 TList.cxx:52
 TList.cxx:53
 TList.cxx:54
 TList.cxx:55
 TList.cxx:56
 TList.cxx:57
 TList.cxx:58
 TList.cxx:59
 TList.cxx:60
 TList.cxx:61
 TList.cxx:62
 TList.cxx:63
 TList.cxx:64
 TList.cxx:65
 TList.cxx:66
 TList.cxx:67
 TList.cxx:68
 TList.cxx:69
 TList.cxx:70
 TList.cxx:71
 TList.cxx:72
 TList.cxx:73
 TList.cxx:74
 TList.cxx:75
 TList.cxx:76
 TList.cxx:77
 TList.cxx:78
 TList.cxx:79
 TList.cxx:80
 TList.cxx:81
 TList.cxx:82
 TList.cxx:83
 TList.cxx:84
 TList.cxx:85
 TList.cxx:86
 TList.cxx:87
 TList.cxx:88
 TList.cxx:89
 TList.cxx:90
 TList.cxx:91
 TList.cxx:92
 TList.cxx:93
 TList.cxx:94
 TList.cxx:95
 TList.cxx:96
 TList.cxx:97
 TList.cxx:98
 TList.cxx:99
 TList.cxx:100
 TList.cxx:101
 TList.cxx:102
 TList.cxx:103
 TList.cxx:104
 TList.cxx:105
 TList.cxx:106
 TList.cxx:107
 TList.cxx:108
 TList.cxx:109
 TList.cxx:110
 TList.cxx:111
 TList.cxx:112
 TList.cxx:113
 TList.cxx:114
 TList.cxx:115
 TList.cxx:116
 TList.cxx:117
 TList.cxx:118
 TList.cxx:119
 TList.cxx:120
 TList.cxx:121
 TList.cxx:122
 TList.cxx:123
 TList.cxx:124
 TList.cxx:125
 TList.cxx:126
 TList.cxx:127
 TList.cxx:128
 TList.cxx:129
 TList.cxx:130
 TList.cxx:131
 TList.cxx:132
 TList.cxx:133
 TList.cxx:134
 TList.cxx:135
 TList.cxx:136
 TList.cxx:137
 TList.cxx:138
 TList.cxx:139
 TList.cxx:140
 TList.cxx:141
 TList.cxx:142
 TList.cxx:143
 TList.cxx:144
 TList.cxx:145
 TList.cxx:146
 TList.cxx:147
 TList.cxx:148
 TList.cxx:149
 TList.cxx:150
 TList.cxx:151
 TList.cxx:152
 TList.cxx:153
 TList.cxx:154
 TList.cxx:155
 TList.cxx:156
 TList.cxx:157
 TList.cxx:158
 TList.cxx:159
 TList.cxx:160
 TList.cxx:161
 TList.cxx:162
 TList.cxx:163
 TList.cxx:164
 TList.cxx:165
 TList.cxx:166
 TList.cxx:167
 TList.cxx:168
 TList.cxx:169
 TList.cxx:170
 TList.cxx:171
 TList.cxx:172
 TList.cxx:173
 TList.cxx:174
 TList.cxx:175
 TList.cxx:176
 TList.cxx:177
 TList.cxx:178
 TList.cxx:179
 TList.cxx:180
 TList.cxx:181
 TList.cxx:182
 TList.cxx:183
 TList.cxx:184
 TList.cxx:185
 TList.cxx:186
 TList.cxx:187
 TList.cxx:188
 TList.cxx:189
 TList.cxx:190
 TList.cxx:191
 TList.cxx:192
 TList.cxx:193
 TList.cxx:194
 TList.cxx:195
 TList.cxx:196
 TList.cxx:197
 TList.cxx:198
 TList.cxx:199
 TList.cxx:200
 TList.cxx:201
 TList.cxx:202
 TList.cxx:203
 TList.cxx:204
 TList.cxx:205
 TList.cxx:206
 TList.cxx:207
 TList.cxx:208
 TList.cxx:209
 TList.cxx:210
 TList.cxx:211
 TList.cxx:212
 TList.cxx:213
 TList.cxx:214
 TList.cxx:215
 TList.cxx:216
 TList.cxx:217
 TList.cxx:218
 TList.cxx:219
 TList.cxx:220
 TList.cxx:221
 TList.cxx:222
 TList.cxx:223
 TList.cxx:224
 TList.cxx:225
 TList.cxx:226
 TList.cxx:227
 TList.cxx:228
 TList.cxx:229
 TList.cxx:230
 TList.cxx:231
 TList.cxx:232
 TList.cxx:233
 TList.cxx:234
 TList.cxx:235
 TList.cxx:236
 TList.cxx:237
 TList.cxx:238
 TList.cxx:239
 TList.cxx:240
 TList.cxx:241
 TList.cxx:242
 TList.cxx:243
 TList.cxx:244
 TList.cxx:245
 TList.cxx:246
 TList.cxx:247
 TList.cxx:248
 TList.cxx:249
 TList.cxx:250
 TList.cxx:251
 TList.cxx:252
 TList.cxx:253
 TList.cxx:254
 TList.cxx:255
 TList.cxx:256
 TList.cxx:257
 TList.cxx:258
 TList.cxx:259
 TList.cxx:260
 TList.cxx:261
 TList.cxx:262
 TList.cxx:263
 TList.cxx:264
 TList.cxx:265
 TList.cxx:266
 TList.cxx:267
 TList.cxx:268
 TList.cxx:269
 TList.cxx:270
 TList.cxx:271
 TList.cxx:272
 TList.cxx:273
 TList.cxx:274
 TList.cxx:275
 TList.cxx:276
 TList.cxx:277
 TList.cxx:278
 TList.cxx:279
 TList.cxx:280
 TList.cxx:281
 TList.cxx:282
 TList.cxx:283
 TList.cxx:284
 TList.cxx:285
 TList.cxx:286
 TList.cxx:287
 TList.cxx:288
 TList.cxx:289
 TList.cxx:290
 TList.cxx:291
 TList.cxx:292
 TList.cxx:293
 TList.cxx:294
 TList.cxx:295
 TList.cxx:296
 TList.cxx:297
 TList.cxx:298
 TList.cxx:299
 TList.cxx:300
 TList.cxx:301
 TList.cxx:302
 TList.cxx:303
 TList.cxx:304
 TList.cxx:305
 TList.cxx:306
 TList.cxx:307
 TList.cxx:308
 TList.cxx:309
 TList.cxx:310
 TList.cxx:311
 TList.cxx:312
 TList.cxx:313
 TList.cxx:314
 TList.cxx:315
 TList.cxx:316
 TList.cxx:317
 TList.cxx:318
 TList.cxx:319
 TList.cxx:320
 TList.cxx:321
 TList.cxx:322
 TList.cxx:323
 TList.cxx:324
 TList.cxx:325
 TList.cxx:326
 TList.cxx:327
 TList.cxx:328
 TList.cxx:329
 TList.cxx:330
 TList.cxx:331
 TList.cxx:332
 TList.cxx:333
 TList.cxx:334
 TList.cxx:335
 TList.cxx:336
 TList.cxx:337
 TList.cxx:338
 TList.cxx:339
 TList.cxx:340
 TList.cxx:341
 TList.cxx:342
 TList.cxx:343
 TList.cxx:344
 TList.cxx:345
 TList.cxx:346
 TList.cxx:347
 TList.cxx:348
 TList.cxx:349
 TList.cxx:350
 TList.cxx:351
 TList.cxx:352
 TList.cxx:353
 TList.cxx:354
 TList.cxx:355
 TList.cxx:356
 TList.cxx:357
 TList.cxx:358
 TList.cxx:359
 TList.cxx:360
 TList.cxx:361
 TList.cxx:362
 TList.cxx:363
 TList.cxx:364
 TList.cxx:365
 TList.cxx:366
 TList.cxx:367
 TList.cxx:368
 TList.cxx:369
 TList.cxx:370
 TList.cxx:371
 TList.cxx:372
 TList.cxx:373
 TList.cxx:374
 TList.cxx:375
 TList.cxx:376
 TList.cxx:377
 TList.cxx:378
 TList.cxx:379
 TList.cxx:380
 TList.cxx:381
 TList.cxx:382
 TList.cxx:383
 TList.cxx:384
 TList.cxx:385
 TList.cxx:386
 TList.cxx:387
 TList.cxx:388
 TList.cxx:389
 TList.cxx:390
 TList.cxx:391
 TList.cxx:392
 TList.cxx:393
 TList.cxx:394
 TList.cxx:395
 TList.cxx:396
 TList.cxx:397
 TList.cxx:398
 TList.cxx:399
 TList.cxx:400
 TList.cxx:401
 TList.cxx:402
 TList.cxx:403
 TList.cxx:404
 TList.cxx:405
 TList.cxx:406
 TList.cxx:407
 TList.cxx:408
 TList.cxx:409
 TList.cxx:410
 TList.cxx:411
 TList.cxx:412
 TList.cxx:413
 TList.cxx:414
 TList.cxx:415
 TList.cxx:416
 TList.cxx:417
 TList.cxx:418
 TList.cxx:419
 TList.cxx:420
 TList.cxx:421
 TList.cxx:422
 TList.cxx:423
 TList.cxx:424
 TList.cxx:425
 TList.cxx:426
 TList.cxx:427
 TList.cxx:428
 TList.cxx:429
 TList.cxx:430
 TList.cxx:431
 TList.cxx:432
 TList.cxx:433
 TList.cxx:434
 TList.cxx:435
 TList.cxx:436
 TList.cxx:437
 TList.cxx:438
 TList.cxx:439
 TList.cxx:440
 TList.cxx:441
 TList.cxx:442
 TList.cxx:443
 TList.cxx:444
 TList.cxx:445
 TList.cxx:446
 TList.cxx:447
 TList.cxx:448
 TList.cxx:449
 TList.cxx:450
 TList.cxx:451
 TList.cxx:452
 TList.cxx:453
 TList.cxx:454
 TList.cxx:455
 TList.cxx:456
 TList.cxx:457
 TList.cxx:458
 TList.cxx:459
 TList.cxx:460
 TList.cxx:461
 TList.cxx:462
 TList.cxx:463
 TList.cxx:464
 TList.cxx:465
 TList.cxx:466
 TList.cxx:467
 TList.cxx:468
 TList.cxx:469
 TList.cxx:470
 TList.cxx:471
 TList.cxx:472
 TList.cxx:473
 TList.cxx:474
 TList.cxx:475
 TList.cxx:476
 TList.cxx:477
 TList.cxx:478
 TList.cxx:479
 TList.cxx:480
 TList.cxx:481
 TList.cxx:482
 TList.cxx:483
 TList.cxx:484
 TList.cxx:485
 TList.cxx:486
 TList.cxx:487
 TList.cxx:488
 TList.cxx:489
 TList.cxx:490
 TList.cxx:491
 TList.cxx:492
 TList.cxx:493
 TList.cxx:494
 TList.cxx:495
 TList.cxx:496
 TList.cxx:497
 TList.cxx:498
 TList.cxx:499
 TList.cxx:500
 TList.cxx:501
 TList.cxx:502
 TList.cxx:503
 TList.cxx:504
 TList.cxx:505
 TList.cxx:506
 TList.cxx:507
 TList.cxx:508
 TList.cxx:509
 TList.cxx:510
 TList.cxx:511
 TList.cxx:512
 TList.cxx:513
 TList.cxx:514
 TList.cxx:515
 TList.cxx:516
 TList.cxx:517
 TList.cxx:518
 TList.cxx:519
 TList.cxx:520
 TList.cxx:521
 TList.cxx:522
 TList.cxx:523
 TList.cxx:524
 TList.cxx:525
 TList.cxx:526
 TList.cxx:527
 TList.cxx:528
 TList.cxx:529
 TList.cxx:530
 TList.cxx:531
 TList.cxx:532
 TList.cxx:533
 TList.cxx:534
 TList.cxx:535
 TList.cxx:536
 TList.cxx:537
 TList.cxx:538
 TList.cxx:539
 TList.cxx:540
 TList.cxx:541
 TList.cxx:542
 TList.cxx:543
 TList.cxx:544
 TList.cxx:545
 TList.cxx:546
 TList.cxx:547
 TList.cxx:548
 TList.cxx:549
 TList.cxx:550
 TList.cxx:551
 TList.cxx:552
 TList.cxx:553
 TList.cxx:554
 TList.cxx:555
 TList.cxx:556
 TList.cxx:557
 TList.cxx:558
 TList.cxx:559
 TList.cxx:560
 TList.cxx:561
 TList.cxx:562
 TList.cxx:563
 TList.cxx:564
 TList.cxx:565
 TList.cxx:566
 TList.cxx:567
 TList.cxx:568
 TList.cxx:569
 TList.cxx:570
 TList.cxx:571
 TList.cxx:572
 TList.cxx:573
 TList.cxx:574
 TList.cxx:575
 TList.cxx:576
 TList.cxx:577
 TList.cxx:578
 TList.cxx:579
 TList.cxx:580
 TList.cxx:581
 TList.cxx:582
 TList.cxx:583
 TList.cxx:584
 TList.cxx:585
 TList.cxx:586
 TList.cxx:587
 TList.cxx:588
 TList.cxx:589
 TList.cxx:590
 TList.cxx:591
 TList.cxx:592
 TList.cxx:593
 TList.cxx:594
 TList.cxx:595
 TList.cxx:596
 TList.cxx:597
 TList.cxx:598
 TList.cxx:599
 TList.cxx:600
 TList.cxx:601
 TList.cxx:602
 TList.cxx:603
 TList.cxx:604
 TList.cxx:605
 TList.cxx:606
 TList.cxx:607
 TList.cxx:608
 TList.cxx:609
 TList.cxx:610
 TList.cxx:611
 TList.cxx:612
 TList.cxx:613
 TList.cxx:614
 TList.cxx:615
 TList.cxx:616
 TList.cxx:617
 TList.cxx:618
 TList.cxx:619
 TList.cxx:620
 TList.cxx:621
 TList.cxx:622
 TList.cxx:623
 TList.cxx:624
 TList.cxx:625
 TList.cxx:626
 TList.cxx:627
 TList.cxx:628
 TList.cxx:629
 TList.cxx:630
 TList.cxx:631
 TList.cxx:632
 TList.cxx:633
 TList.cxx:634
 TList.cxx:635
 TList.cxx:636
 TList.cxx:637
 TList.cxx:638
 TList.cxx:639
 TList.cxx:640
 TList.cxx:641
 TList.cxx:642
 TList.cxx:643
 TList.cxx:644
 TList.cxx:645
 TList.cxx:646
 TList.cxx:647
 TList.cxx:648
 TList.cxx:649
 TList.cxx:650
 TList.cxx:651
 TList.cxx:652
 TList.cxx:653
 TList.cxx:654
 TList.cxx:655
 TList.cxx:656
 TList.cxx:657
 TList.cxx:658
 TList.cxx:659
 TList.cxx:660
 TList.cxx:661
 TList.cxx:662
 TList.cxx:663
 TList.cxx:664
 TList.cxx:665
 TList.cxx:666
 TList.cxx:667
 TList.cxx:668
 TList.cxx:669
 TList.cxx:670
 TList.cxx:671
 TList.cxx:672
 TList.cxx:673
 TList.cxx:674
 TList.cxx:675
 TList.cxx:676
 TList.cxx:677
 TList.cxx:678
 TList.cxx:679
 TList.cxx:680
 TList.cxx:681
 TList.cxx:682
 TList.cxx:683
 TList.cxx:684
 TList.cxx:685
 TList.cxx:686
 TList.cxx:687
 TList.cxx:688
 TList.cxx:689
 TList.cxx:690
 TList.cxx:691
 TList.cxx:692
 TList.cxx:693
 TList.cxx:694
 TList.cxx:695
 TList.cxx:696
 TList.cxx:697
 TList.cxx:698
 TList.cxx:699
 TList.cxx:700
 TList.cxx:701
 TList.cxx:702
 TList.cxx:703
 TList.cxx:704
 TList.cxx:705
 TList.cxx:706
 TList.cxx:707
 TList.cxx:708
 TList.cxx:709
 TList.cxx:710
 TList.cxx:711
 TList.cxx:712
 TList.cxx:713
 TList.cxx:714
 TList.cxx:715
 TList.cxx:716
 TList.cxx:717
 TList.cxx:718
 TList.cxx:719
 TList.cxx:720
 TList.cxx:721
 TList.cxx:722
 TList.cxx:723
 TList.cxx:724
 TList.cxx:725
 TList.cxx:726
 TList.cxx:727
 TList.cxx:728
 TList.cxx:729
 TList.cxx:730
 TList.cxx:731
 TList.cxx:732
 TList.cxx:733
 TList.cxx:734
 TList.cxx:735
 TList.cxx:736
 TList.cxx:737
 TList.cxx:738
 TList.cxx:739
 TList.cxx:740
 TList.cxx:741
 TList.cxx:742
 TList.cxx:743
 TList.cxx:744
 TList.cxx:745
 TList.cxx:746
 TList.cxx:747
 TList.cxx:748
 TList.cxx:749
 TList.cxx:750
 TList.cxx:751
 TList.cxx:752
 TList.cxx:753
 TList.cxx:754
 TList.cxx:755
 TList.cxx:756
 TList.cxx:757
 TList.cxx:758
 TList.cxx:759
 TList.cxx:760
 TList.cxx:761
 TList.cxx:762
 TList.cxx:763
 TList.cxx:764
 TList.cxx:765
 TList.cxx:766
 TList.cxx:767
 TList.cxx:768
 TList.cxx:769
 TList.cxx:770
 TList.cxx:771
 TList.cxx:772
 TList.cxx:773
 TList.cxx:774
 TList.cxx:775
 TList.cxx:776
 TList.cxx:777
 TList.cxx:778
 TList.cxx:779
 TList.cxx:780
 TList.cxx:781
 TList.cxx:782
 TList.cxx:783
 TList.cxx:784
 TList.cxx:785
 TList.cxx:786
 TList.cxx:787
 TList.cxx:788
 TList.cxx:789
 TList.cxx:790
 TList.cxx:791
 TList.cxx:792
 TList.cxx:793
 TList.cxx:794
 TList.cxx:795
 TList.cxx:796
 TList.cxx:797
 TList.cxx:798
 TList.cxx:799
 TList.cxx:800
 TList.cxx:801
 TList.cxx:802
 TList.cxx:803
 TList.cxx:804
 TList.cxx:805
 TList.cxx:806
 TList.cxx:807
 TList.cxx:808
 TList.cxx:809
 TList.cxx:810
 TList.cxx:811
 TList.cxx:812
 TList.cxx:813
 TList.cxx:814
 TList.cxx:815
 TList.cxx:816
 TList.cxx:817
 TList.cxx:818
 TList.cxx:819
 TList.cxx:820
 TList.cxx:821
 TList.cxx:822
 TList.cxx:823
 TList.cxx:824
 TList.cxx:825
 TList.cxx:826
 TList.cxx:827
 TList.cxx:828
 TList.cxx:829
 TList.cxx:830
 TList.cxx:831
 TList.cxx:832
 TList.cxx:833
 TList.cxx:834
 TList.cxx:835
 TList.cxx:836
 TList.cxx:837
 TList.cxx:838
 TList.cxx:839
 TList.cxx:840
 TList.cxx:841
 TList.cxx:842
 TList.cxx:843
 TList.cxx:844
 TList.cxx:845
 TList.cxx:846
 TList.cxx:847
 TList.cxx:848
 TList.cxx:849
 TList.cxx:850
 TList.cxx:851
 TList.cxx:852
 TList.cxx:853
 TList.cxx:854
 TList.cxx:855
 TList.cxx:856
 TList.cxx:857
 TList.cxx:858
 TList.cxx:859
 TList.cxx:860
 TList.cxx:861
 TList.cxx:862
 TList.cxx:863
 TList.cxx:864
 TList.cxx:865
 TList.cxx:866
 TList.cxx:867
 TList.cxx:868
 TList.cxx:869
 TList.cxx:870
 TList.cxx:871
 TList.cxx:872
 TList.cxx:873
 TList.cxx:874
 TList.cxx:875
 TList.cxx:876
 TList.cxx:877
 TList.cxx:878
 TList.cxx:879
 TList.cxx:880
 TList.cxx:881
 TList.cxx:882
 TList.cxx:883
 TList.cxx:884
 TList.cxx:885
 TList.cxx:886
 TList.cxx:887
 TList.cxx:888
 TList.cxx:889
 TList.cxx:890
 TList.cxx:891
 TList.cxx:892
 TList.cxx:893
 TList.cxx:894
 TList.cxx:895
 TList.cxx:896
 TList.cxx:897
 TList.cxx:898
 TList.cxx:899
 TList.cxx:900
 TList.cxx:901
 TList.cxx:902
 TList.cxx:903
 TList.cxx:904
 TList.cxx:905
 TList.cxx:906
 TList.cxx:907
 TList.cxx:908
 TList.cxx:909
 TList.cxx:910
 TList.cxx:911
 TList.cxx:912
 TList.cxx:913
 TList.cxx:914
 TList.cxx:915
 TList.cxx:916
 TList.cxx:917
 TList.cxx:918
 TList.cxx:919
 TList.cxx:920
 TList.cxx:921
 TList.cxx:922
 TList.cxx:923
 TList.cxx:924
 TList.cxx:925
 TList.cxx:926
 TList.cxx:927
 TList.cxx:928
 TList.cxx:929
 TList.cxx:930
 TList.cxx:931
 TList.cxx:932
 TList.cxx:933
 TList.cxx:934
 TList.cxx:935
 TList.cxx:936
 TList.cxx:937
 TList.cxx:938
 TList.cxx:939
 TList.cxx:940
 TList.cxx:941
 TList.cxx:942
 TList.cxx:943
 TList.cxx:944
 TList.cxx:945
 TList.cxx:946
 TList.cxx:947
 TList.cxx:948
 TList.cxx:949
 TList.cxx:950
 TList.cxx:951
 TList.cxx:952
 TList.cxx:953
 TList.cxx:954
 TList.cxx:955
 TList.cxx:956
 TList.cxx:957
 TList.cxx:958
 TList.cxx:959
 TList.cxx:960
 TList.cxx:961
 TList.cxx:962
 TList.cxx:963
 TList.cxx:964
 TList.cxx:965
 TList.cxx:966
 TList.cxx:967
 TList.cxx:968
 TList.cxx:969
 TList.cxx:970
 TList.cxx:971
 TList.cxx:972
 TList.cxx:973
 TList.cxx:974
 TList.cxx:975
 TList.cxx:976
 TList.cxx:977
 TList.cxx:978
 TList.cxx:979
 TList.cxx:980
 TList.cxx:981
 TList.cxx:982
 TList.cxx:983
 TList.cxx:984
 TList.cxx:985
 TList.cxx:986
 TList.cxx:987
 TList.cxx:988
 TList.cxx:989
 TList.cxx:990
 TList.cxx:991
 TList.cxx:992
 TList.cxx:993
 TList.cxx:994
 TList.cxx:995
 TList.cxx:996
 TList.cxx:997
 TList.cxx:998
 TList.cxx:999
 TList.cxx:1000
 TList.cxx:1001
 TList.cxx:1002
 TList.cxx:1003
 TList.cxx:1004
 TList.cxx:1005
 TList.cxx:1006
 TList.cxx:1007
 TList.cxx:1008
 TList.cxx:1009
 TList.cxx:1010
 TList.cxx:1011
 TList.cxx:1012
 TList.cxx:1013
 TList.cxx:1014
 TList.cxx:1015
 TList.cxx:1016
 TList.cxx:1017
 TList.cxx:1018
 TList.cxx:1019
 TList.cxx:1020
 TList.cxx:1021
 TList.cxx:1022
 TList.cxx:1023
 TList.cxx:1024
 TList.cxx:1025
 TList.cxx:1026
 TList.cxx:1027
 TList.cxx:1028
 TList.cxx:1029
 TList.cxx:1030
 TList.cxx:1031
 TList.cxx:1032
 TList.cxx:1033
 TList.cxx:1034
 TList.cxx:1035
 TList.cxx:1036
 TList.cxx:1037
 TList.cxx:1038
 TList.cxx:1039
 TList.cxx:1040
 TList.cxx:1041
 TList.cxx:1042
 TList.cxx:1043
 TList.cxx:1044
 TList.cxx:1045
 TList.cxx:1046
 TList.cxx:1047
 TList.cxx:1048
 TList.cxx:1049
 TList.cxx:1050
 TList.cxx:1051
 TList.cxx:1052
 TList.cxx:1053
 TList.cxx:1054
 TList.cxx:1055
 TList.cxx:1056
 TList.cxx:1057
 TList.cxx:1058
 TList.cxx:1059
 TList.cxx:1060
 TList.cxx:1061
 TList.cxx:1062
 TList.cxx:1063
 TList.cxx:1064
 TList.cxx:1065
 TList.cxx:1066
 TList.cxx:1067
 TList.cxx:1068
 TList.cxx:1069
 TList.cxx:1070
 TList.cxx:1071
 TList.cxx:1072
 TList.cxx:1073
 TList.cxx:1074
 TList.cxx:1075
 TList.cxx:1076
 TList.cxx:1077
 TList.cxx:1078
 TList.cxx:1079
 TList.cxx:1080
 TList.cxx:1081
 TList.cxx:1082
 TList.cxx:1083
 TList.cxx:1084
 TList.cxx:1085
 TList.cxx:1086
 TList.cxx:1087