// @(#)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 "Riostream.h"
#include "TSystem.h"
#include "TDataSetIter.h"
#include "TDataSet.h"

#include "TROOT.h"
#include "TBrowser.h"

#include "TSystem.h"
#include <assert.h>

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDataSet                                                             //
//                                                                      //
// TDataSet class is to create a special compound object-container:     //
//                                                                      //
// ==================================================================== //
//    TDataSet object ::= the "named" list of TDataSet objects          //
// ==================================================================== //
// where the "list" (the pointer to TList object) may contain no object //
//                                                                      //
//  TDataSet object has a back pointer to its "parent" TDataSet         //
//  object, the "character" *name* and "character" *title*              //
//                                                                      //
//  The service this class does provide is to help the user to build    //
//  and manage the hierarchy of their data but the data itself.         //
//                                                                      //
//  So it is not "Container" itself rather the basement (base class)    //
//  to built the containers.                                            //
//                                                                      //
//  One may derive the custom container classes from TDataSet.          //
//  See for example TObjectSet, TTable, TVolume, TFileSet               //
//  These classes  derived from TDataSet:                               //
//                                                                      //
//   Class Name                                                         //
//   ----------                                                         //
//  TObjectSet::public TDataSet - is a container for TObject            //
//  TTable::    public TDataSet - is a container for the array          //
//                                    of any "plain" C-structure        //
//  TNode::     public TDataSet - is a container for 3D objects         //
//  TMaker::     public TDataSet - is a container for STAR "control"    //
//                                    objects                           //
//   etc etc                                                            //
//                                                                      //
//  TDataSet class is a base class to implement the directory-like      //
//  data structures and maintain it via TDataSetIter class iterator     //
//                                                                      //
// TDataSet can be iterated using an iterator object (see TDataSetIter) //
//            or by TDataSet::Pass method (see below)                   //
//                                                                      //
//  Terms:    Dataset       - any object from the list above            //
//  =====     Member          is called "DataSet Member"                //
//                                                                      //
//          Structural      - the "Dataset Member" is its               //
//            member          "Structural member" if its "back pointer" //
//                            points to this object                     //
//                                                                      //
//           Dataset        - we will say this TDataSet object "OWNs"   //
//            Owner           (or is an OWNER / PARENT of ) another     //
//          (parent)          TDataSet object if the last one is its    //
//                            "Structural Member"                       //
//                                                                      //
//          Associated      - If some object is not "Structural member" //
//            member          of this object we will say it is an       //
//                            "Associated Member" of this dataset       //
//                                                                      //
//           Orphan         - If some dataset is a member of NO other   //
//           dataset          TDataSet object it is called an "orphan"  //
//                            dataset object                            //
//                                                                      //
// - Any TDataSet object may be "Owned" by one and only one another     //
//   TDataSet object if any.                                            //
//                                                                      //
// - Any TDataSet object can be the "Structural Member" of one and      //
//   only one another TDataSet                                          //
//                                                                      //
// - Any TDataSet object may be an "Associated Member" for any number   //
//   of other TDataSet objects if any                                   //
//                                                                      //
// - NAME issue:                                                        //
//   Each "dataset member" is in possession of some "alpha-numerical"   //
//   NAME as defined by TNamed class.                                   //
//   The NAME may contain any "printable" symbols but "SLASH" - "/"     //
//   The symbol "RIGHT SLASH" - "/" can not be used as any part of the  //
//   "DataSet Member" NAME                                              //
//    Any DataSet  can be found by its NAME with TDataSetIter object    //
//                                                                      //
// - TITLE issue:                                                       //
//   Each "dataset member" is in possession of the "alpha-numerical"    //
//   TITLE as defined by TNamed class. The meaning of the TITLE is      //
//   reserved for the derived classes to hold there some indetification //
//   that is special for that derived class.                            //
//                                                                      //
//   This means the user must be careful about  the "TDataSet           //
//   NAME and TITLE since this may cause some "side effects" of the     //
//   particular class functions                                         //
//                                                                      //
// - It is NOT required those all "DataSet Members" are in possession   //
//   of the unique names, i.e. any number of "DataSet Members"          //
//   may bear one and the same name                                     //
//                                                                      //
//   Actions:                                                           //
//   ========                                                           //
//   Create  DataSet is born either as "Orphan" or                      //
//                                  as "Structural Member"              //
//           of another TDataSet object                                 //
//                                                                      //
//   Add     One dataset can be included into another dataset.          //
//           Upon adding:                                               //
//           -  the "Orphan dataset" becomes "Structural Member"        //
//           - "Structural Members" of another dataset becomes the      //
//             "Associated Member" of this datatset                     //
//                                                                      //
//   Delete  - Upon deleting the "Structural Member":                   //
//             - "REMOVES" itself  from the "Parent DataSet".           //
//             - Its "Associated memberships" is not changed though     //
//                                                                      //
//              The last means the DataSet with the "Associated Members"//
//              may contain a DIED pointers to unexisting "Associated"  //
//              objects !!!                                             //
//                                                                      //
//  Further information is provided my the particular method            //
//  descriptions.                                                       //
//                                                                      //
//  The TDataSet class has several methods to control object('s)        //
//  memberships                                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

