library: libTable
#include "TDataSetIter.h"

TDataSetIter


class description - source file - inheritance tree (.pdf)

class TDataSetIter : public TObject

Inheritance Chart:
TObject
<-
TDataSetIter
<-
TVolumeViewIter

    protected:
TDataSet* GetNullSet() TDataSet* NextDataSet(TIter& next) TDataSet* NextDataSet(Int_t nDataSet) public:
TDataSetIter(TDataSet* l = 0, Int_t depth = 1, Bool_t dir = kIterForward) TDataSetIter(TDataSet* l, Bool_t dir) TDataSetIter(const TDataSetIter&) virtual ~TDataSetIter() virtual TDataSet* Add(TDataSet* set) virtual TDataSet* Add(TDataSet* set, const Char_t* path) virtual TDataSet* Add(TDataSet* set, TDataSet* dataset) virtual TDataSet* Cd(const Char_t* dirname) virtual TDataSet* Cd(TDataSet* ds) static TClass* Class() virtual TDataSet* Cwd() const virtual Int_t Df() const virtual TDataSet* Dir(Char_t* dirname) virtual Int_t Du() const virtual TDataSet* Find(const Char_t* path, TDataSet* rootset = 0, Bool_t mkdir = kFALSE, Bool_t titleFlag = kFALSE) virtual TDataSet* FindByName(const Char_t* name, const Char_t* path = "", Option_t* opt = "") virtual TDataSet* FindByPath(const Char_t* path, TDataSet* rootset = 0, Bool_t mkdir = kFALSE) virtual TDataSet* FindByPointer(TDataSet* set, const Char_t* path = "0", Option_t* opt = "") virtual TDataSet* FindByTitle(const Char_t* title, const Char_t* path = "", Option_t* opt = "") virtual TDataSet* FindDataSet(const Char_t* name, const Char_t* path = "", Option_t* opt = "") virtual TDataSet* FindDataSet(TDataSet* set, const Char_t* path, Option_t* opt = "") virtual TObject* FindObject(const Char_t* name) const virtual TObject* FindObject(const TObject* obj) const virtual Int_t Flag(UInt_t flag = TDataSet::kMark, TDataSet::EBitOpt reset = TDataSet::kSet) virtual Int_t Flag(const Char_t* path, UInt_t flag = TDataSet::kMark, TDataSet::EBitOpt reset = TDataSet::kSet) virtual Int_t Flag(TDataSet* dataset, UInt_t flag = TDataSet::kMark, TDataSet::EBitOpt reset = TDataSet::kSet) virtual Int_t GetDepth() const virtual Option_t* GetOption() const virtual TClass* IsA() const virtual TDataSet* Ls(const Char_t* dirname = "", Option_t* opt = "") const virtual TDataSet* Ls(const Char_t* dirname, Int_t depth) const virtual void ls(Option_t* dirname = "") const virtual TDataSet* ls(TString dirname, Option_t* opt = "") const virtual TDataSet* ls(const Char_t* dirname, Int_t depth) const virtual TDataSet* Md(const Char_t* dirname) virtual TDataSet* Mkdir(const Char_t* dirname) virtual TDataSet* Next(TDataSet::EDataSetPass mode = TDataSet::kContinue) virtual TDataSet* Next(const Char_t* path, TDataSet* rootset = 0, Bool_t mkdir = kFALSE) virtual Bool_t Notify() virtual void Notify(TDataSet* dataset) virtual TDataSet* operator()(TDataSet::EDataSetPass mode = TDataSet::kContinue) virtual TDataSet* operator()(const Char_t* path) virtual TDataSet* operator*() const TDataSetIter& operator=(const TDataSetIter&) virtual TDataSet* operator[](const Char_t* path) virtual TString Path(const Char_t* path) virtual TString Path() virtual TDataSet* Pwd(Option_t* opt = "") const virtual TDataSet* Rd(const Char_t* dirname, Option_t* option = "") virtual void Reset(TDataSet* l = 0, Int_t depth = 0) virtual TDataSet* Rmdir(TDataSet* dataset, Option_t* option = "") virtual TDataSet* Rmdir(const Char_t* dirname, Option_t* option = "") virtual void ShowMembers(TMemberInspector& insp, char* parent) virtual TDataSet* Shunt(TDataSet* set) virtual TDataSet* Shunt(TDataSet* set, const Char_t* path) virtual TDataSet* Shunt(TDataSet* set, TDataSet* dataset) virtual void Streamer(TBuffer& b) void StreamerNVirtual(TBuffer& b)

