// @(#)root/table:$Id$
// Author: Valery Fine(fine@mail.cern.ch)   03/07/98

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

#include "Riosfwd.h"
#include "Riostream.h"

#include "TDataSetIter.h"
#include "TBrowser.h"
#include "TSystem.h"

#ifndef WIN32
# ifndef HASSTRCASE
#  define HASSTRCASE
# endif
#endif

#ifndef HASSTRCASE
#  define strcasecmp(arg1,arg2) stricmp(arg1,arg2)
#endif

TDataSet *TDataSetIter::fgNullDataSet = (TDataSet *)(-1);

ClassImp(TDataSetIter)

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDataSetIter                                                         //
//                                                                      //
// TDataSetIter is a class iterator to navigate TDataSet objects        //
// via 4 internal pointers :                                            //
//                                                                      //
//  1. fRootDataSet    - "root" dataset                                 //
//  2. fWorkingDataSet - Working dataset                                //
//  3. fDataSet        - the last selected TDataSet                     //
//  4. fNext           - TIter for the the list of the "root" dataset   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TDataSetIter::TDataSetIter(TDataSet *link, Bool_t dir)
{
   //to be documented
   fWorkingDataSet= fRootDataSet   =link;
   fMaxDepth      = fDepth         =1;
   fDataSet= fgNullDataSet ;
   fNext = link ? new TIter(link->GetCollection() ,dir):0;
   for(UInt_t i = 0; i < sizeof(fNextSet) / sizeof(TIter*); ++i) {
      fNextSet[i] = (TIter*)0;
   }
}

//______________________________________________________________________________
TDataSetIter::TDataSetIter(TDataSet *link, Int_t depth, Bool_t dir)
{
   //to be documented
   fRootDataSet = fWorkingDataSet = link;
   fMaxDepth    = depth;
   fDepth       = 1;
   fDataSet     = fgNullDataSet;
   fNext        = (link)? new TIter(link->GetCollection() ,dir):0;

   // Create a DataSet iterator to pass all nodes of the
   //     "depth"  levels
   //  of  TDataSet *link

   for(UInt_t i = 0; i < sizeof(fNextSet) / sizeof(TIter*); ++i) {
      fNextSet[i] = (TIter*)0;
   }
   if (fMaxDepth != 1) {
      fNextSet[0] = fNext;
      if (fMaxDepth > 100) fMaxDepth = 100;
      fDepth = 0;
   }
}

//______________________________________________________________________________
TDataSetIter::~TDataSetIter()
{
   //to be documented
   if (fMaxDepth != 1) {
      Int_t level = fDepth;
      if (level) level--;
      for (Int_t i = level;i>=0;i--) {
         TIter *s = fNextSet[i];
         if (s) delete s;
      }
   }
   else
      SafeDelete(fNext);
   fDepth = 0;
}