TDataSet mainSet("DSMAIN");
TDataSet *TDataSet::fgMainSet = &mainSet;

ClassImp(TDataSet)

//______________________________________________________________________________
TDataSet::TDataSet(const Char_t *name, TDataSet *parent, Bool_t arrayFlag)
           : TNamed(name,"TDataSet"),fParent(0),fList(0)
{
  //  std::cout << "ctor for " << GetName() << " - " << GetTitle() << std::endl;
   if (name && strchr(name,'/')) {
      Error("TDataSet::TDataSet","dataset name (%s) cannot contain a slash", name);
      return;
   }
   fList =0; fParent=0;
   if (arrayFlag) SetBit(kArray);
   if (parent) parent->Add(this);
//   else AddMain(this);
}

//______________________________________________________________________________
TDataSet *TDataSet::GetRealParent()
{
   //return real parent
   TDataSet *p = GetParent();
   if (fgMainSet && p == fgMainSet) p = 0;
   return p;
}
//______________________________________________________________________________
TDataSet::TDataSet(const TDataSet &pattern,EDataSetPass iopt):TNamed(pattern.GetName(),pattern.GetTitle()),
fParent(0),fList(0)
{
  //
  // Creates TDataSet (clone) with a topology similar with TDataSet *pattern
  //
  //  Parameters:
  //  -----------
  //  pattern        - the pattern dataset
  //  iopt = kStruct - clone only my structural links
  //         kAll    - clone all links
  //         kRefs   - clone only refs
  //         kMarked - clone marked (not implemented yet) only
  //
  //   All new-created sets become the structural ones anyway.
  //
  //  std::cout << "ctor for " << GetName() << " - " << GetTitle() << std::endl;

   TDataSet *set = 0;
   TDataSetIter next((TDataSet *)&pattern);
   Bool_t optsel = (iopt == kStruct);
   Bool_t optall = (iopt == kAll);
   while ((set = next())) {
//              define the parent of the next set
      TDataSet *parent = set->GetParent();
      if ( optall || (optsel && parent == this) )
         Add((TDataSet *)(set->Clone()));
   }
}

//______________________________________________________________________________
TDataSet::TDataSet(TNode &)
{
   // This copy ctor has been depricated (left for thwe sake of the backweard compatibility)
   assert(0);
}
//______________________________________________________________________________
TDataSet::~TDataSet()
{
//              std::cout << "Default destructor for " << GetName() << " - " << GetTitle() << std::endl;
   Shunt(0); Delete();
}

//______________________________________________________________________________
void  TDataSet::MakeCollection()
{
   // Create the internal container at once if any
   if (!fList)
      fList = TestBit(kArray) ? (TSeqCollection *)new TObjArray : (TSeqCollection *) new TList;
}