Data Members


    protected:
TIter* fNext "standard" ROOT iterator for containers TIter* fNextSet[100] the list of the TList iterators to bypass the whole dataset Int_t fDepth the current depth of the passing Int_t fMaxDepth the max depth of the passing (=1 by default) TDataSet* fDataSet Pointer to the last selected TDataSet TDataSet* fRootDataSet Pointer to the root TDataSet TDataSet* fWorkingDataSet Pointer to the working TDataSet static TDataSet* fgNullDataSet

Class Description

                                                                      
 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(TDataSet *link, Bool_t dir)

TDataSetIter(TDataSet *link, Int_t depth, Bool_t dir)

~TDataSetIter()

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


TDataSet* 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                           
  =======                                                                  
                                                                           


TDataSet* 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* 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* 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


Int_t Du() const
 summarize dataset usage by Herb Ward proposal

TDataSet* FindByName(const Char_t *name,const Char_t *path,Option_t *opt)

TDataSet* FindByTitle(const Char_t *title,const Char_t *path,Option_t *opt)

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


TDataSet* 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


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

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

TDataSet* 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


Int_t Flag(const Char_t *path,UInt_t flag,TDataSet::EBitOpt reset)

Int_t Flag(TDataSet *dataset,UInt_t flag,TDataSet::EBitOpt reset)

TDataSet* 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* 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* Mkdir(const Char_t *dirname)

void 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* 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* 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"



TDataSet* NextDataSet(TIter &next)

TDataSet* NextDataSet(Int_t nDataSet)
 Pick the next object of the  level provided

TDataSet* FindByPath(const Char_t *path, TDataSet *rootset,Bool_t mkdir)

TDataSet* 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 
  ------                                                                    


void 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;


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


TDataSet* 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                           
  =======                                                                  
                                                                           




Inline Functions


            TDataSet* GetNullSet()
            TDataSet* Add(TDataSet* set, TDataSet* dataset)
            TDataSet* operator()(TDataSet::EDataSetPass mode = TDataSet::kContinue)
            TDataSet* operator()(const Char_t* path)
            TDataSet* operator[](const Char_t* path)
                Int_t GetDepth() const
            TDataSet* Cwd() const
                Int_t Df() const
                Int_t Flag(TDataSet* dataset, UInt_t flag = TDataSet::kMark, TDataSet::EBitOpt reset = TDataSet::kSet)
                 void ls(Option_t* dirname = "") const
            TDataSet* ls(TString dirname, Option_t* opt = "") const
            TDataSet* ls(const Char_t* dirname, Int_t depth) const
            TDataSet* Md(const Char_t* dirname)
              TString Path(const Char_t* path)
              TString Path()
            TDataSet* Pwd(Option_t* opt = "") const
            TDataSet* Rmdir(const Char_t* dirname, Option_t* option = "")
            TDataSet* Rd(const Char_t* dirname, Option_t* option = "")
            TDataSet* Shunt(TDataSet* set, TDataSet* dataset)
            TDataSet* Next(const Char_t* path, TDataSet* rootset = 0, Bool_t mkdir = kFALSE)
                 void Notify(TDataSet* dataset)
            Option_t* GetOption() const
            TDataSet* operator*() const
              TClass* Class()
              TClass* IsA() const
                 void ShowMembers(TMemberInspector& insp, char* parent)
                 void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
         TDataSetIter TDataSetIter(const TDataSetIter&)
        TDataSetIter& operator=(const TDataSetIter&)


Author: Valery Fine(fine@mail.cern.ch) 03/07/98
Last update: root/star:$Name: $:$Id: TDataSetIter.cxx,v 1.5 2005/09/09 04:57:59 brun Exp $


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.