//______________________________________________________________________________
TDataSet *TDataSetIter::operator *() const
{
   //operator *
   return fDataSet == fgNullDataSet ? fWorkingDataSet : fDataSet;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::GetNullSet()
{
   // return a fake pointer == -1 casted to (TDataSet *)
   return (TDataSet *)fgNullDataSet;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Add(TDataSet *set, TDataSet *dataset)
{
   ///////////////////////////////////////////////////////////////////////////////
   //                                                                           //
   // Add - adds the set to the dataset defined with the second parameters      //
   //                                                                           //
   // TDataSet dataset != 0 - Add the set to the TDataSet *dataset              //
   //                                                                           //
   //                     = 0 - (by default) to the current TDataSet defined    //
   //                          with fWorkingDataSet data member                 //
   //                                                                           //
   //  returns  the pointer to set is success or ZERO poiner                    //
   //  =======                                                                  //
   //                                                                           //
   //  Note: If this TDataSetIter is empty (i.e. Cwd() returns 0), the "set"    //
   //        becomes the "root" dataset of this iterator                        //                                                                         //
   ///////////////////////////////////////////////////////////////////////////////

   if (!set) return 0;
   TDataSet *s =  dataset;
   if (!s) s = Cwd();
   if (s) {
      s->Add(set);
      s = set;
   }
   else {
      //  make the coming dataset the current one for the iterator
      s = set;
      fRootDataSet    = s;
      fWorkingDataSet = s;
      if (fNext) {
         Error("Add","TDataSetIter.has been corrupted ;-!");
         delete fNext;
         fNext = 0;
      }
      fNext = new TIter(s->GetCollection() );
   }
   return s;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Add(TDataSet *dataset, const Char_t *path)
{
   ///////////////////////////////////////////////////////////////////////////////
   //                                                                           //
   // Add                                                                       //
   //                                                                           //
   // Char_t path != 0 - Add a TDataSet dataset to the TDataSet dataset         //
   //                    defined with "path"                                    //
   //              = 0 - (by default) to the current TDataSet defined           //
   //                     with fWorkingDataSet data member                      //
   //                                                                           //
   //  returns the dataset is success or ZERO pointer                           //
   //  =======                                                                  //
   //                                                                           //
   ///////////////////////////////////////////////////////////////////////////////
   if (!dataset) return 0;
   TDataSet *set = 0;
   if (path && strlen(path)) set = Find(path);
   return Add(dataset,set);
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Cd(const Char_t *dirname){
   /////////////////////////////////////////////////////////////////////
   //                                                                 //
   // TDataSet *TDataSetIter::Cd(const Char_t *dirname)               //
   //                                                                 //
   // Change the current working directory to dirname                 //
   //                                                                 //
   // Returns the pointer to the new "working" TDataSet               //
   // =======   0,  if the new directory doesn't exist.               //
   //                                                                 //
   // Remark:  The name = ".." has a special meaning.                 //
   // ------   TDataSetIter::Cd("..") returns the parent set          //
   //          But one still can not use ".." as a legal part         //
   //          of the full path                                       //
   /////////////////////////////////////////////////////////////////////
   TDataSet *set = 0;
   if (strcmp(dirname,".."))
      set =  Find(dirname);
   else
      set = fWorkingDataSet->GetParent();
   if (set) fWorkingDataSet = set;
   return set;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Cd(TDataSet *ds)
{
   /////////////////////////////////////////////////////////////////////
   //                                                                 //
   // TDataSet *TDataSetIter::Cd(const TDataSet *ds)                  //
   //                                                                 //
   // Make:  Cwd() = ds;                                              //
   // Look for the first occurence of the "ds" pointer for the current//
   // TDataSet in respect of the Cwd() if any                         //
   //                                                                 //
   // Change the current working directory to ds if present           //
   //                                                                 //
   // Returns the pointer to the new "working" TDataSet (i.e. ds)     //
   // =======   0,  if the new directory doesn't exist.               //
   //                                                                 //
   /////////////////////////////////////////////////////////////////////
   TDataSet *nextSet = 0;
   if (Cwd()) {
      TDataSetIter next(Cwd(),0);
      while ( (nextSet = next()) )
         if (ds == nextSet) {fWorkingDataSet = ds; break;}
   }
   return nextSet;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Dir(Char_t *dirname)
{
   //
   // Print the names of the TDataSet objects for the datatset named with "dirname"
   // apart of TDataSet::Ls()  this method prints one level only
   //
   TDataSet *set = (TDataSet *)fWorkingDataSet;
   if (dirname) set = Find(dirname);
   if (set) set->ls();
   return set;
}

//______________________________________________________________________________
Int_t TDataSetIter::Du() const {
   // summarize dataset usage by Herb Ward proposal
   if (!fWorkingDataSet) return 0;
   TDataSetIter next(fWorkingDataSet,0);
   TDataSet *nextset = 0;
   Int_t count = 0;
   while((nextset = (count) ? next():fWorkingDataSet)) {
      count++;
      if (nextset->IsFolder()) std::cout << std::endl;
      TString path = nextset->Path();
      std::cout << std::setw(2) << next.GetDepth() << ". ";
      std::cout << path << std::setw(TMath::Max(Int_t(60-strlen(path.Data())),Int_t(0))) << "...";
      const Char_t *type = nextset->IsFolder() ? "directory" : "table" ;
      std::cout << std::setw(10) << type;
      std::cout  << " : " << std::setw(10) << nextset->GetTitle();
      std::cout << std::endl;
   }
   return count;
}

//______________________________________________________________________________
TDataSet  *TDataSetIter::FindByName(const Char_t *name,const Char_t *path,Option_t *opt)
{
   //to be documented
   return FindDataSet(name,path,opt);
}

//______________________________________________________________________________
TDataSet  *TDataSetIter::FindByTitle(const Char_t *title,const Char_t *path,Option_t *opt)
{
   //to be documented
   TString optt = "-t";
   optt += opt;
   return FindDataSet(title,path,optt.Data());
}

//______________________________________________________________________________
TDataSet *TDataSetIter::FindDataSet(const Char_t *name,const Char_t *path,Option_t *opt)
{
   //
   // FindDataSet looks for the object with the name supplied across dataset.
   //
   // name        - the "base" name title (with no path) of the TDataSet (see: opt = -t)
   // path        - path to start the search from (the current dataset "by default")
   // opt = "-i"  - case insensitive search
   //       "-t"  - first <name> parameter defines the object "title" rather the object "name"
   //
   // Note: If the name provided is not unique
   //       the first found is returned.
   //

   if (!name || !name[0]) return 0;
   if (strchr(name,'/')) {
      Error("FindDataSet","The name of the object <%s> can not contain any \"/\"",name);
      return 0;
   }

   Bool_t opti = opt ? strcasecmp(opt,"-i") == 0 : kFALSE;
   Bool_t optt = opt ? strcasecmp(opt,"-t") == 0 : kFALSE;

   TDataSet *startset = 0;
   if (path && strlen(path)) startset = Find(path);
   else                      startset = fWorkingDataSet;
   if (!startset) return 0;

   TDataSet *set = startset;
   if ( !((opti && strcasecmp( optt ? set->GetTitle() : set->GetName(),name) == 0 ) ||
      (strcmp(optt ? set->GetTitle() : set->GetName(),name) == 0)) )
   {
      TDataSetIter next(startset,0);
      while ((set = next()))
         if ( (opti && strcasecmp(optt ? set->GetTitle() : set->GetName(),name) == 0 ) ||
            (strcmp(optt ? set->GetTitle() : set->GetName(),name) == 0) )           break;
   }

   return set;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::FindDataSet(TDataSet *set,const Char_t *path,Option_t *opt)
{
   //
   // Check whether the object does belong the TDataSet defined with "path"
   // opt = "-l"  - check the "reference" links only
   //       "-s"  - check the "structural" links only
   //             = "by default" - checks all links
   //
   if (!set) return 0;
   if (opt) {/* no used */}

   TDataSet *startset = 0;
   if (path) startset = Find(path);
   else      startset = fWorkingDataSet;
   if (!startset) return 0;

   TDataSetIter next(startset);
   TDataSet *nextSet = 0;
   while ( (nextSet = next()) )
      if (set == nextSet) break;

   return nextSet;
}
//______________________________________________________________________________
TObject *TDataSetIter::FindObject(const Char_t *name) const
{
   // This method is not recommended.
   // It is done to back TObject::FindObject method only.
   // One is recommnened to use FindByName method instead.
   return ((TDataSetIter *)this)->FindByName(name);
}

//______________________________________________________________________________
TObject  *TDataSetIter::FindObject(const TObject *dataset) const
{
   // This method is not recommended.
   // It is done to back TObject::FindObject method only.
   // One is recommended to use FindByName method instead.
   return ((TDataSetIter *)this)->FindByPointer((TDataSet *)dataset);
}
//______________________________________________________________________________
TDataSet *TDataSetIter::FindByPointer(TDataSet *set,const Char_t *path,Option_t *)
{
   //
   // Check whether the object does belong the TDataSet defined with "path"
   // opt = "-l"  - check the "reference" links only
   //       "-s"  - check the "structural" links only
   //             = "by default" - checks all links
   //
   if (!set) return 0;

   TDataSet *startset = 0;
   if (path && path[0]) startset = Find(path);
   else      startset = fWorkingDataSet;
   if (!startset) return 0;

   TDataSetIter next(startset);
   TDataSet *nextSet = 0;
   while ( (nextSet = next()) )
      if (set == nextSet) break;

   return nextSet;
}

//______________________________________________________________________________
Int_t TDataSetIter::Flag(const Char_t *path,UInt_t flag,TDataSet::EBitOpt reset)
{
   //to be documented
   TDataSet *set = Find(path);
   if (set) set->SetBit(flag,reset);
   return 0;
}
//______________________________________________________________________________
Int_t TDataSetIter::Flag(TDataSet *dataset,UInt_t flag,TDataSet::EBitOpt reset)
{
   //to be documented
   if (dataset) dataset->SetBit(flag,reset);
   return 0;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Ls(const Char_t *dirname,Option_t *opt) const {
   //
   //   Ls(const Char_t *dirname,Option_t)
   //
   //   Prints the list of the TDataSet defined with dirname
   //
   //   dirname     = 0   - prints the current dataset
   //   dirname[0]  = '/' - print TDataSet defined with dirname
   //   dirname[0] != '/' - prints DataSet with respect of the current class
   //

   TDataSet *set= 0;
   if (dirname && strlen(dirname)) set = ((TDataSetIter*)this)->Find(dirname);
   if (!set && dirname==0) set=Cwd();
   if (set) set->ls(opt);
   return set;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Ls(const Char_t *dirname,Int_t depth) const {
   //
   //   Ls(const Char_t *dirname,Int_t depth)
   //
   //   Prints the list of the TDataSet defined with dirname
   //   Returns the dataset defined by "path" or Cwd();
   //
   //   dirname     = 0   - prints the current dataset
   //   dirname[0]  = '/' - print TDataSet defined with dirname
   //   dirname[0] != '/' - prints DataSet with respect of the current class
   //
   //   depth       = 0   - print all level of the TDataSet defined with dirname
   //               > 0   - print depth levels at most of the dirname TDataSet
   //
   TDataSet *set= fWorkingDataSet;
   if (dirname && strlen(dirname)) set= ((TDataSetIter*)this)->Find(dirname);
   if (set) set->ls(depth);
   return set;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Mkdir(const Char_t *dirname)
{
   //to be documented
   TDataSet *set = 0;
   set = Find(dirname,0,kTRUE);
   if (!fNext)  Reset();  // Create a new iterator
   // If this dataset is first one then make it the root and working
   if (!fRootDataSet ) fRootDataSet  = set;
   if (!fWorkingDataSet) fWorkingDataSet = fRootDataSet;
   return set;
}

//______________________________________________________________________________
void TDataSetIter::Notify(TDataSet *)
{
   //
   //  Notify(TDataSet *dataset)
   //
   //  This dummy method is called when TDataSetIter::Find dives in "dataset"
   //  to look for thew next level of the dataset's
   //  printf("void TDataSetIter::Notify(TDataSet *) level: %d %s\n",fDepth,ds->GetName());
   //
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Rmdir(TDataSet *dataset,Option_t *)
{
   //
   //  Remove the TDataSet *dataset from the current dataset
   //  If the current dataset is the deleted dataset the its parent
   //  becomes the "current dataset" or 0 if this dataset has no parent.
   //
   //  returns: the "current dataset" pointer
   //
   //
   TDataSet *set = dataset;
   if (set) {
      if (set == fWorkingDataSet) {
         fWorkingDataSet = set->GetParent();
      }
      if (set == fRootDataSet) {
         fRootDataSet = 0;
      }
      delete set;
   }
   return Cwd();
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Next( TDataSet::EDataSetPass mode)
{
   ////////////////////////////////////////////////////////////////////////////////
   //
   // returns the pointer the "next" TDataSet object
   //         = 0 if all objects have been returned.
   //
   //  mode = kContinue  - default normal mode
   //         kPrune     - stop passing of the current branch but continue with the next one if any
   //         kUp        - break passing, return to the previous level, then continue
   //         all other  - are treated as "kContinue"
   //
   ////////////////////////////////////////////////////////////////////////////////

   if (fMaxDepth==1) fDataSet = fNext ? NextDataSet(*fNext) :0;
   else {
      // Check the whether the next level does exist
      if (fDepth==0) fDepth = 1;
      if (fDataSet && fDataSet != fgNullDataSet &&
         (fDepth < fMaxDepth || fMaxDepth ==0) && mode == TDataSet::kContinue )
      {
         // create the next level iterator, go deeper
         TSeqCollection *list  = fDataSet->GetCollection();
         // Look for the next level
         if (list && list->GetSize() ) {
            fDepth++;
            if (fDepth >= 100) {
               Error("Next()"
                  ," too many (%d) nested levels of your TDataSet has been detected",fDepth);
               return 0;
            }
            fNextSet[fDepth-1] = new TIter(list);
         }
      }

      // Pick the next object of the current level
      TIter *next = fNextSet[fDepth-1];
      if (next) {
         fDataSet = 0;
         if (mode != TDataSet::kUp) fDataSet = NextDataSet(*next);

         // Go upstair if the current one has been escaped
         if (!fDataSet) {
            // go backwards direction
            while (!fDataSet && fDepth > 1) {
               fDepth--;
               delete next;
               next =  fNextSet[fDepth-1];
               TDataSet *set = NextDataSet(*next);
               if (set)
                  fDataSet = set;
            }
         }
      }
   }
   return (TDataSet *)fDataSet;
}
//______________________________________________________________________________
TDataSet *TDataSetIter::NextDataSet(TIter &next)
{
   //to be documented
   TDataSet *ds = (TDataSet *)next();
   if (ds) Notify(ds);
   return ds;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::NextDataSet(Int_t nDataSet)
{
   // Pick the next object of the  level provided
   TIter *next = fNextSet[nDataSet];
   if (next) return NextDataSet(*next);
   return 0;
}
//______________________________________________________________________________
TDataSet  *TDataSetIter::FindByPath(const Char_t *path, TDataSet *rootset,Bool_t mkdir)
{
   //to be documented
   return Find(path,rootset,mkdir);
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Find(const Char_t *path, TDataSet *rootset,
                             Bool_t mkdirflag,Bool_t titleFlag)
{
   ////////////////////////////////////////////////////////////////////////////////
   //                                                                            //
   //     titleFlag = kFALSE; use object name as key (by default)                //
   //                 kTRUE;  use object title as key  and ignore mkdirFlag      //
   //                                                                            //
   //           "path" ::= <relative path> | <absolute path> | <empty>           //
   //                                                                            //
   //  "relative path" ::= <dataset name> | <dataset name>/<dataset name>        //
   //                                                                            //
   //  "absolute path" ::= /<relative path>                                      //
   //  "empty"         ::= zero pointer | pointer to zero length string          //
   //                                                                            //
   // "relative path": the search is done against of fWorkingDataSet data mem    //
   // "absolute path": the search is done against of fRootDataSet    data mem    //
   // "empty path"   : no search is done just next TDataSet is returned if any   //
   //                                                                            //
   //  Remark: This version can not treat any "special name" like "..", ".", etc //
   //  ------                                                                    //
   ////////////////////////////////////////////////////////////////////////////////
   TDataSet *dataset=0,*dsnext=0,*ds=0;
   Int_t len=0,nextlen=0,yes=0,anywhere=0,rootdir=0;
   const Char_t *name=0,*nextname=0;
   TSeqCollection *tl=0;

   name = path;
   if (!name) return rootset;
   dataset = rootset;
   if (!dataset) {// Starting point
      rootdir = 1999;
      dataset = (path[0]=='/') ? fRootDataSet:fWorkingDataSet;}

   if (name[0] == '/') name++;

   if (!strncmp(name,".*/",3)) {anywhere=1998; name +=3;}

   len = strcspn(name," /");
   if (!len) return dataset;

   if (!dataset) goto NOTFOUND;

   //      Check name of root directory
   if (rootdir)
   {
      nextname = titleFlag ? dataset->GetTitle() : dataset->GetName();
      nextlen  = strlen(nextname);
      if (nextlen==len && !strncmp(name,nextname,len))
         return Find(name+len,dataset,mkdirflag,titleFlag);
   }

   tl = dataset->GetCollection();
   if (tl) {
      TIter next(tl);
      while ( (dsnext = NextDataSet(next)) )
      { //horisontal loop
         nextname = titleFlag ? dataset->GetTitle() : dsnext->GetName();
         if (!nextname)  continue;
         yes = name[0]=='*';     // wildcard test
         if (!yes) {             // real     test
            nextlen  = strlen(nextname);
            yes = (len == nextlen);
            if (yes)
               yes = !strncmp(name,nextname,len);
         }

         if (yes)
         {//go down
            if (fDepth == 0) fDepth = 1;
            Notify(dsnext);
            fDepth++;
            ds = Find(name+len,dsnext,mkdirflag,titleFlag);
            fDepth--;
            if (ds)
               return ds;
         }

         if (!anywhere) continue;        // next horizontal
         ds = Find(name,dsnext,mkdirflag,titleFlag);
         if (ds)
            return ds;
      }                                  // end of while
   }

NOTFOUND:
   if (mkdirflag && !titleFlag)
   {
      // create dir the same type as the type of the fRootDataSet if present
      // Create TDataSet by default.
      char buf[512];buf[0]=0; strncat(buf,name,len);
      if (!fRootDataSet)
         ds = new TDataSet(buf);
      else {
         ds = fRootDataSet->Instance();
         ds->SetName(buf);
      }

      if (!fRootDataSet)         fRootDataSet    = ds;
      if (!fWorkingDataSet)      fWorkingDataSet = ds;
      if (dataset)
         dataset->Add(ds);
      else {
         dataset = ds;
         name +=len;
      }

      return Find(name,dataset,mkdirflag);
   }

   return 0;
}
//______________________________________________________________________________
void TDataSetIter::Reset(TDataSet *l, int depth)
{
   //
   // TDataSet *l != 0 means the new start pointer
   //    depth      != 0 means the new value for the depth
   //                    otherwise the privious one is used;
   //
   fDataSet = fgNullDataSet;
   if (fMaxDepth != 1) {
      // clean all interators
      Int_t level = fDepth;
      if (level) level--;
      for (int i = level;i>=0;i--) {
         TIter *s = fNextSet[i];
         if (s) delete s;
      }
      fNext = 0; // this iterator has been deleted in the loop above
   }

   fDepth = 0;

   if (l) {
      fRootDataSet    = l;
      fWorkingDataSet = l;
      SafeDelete(fNext);
      if (fRootDataSet->GetCollection() )
         fNext = new TIter(fRootDataSet->GetCollection() );
   }
   else {
      fWorkingDataSet = fRootDataSet;
      if (fNext)
         fNext->Reset();
      else if (fRootDataSet && fRootDataSet->GetCollection() )
         fNext = new TIter(fRootDataSet->GetCollection() );
   }
   // set the new value of the maximum depth to bypass
   if (depth) fMaxDepth = depth;
}
//______________________________________________________________________________
TDataSet *TDataSetIter::Shunt(TDataSet *set, TDataSet *dataset)
{
   ///////////////////////////////////////////////////////////////////////////////
   //                                                                           //
   // Shunt - moves the set to the dataset defined with the second parameters   //
   //                                                                           //
   // TDataSet dataset != 0 - Add the set to the TDataSet *dataset              //
   //                                                                           //
   //                     = 0 - (by default) to the current TDataSet defined    //
   //                          with fWorkingDataSet data member                 //
   //                                                                           //
   //  returns  the pointer to set if successful or ZERO pointer                //
   //  =======                                                                  //
   //                                                                           //
   //  Note: If this TDataSetIter is empty (i.e. Cwd() returns 0), the "set"    //
   //        becomes the "root" dataset of this iterator                        //                                                                         //
   ///////////////////////////////////////////////////////////////////////////////

   if (!set) return 0;
   TDataSet *s =  dataset;
   if (!s) s = Cwd();
   if (s) {
      s->Shunt(set);
      s = set;
   }
   else {
      //  make the coming dataset the current one for the iterator
      s = set;
      fRootDataSet    = s;
      fWorkingDataSet = s;
      if (fNext) {
         Error("Shunt","TDataSetIter.has been corrupted ;-!");
         delete fNext;
         fNext = 0;
      }
      fNext = new TIter(s->GetCollection() );
   }
   return s;
}

//______________________________________________________________________________
TDataSet *TDataSetIter::Shunt(TDataSet *dataset, const Char_t *path)
{
   ///////////////////////////////////////////////////////////////////////////////
   //                                                                           //
   // Shunt                                                                     //
   //                                                                           //
   // Char_t path != 0 - Move a TDataSet dataset from its parent to             //
   //                    the TDataSet dataset                                   //
   //                    defined with "path"                                    //
   //              = 0 - (by default) to the current TDataSet defined           //
   //                    with fWorkingDataSet data member                       //
   //                                                                           //
   //  returns the dataset is success or ZERO pointer                           //
   //  =======                                                                  //
   //                                                                           //
   ///////////////////////////////////////////////////////////////////////////////
   if (!dataset) return 0;
   TDataSet *set = 0;
   if (path && strlen(path)) set = Find(path);
   return Shunt(dataset,set);
}

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