//______________________________________________________________________________
void TDataSet::AddAt(TDataSet *dataset,Int_t idx)
{
//
// Add TDataSet object at the "idx" position in ds
// or at the end of the dataset
// The final result is defined by either TList::AddAt or TObjArray::AddAt
// methods
//
   if (!dataset) return;

   MakeCollection();

   // Check whether this new child has got any parent yet
   if (!dataset->GetRealParent()) dataset->SetParent(this);
   fList->AddAt(dataset,idx);
}

//______________________________________________________________________________
void TDataSet::AddAtAndExpand(TDataSet *dataset, Int_t idx)
{
//   !!!! Under construction !!!!!
// Add TDataSet object at the "idx" position in ds
// or at the end of the dataset
// The final result is defined by either TList::AddAt or TObjArray::AddAt
// methods
//
   if (!dataset) return;

   MakeCollection();

   // Check whether this new child has got any parent yet
   if (!dataset->GetRealParent()) dataset->SetParent(this);
   if (TestBit(kArray)) ((TObjArray *) fList)->AddAtAndExpand(dataset,idx);
   else                  fList->AddAt(dataset,idx);
}

//______________________________________________________________________________
void TDataSet::AddLast(TDataSet *dataset)
{
// Add TDataSet object at the end of the dataset list of this dataset
   if (!dataset) return;

   MakeCollection();

   // Check whether this new child has got any parent yet
   if (!dataset->GetRealParent()) dataset->SetParent(this);
   fList->AddLast(dataset);
}

//______________________________________________________________________________
void TDataSet::AddFirst(TDataSet *dataset)
{
 // Add TDataSet object at the beginning of the dataset list of this dataset
   if (!dataset) return;

   MakeCollection();

   // Check whether this new child has got any partent yet
   if (!dataset->GetRealParent()) dataset->SetParent(this);
   fList->AddFirst(dataset);
}

//______________________________________________________________________________
void TDataSet::Browse(TBrowser *b)
{
  // Browse this dataset (called by TBrowser).
   TDataSetIter next(this);
   TDataSet *obj;
   if (b)
      while ((obj = next())) b->Add(obj,obj->GetName());
}

//______________________________________________________________________________
TObject *TDataSet::Clone(const char*) const
{
   // the custom implementation fo the TObject::Clone
   return new TDataSet(*this);
}

//______________________________________________________________________________
void TDataSet::Delete(Option_t *opt)
{
//
// Delete - deletes the list of the TDataSet objects and all "Structural Members"
//          as well
//          This method doesn't affect the "Associated Members"
//
   if(opt){/*unused*/}

//      Delete list of the TDataSet
   TSeqCollection     *thisList = GetCollection();
   if (!thisList) return;
   fList = 0;
   TIter next(thisList);
   TDataSet *son = 0;
   //  Delete the "Structural Members" of this TDataSet only
   while ((son = (TDataSet *)next())) {
      if ( (!son->TObject::IsOnHeap()) || (this != son->TDataSet::GetParent()) ) continue;
      // mark the object is deleted from the TDataSet dtor or Delete method
      son->TDataSet::SetParent(0);
      if (son->TDataSet::Last()) { son->TDataSet::Delete(); }
      son->TObject::SetBit(kCanDelete);
      delete son;
   }
   //  Cleare list
   thisList->Clear("nodelete");
   delete thisList;
}

//______________________________________________________________________________
TDataSet  *TDataSet::FindByPath(const Char_t *path) const
{
   // Aliase for TDataSet::Find(const Char_t *path) method
   return Find(path);
}

//______________________________________________________________________________
TDataSet *TDataSet::Find(const Char_t *path) const
{
  //
  // Full description see: TDataSetIter::Find
  //
  // Note. This method is quite expansive.
  // ----- It is done to simplify the user's code when one wants to find ONLY object.
  //       If you need to find more then 1 object in this dataset,
  //       regard using TDataSetIter class yourself.
  //
   TDataSetIter next((TDataSet*)this);
   return next.Find(path);
}

//______________________________________________________________________________
TDataSet *TDataSet::FindByName(const Char_t *name,const Char_t *path,Option_t *opt) const
{
  //
  // Full description see: TDataSetIter::Find
  //
  // Note. This is method is quite expansive.
  // ----- It is done to simplify the user's code when one wants to find ONLY object.
  //       If you need to find more then 1 object in this dataset,
  //       regard using TDataSetIter class yourself.
  //

   TDataSetIter next((TDataSet*)this);
   return next.FindByName(name,path,opt);
}

 //______________________________________________________________________________
TDataSet *TDataSet::FindByTitle(const Char_t *title,const Char_t *path,Option_t *opt) const
{
  //
  // Full description see: TDataSetIter::Find
  //
  // Note. This method is quite expansive.
  // ----- It is done to simplify the user's code when one wants to find ONLY object.
  //       If you need to find more then 1 object in this dataset,
  //       regard using TDataSetIter class yourself.
  //
   TDataSetIter next((TDataSet*)this);
   return next.FindByTitle(title,path,opt);
}

//______________________________________________________________________________
TDataSet *TDataSet::First() const
{
   //  Return the first object in the list. Returns 0 when list is empty.
   if (fList) return (TDataSet *)(fList->First());
   return 0;
}

//______________________________________________________________________________
void TDataSet::AddMain(TDataSet *set)
{
   //add data set to main data set

   if (fgMainSet && set) fgMainSet->AddFirst(set);
}

//______________________________________________________________________________
TDataSet *TDataSet::GetMainSet()
{
   //return pointer to the main dataset

   return fgMainSet;
}

//______________________________________________________________________________
TObject *TDataSet::GetObject() const
{
   // The depricated method (left here for the sake of the backward compatibility)
   Print("***DUMMY GetObject***\n");
   return 0;
}

//______________________________________________________________________________
TDataSet *TDataSet::Last() const
{
   // Return the last object in the list. Returns 0 when list is empty.
   if (fList) return (TDataSet *)(fList->Last());
   return 0;
}

//______________________________________________________________________________
TDataSet *TDataSet::Next() const
{
   // Return the object next to this one in the parent structure
   // This convinient but time-consuming. Don't use it in the inner loops
   TDataSet *set = 0;
   TDataSet *parent = GetParent();
   if (parent) {
      TIter next(parent->GetCollection());
      // Find this object
      while ( (set = (TDataSet *)next()) && (set != this) ){}
      if (set) set = (TDataSet *)next();
   }
   return set;
}

//______________________________________________________________________________
TDataSet *TDataSet::Prev() const
{
   // Return the object that is previous to this one in the parent structure
   // This convinient but time-consuming. Don't use it in the inner loops
   TDataSet *prev = 0;
   TDataSet *set  = 0;
   TDataSet *parent = GetParent();
   if (parent) {
      TIter next(parent->GetCollection());
      // Find this object
      while ( (set = (TDataSet *)next()) && (set != this) ){prev = set;}
      if (!set) prev = 0;
   }
   return prev;
}
//______________________________________________________________________________
void TDataSet::SetObject(TObject * /*obj*/)
{
   // The depricated method (left here for the sake of the backward compatibility)
   Print("***DUMMY PutObject***\n");
}

//______________________________________________________________________________
void  TDataSet::ls(Option_t *option) const
{
 /////////////////////////////////////////////////////////////////////
 //                                                                 //
 //  ls(Option_t *option)                                           //
 //                                                                 //
 //    option       - defines the path to be listed                 //
 //           = "*" -  means print all levels                       //
 //                                                                 //
 /////////////////////////////////////////////////////////////////////

   if (option && !strcmp(option,"*")) ls(Int_t(0));
   else {
      TDataSet *set = 0;
      if (option && strlen(option) > 0) {
         TDataSetIter local((TDataSet*)this);
         set = local(option);
      } else
         set = (TDataSet*)this;
      if (set) set->ls(Int_t(1));
      else
         if (option) Warning("ls","Dataset <%s> not found",option);
   }
}

//______________________________________________________________________________
void TDataSet::ls(Int_t depth) const
{
 /////////////////////////////////////////////////////////////////////
 //                                                                 //
 //  ls(Int_t depth)                                                //
 //                                                                 //
 //  Prints the list of the this TDataSet.                          //
 //                                                                 //
 //  Parameter:                                                     //
 //  =========                                                      //
 //    Int_t depth >0 the number of levels to be printed            //
 //               =0 all levels will be printed                     //
 //            No par - ls() prints only level out                  //
 //                                                                 //
 /////////////////////////////////////////////////////////////////////
   PrintContents();

   if (!fList || depth == 1 ) return;
   if (!depth) depth = 99999;

   TIter next(fList);
   TDataSet *d=0;
   while ((d = (TDataSet *)next())) {
      TROOT::IncreaseDirLevel();
      d->ls(depth-1);
      TROOT::DecreaseDirLevel();
   }
}
//______________________________________________________________________________
TDataSet *TDataSet::Instance() const
{
 // apply the class default ctor to instantiate a new object of the same kind.
 // This is a base method to be overriden by the classes
 // derived from TDataSet (to support TDataSetIter::Mkdir for example)
   return instance();
}

//______________________________________________________________________________
Bool_t TDataSet::IsThisDir(const Char_t *dirname,int len,int ignorecase) const
{
   // Compare the name of the TDataSet with "dirname"
   // ignorercase flags indicates whether the comparision is case sensitive

   if (!ignorecase) {
      if (len<0) {return !strcmp (GetName(),dirname);
      } else     {return !strncmp(GetName(),dirname,len);}
   } else {
      const char *name = GetName();
      if (len==-1) len = strlen(dirname);
      for (int i=0;i<len;i++) { if ( tolower(name[i])!=tolower(dirname[i])) return 0;}
      return 1;
   }
}

//______________________________________________________________________________
void TDataSet::MarkAll()
{
   // Mark all members of this dataset
   Mark();
   TDataSetIter nextMark(this,0);
   TDataSet *set = 0;
   while ( (set = nextMark()) ) set->Mark();
}

//______________________________________________________________________________
void TDataSet::UnMarkAll()
{
   // UnMark all members of this dataset
   Mark(kMark,kReset);
   TDataSetIter nextMark(this,0);
   TDataSet *set = 0;
   while ( (set = nextMark()) ) set->Mark(kMark,kReset);
}

//______________________________________________________________________________
void TDataSet::InvertAllMarks()
{
  // Invert mark bit for all members of this dataset
   if (IsMarked()) Mark(kMark,kReset);
   else Mark();
   TDataSetIter nextMark(this,0);
   TDataSet *set = 0;
   while (( set = nextMark()) ) {
      if (set->IsMarked()) set->Mark(kMark,kReset);
      else set->Mark();
   }
}

//______________________________________________________________________________
Bool_t TDataSet::IsEmpty() const
{
   // return kTRUE if the "internal" collection has no member
   return First() ? kFALSE : kTRUE ;
}

//______________________________________________________________________________
void TDataSet::PrintContents(Option_t *opt) const {
   // Callback method to complete ls() method recursive loop
   // This is to allow to sepoarate navigation and the custom invormation
   // in the derived classes (see; TTable::PrintContents for example
   if (opt) { /* no used */ }
   Printf("%3d - %s\t%s\n",TROOT::GetDirLevel(),(const char*)Path(),(char*)GetTitle());
}

//______________________________________________________________________________
TString TDataSet::Path() const
{
   // return the full path of this data set
   TString str;
   TDataSet *parent = GetParent();
   if (parent) {
      str = parent->Path();
      str += "/";
   }
   str +=  GetName();
   return str;
}

//______________________________________________________________________________
void TDataSet::Remove(TDataSet *set)
{
   // Remiove the "set" from this TDataSet
   if (fList && set) {
      if (set->GetParent() == this) set->SetParent(0);
      fList->Remove(set);
   }

}

//______________________________________________________________________________
TDataSet  *TDataSet::RemoveAt(Int_t idx)
{
   //
   // Remove object from the "idx" cell of this set and return
   // the pointer to the removed object if any
   //
   TDataSet *set = 0;
   if (fList) {
      set = (TDataSet *)fList->At(idx);
      fList->RemoveAt(idx);
      if (set && (set->GetParent() == this) ) set->SetParent(0);
   }
   return set;
}

//______________________________________________________________________________
TDataSet::EDataSetPass TDataSet::Pass(EDataSetPass ( *callback)(TDataSet *),Int_t depth)
{
 /////////////////////////////////////////////////////////////////////
 //                                                                 //
 // Pass (callback,depth)                                           //
 //                                                                 //
 // Calls callback(this) for all datasets those recursively         //
 //                                                                 //
 //  Parameter:                                                     //
 //  =========                                                      //
 //    Int_t depth >0 the number of levels to be passed             //
 //                =0 all levels will be passed                     //
 //                                                                 //
 //  Return (this value mast be returned by the user's callback):   //
 //  ======                                                         //
 //  kContinue - continue passing                                   //
 //  kPrune    - stop passing the current branch, go to the next one//
 //  kUp       - stop passing, leave the current branch,            //
 //              return to previous level and continue              //
 //  kStop     - stop passing, leave all braches                    //
 //                                                                 //
 /////////////////////////////////////////////////////////////////////

   if (!callback) return kStop;

   EDataSetPass condition = callback(this);

   if (condition == kContinue){
      if (fList && depth != 1 ) {
         TIter next(fList);
         TDataSet *d=0;
         while ( (d = (TDataSet *)next()) ) {
            condition = d->Pass(callback, depth == 0 ? 0 : --depth);
            if (condition == kStop || condition == kUp) break;
         }
      }
   }
   return condition==kUp ? kContinue:condition;
}

//______________________________________________________________________________
TDataSet::EDataSetPass TDataSet::Pass(EDataSetPass ( *callback)(TDataSet *,void*),void *user,Int_t depth)
{
 /////////////////////////////////////////////////////////////////////
 //                                                                 //
 // Pass (callback,user,depth)                                      //
 //                                                                 //
 // Calls callback(this,user) for all datasets those recursively    //
 //                                                                 //
 //  Parameter:                                                     //
 //  =========                                                      //
 //    Int_t depth >0 the number of levels to be passed             //
 //                =0 all levels will be passed                     //
 //                                                                 //
 //  Return (this value mast be returned by the user's callback):   //
 //  ======                                                         //
 //  kContinue - continue passing                                   //
 //  kPrune    - stop passing the current branch, go to the next one//
 //  kUp       - stop passing, leave the current branch,            //
 //              return to previous level and continue              //
 //  kStop     - stop passing, leave all braches                    //
 //                                                                 //
 /////////////////////////////////////////////////////////////////////

   if (!callback) return kStop;

   EDataSetPass condition = callback(this,user);

   if (condition == kContinue){
      if (fList && depth != 1 ) {
         TIter next(fList);
         TDataSet *d=0;
         while ((d = (TDataSet *)next())) {
            condition = d->Pass(callback, user, depth == 0 ? 0 : --depth);
            if (condition == kStop) break;
            if (condition == kUp  ) break;
         }
      }
   }
   return (condition==kUp) ? kContinue:condition;
}

//______________________________________________________________________________
Int_t TDataSet::Purge(Option_t *)
{
//
// Purge  - deletes all "dummy" "Structural Members" those are not ended
//          up with some dataset with data inside (those return HasData() = 0)
//
// Purge does affect only the "Structural Members" and doesn't "Associated" ones
//

   if (!fList) return 0;
   TIter next(fList);
   TDataSet *son = 0;
   // Purge "Structural Members" only
   TList garbage;
   while ((son = (TDataSet *)next())) {
      if (this == son->GetParent()) continue;
      //   mark the object is deleted from the TDataSet dtor
      son->Purge();
      if (son->HasData() || son->GetListSize()) continue;
      delete son;
   }
   return 0;
}

//______________________________________________________________________________
void  TDataSet::SetParent(TDataSet *parent)
{
//
//  Break the "parent" relationship with the current object parent if present
//  parent != 0   Makes this object the "Structural Member"
//                of the "parent" dataset
//          = 0   Makes this object the "pure Associator", i.e it makes this
//                object the "Structural Member" of NO other TDataSet
//
   fParent = parent;
}

//______________________________________________________________________________
void TDataSet::SetWrite()
{
 // One should not use this method but TDataSet::Write instead
 // This method os left here for the sake of the backward compatibility
 // To Write object first we should temporary break the
 // the backward fParent pointer (otherwise ROOT follows this links
 // and will pull fParent out too.
 //
   Write();
}

//______________________________________________________________________________
void TDataSet::Shunt(TDataSet *newParent)
{
  //
  //  Remove the object from the original and add it to dataset
  //  TDataSet dataset   != 0  -  Make this object the "Structural Member"
  //                                of "dataset"
  //                        = 0  -  Make this object "Orphan"
  //
   if (fParent)   fParent->Remove(this);
   if (newParent) newParent->Add(this);
}

//______________________________________________________________________________
void TDataSet::Update(TDataSet* set,UInt_t opt)
{
//
// Update this TDataSet with "set"
//
// ATTENTION !!!
// ---------
// This method changes the parent relationships of the input "set"
//
   if(opt){/*unused*/}
   if(!set) return;

   SetTitle(set->GetTitle());
   TDataSetIter nextnew(set);
   TDataSet *newset = 0;
   while((newset = nextnew())) {
      Bool_t found = kFALSE;
      //              Check whether this has the list of the sons
      if (fList) {
         TIter nextold(fList);
         const Char_t *newname = newset->GetName();
         TDataSet *oldset = 0;
         while ( ((oldset = (TDataSet *)nextold())!=0) && !found) {
            // if the "new" set does contain the dataset
            // with the same name as ours update it too
            // (We do not update itself (oldset == newset)
            if ( (oldset != newset) && oldset->IsThisDir(newname) ) {
               oldset->Update(newset);
               found = kTRUE;
            }
         }
      }
      // If the new "set" contains some new dataset with brand-new name
      // move it into the our dataset and remove it from its old location
      if (!found) newset->Shunt(this);
   }
}

//______________________________________________________________________________
void TDataSet::Update()
{
 //
 //  Update()
 //
 //  Recursively updates all tables for all nested datasets
 //  in inverse order
 //

   TDataSetIter next(this);
   TDataSet *set = 0;
   while(( set = next())) set->Update();
}

//______________________________________________________________________________
void TDataSet::Sort()
{
   // Sort recursively all members of the TDataSet with TList::Sort method
   TDataSetIter next(this,0);
   TDataSet *ds;
   TList *list;
   while ((ds=next())) {
      list = ds->GetList();
      if (!list) continue;
      list->Sort(); ds->Sort();
   }
}

//______________________________________________________________________________
Int_t TDataSet::Write(const char *name, Int_t option, Int_t bufsize)
{
 //
 // To Write object first we should temporary break the
 // the backward fParent pointer (otherwise ROOT follows this links
 // and will pull fParent out too.
 //
   TDataSet *saveParent = fParent; // GetParent();
   fParent = 0;
   Int_t nbytes = TObject::Write(name,option, bufsize);
   fParent = saveParent;
   return nbytes;
}

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