class TDirectory: public TNamed

Directory default constructor-
*-*                    =============================

 Create a new Directory *-*-
*-*                     ======================
  A new directory with name,title is created in the current directory
  The directory header information is immediately saved in the file
  A new key is added in the parent directory

  When this constructor is called from a class directly derived
  from TDirectory, the third argument classname MUST be specified.
  In this case, classname must be the name of the derived class.

  Note that the directory name cannot contain slashes.

 Copy constructor.

 -- Destructor.

 Sets the flag controlling the automatic add objects like histograms, TGraph2D, etc
 in memory

 By default (fAddDirectory = kTRUE), these objects are automatically added
 to the list of objects in memory.
 Note that in the classes like TH1, TGraph2D supporting this facility,
 one object can be removed from its support directory
 by calling object->SetDirectory(0) or object->SetDirectory(dir) to add it
 to the list of objects in the directory dir.

  NOTE that this is a static function. To call it, use;
     TDirectory::AddDirectory

static function: see TDirectory::AddDirectory for more comments

 Append object to this directory.

 If replace is true:
   remove any existing objects with the same same (if the name is not ""

 Browse the content of the directory.

-*-*Initialise directory to defaults
*-*                    ================================

 Clean the pointers to this object (gDirectory, TContext, etc.)

 Clone an object.
 This function is called when the directory is not a TDirectoryFile.
 This version has to load the I/O package, hence via CINT

 If autoadd is true and if the object class has a
 DirectoryAutoAdd function, it will be called at the end of the
 function with the parameter gDirector.  This usually means that
 the object will be appended to the current ROOT directory.

 Return the current directory for the current thread.

 Find a directory using apath.
 It apath is null or empty, returns "this" directory.
 Otherwie use apath to find a directory.
 The absolute path syntax is:
    file.root:/dir1/dir2
 where file.root is the file and /dir1/dir2 the desired subdirectory
 in the file. Relative syntax is relative to "this" directory. E.g:
 ../aa.
 Returns 0 in case path does not exist.
 If printError is true, use Error with 'funcname' to issue an error message.

 Change current directory to "this" directory . Using path one can
 change the current directory to "path". The absolute path syntax is:
 file.root:/dir1/dir2
 where file.root is the file and /dir1/dir2 the desired subdirectory
 in the file. Relative syntax is relative to "this" directory. E.g:
 ../aa. Returns kTRUE in case of success.

 Change current directory to "this" directory . Using path one can
 change the current directory to "path". The absolute path syntax is:
 file.root:/dir1/dir2
 where file.root is the file and /dir1/dir2 the desired subdirectory
 in the file. Relative syntax is relative to "this" directory. E.g:
 ../aa. Returns kFALSE in case path does not exist.

 Change current directory to "path". The absolute path syntax is:
 file.root:/dir1/dir2
 where file.root is the file and /dir1/dir2 the desired subdirectory
 in the file. Relative syntax is relative to the current directory
 gDirectory, e.g.: ../aa. Returns kTRUE in case of success.

 Change current directory to "path". The path syntax is:
 file.root:/dir1/dir2
 where file.root is the file and /dir1/dir2 the desired subdirectory
 in the file. Returns kFALSE in case path does not exist.

Delete all objects from a Directory list-*-
*-*    =======================================

 -- Delete all objects from memory and directory structure itself.

 -- Delete all objects from memory.

Delete Objects or/and keys in a directory
*-*             =========================================
   namecycle has the format name;cycle
   namecycle = "" same as namecycle ="T*"
   name  = * means all
   cycle = * means all cycles (memory and keys)
   cycle = "" or cycle = 9999 ==> apply to a memory object
   When name=* use T* to delete subdirectories also

   To delete one directory, you must specify the directory cycle,
      eg.  file.Delete("dir1;1");

   examples:
     foo   : delete object named foo in memory
     foo*  : delete all objects with a name starting with foo
     foo;1 : delete cycle 1 of foo on file
     foo;* : delete all cycles of foo on file and also from memory
     *;2   : delete all objects on file having the cycle 2
     *;*   : delete all objects from memory and file
    T*;*   : delete all objects from memory and file and all subdirectories

-*-*Fill Graphics Structure and Paint
*-*                    =================================
 Loop on all objects (memory or file) and all subdirectories

 Find object in the list of memory objects.

 Find object by name in the list of memory objects.

 Find object by name in the list of memory objects of the current
 directory or its sub-directories.
 After this call the current directory is not changed.
 To automatically set the current directory where the object is found,
 use FindKeyAny(aname)->ReadObj().

  return pointer to object identified by namecycle

   namecycle has the format name;cycle
   name  = * is illegal, cycle = * is illegal
   cycle = "" or cycle = 9999 ==> apply to a memory object

   examples:
     foo   : get object named foo in memory
             if object is not in memory, try with highest cycle from file
     foo;1 : get cycle 1 of foo on file

  The retrieved object should in principle derive from TObject.
  If not, the function TDirectory::GetObject should be called.
  However, this function will still work for a non-TObject, providing that
  the calling application cast the return type to the correct type (which
  is the actual type of the object).

  NOTE:
  The method GetObject offer better protection and avoid the need
  for any cast:
      MyClass *obj;
      directory->GetObject("some object",obj);
      if (obj) { ... the object exist and inherits from MyClass ... }

  VERY IMPORTANT NOTE:
  In case the class of this object derives from TObject but not
  as a first inheritance, one must use dynamic_cast<>().
  Example 1: Normal case:
      class MyClass : public TObject, public AnotherClass
   then on return, one can do:
      MyClass *obj = (MyClass*)directory->Get("some object of MyClass");

  Example 2: Special case:
      class MyClass : public AnotherClass, public TObject
  then on return, one must do:
      MyClass *obj = dynamic_cast<MyClass*>(directory->Get("some object of MyClass"));

  Of course, dynamic_cast<> can also be used in the example 1.

 return pointer to object identified by namecycle.
 The returned object may or may not derive from TObject.

   namecycle has the format name;cycle
   name  = * is illegal, cycle = * is illegal
   cycle = "" or cycle = 9999 ==> apply to a memory object

  VERY IMPORTANT NOTE:
  The calling application must cast the returned object to
  the final type, e.g.
      MyClass *obj = (MyClass*)directory->GetObject("some object of MyClass");

 See documentation of TDirectory::GetObjectCheck(const char *namecycle, const TClass *cl)

 return pointer to object identified by namecycle if and only if the actual
 object is a type suitable to be stored as a pointer to a "expectedClass"
 If expectedClass is null, no check is performed.

   namecycle has the format name;cycle
   name  = * is illegal, cycle = * is illegal
   cycle = "" or cycle = 9999 ==> apply to a memory object

  VERY IMPORTANT NOTE:
  The calling application must cast the returned pointer to
  the type described by the 2 arguments (i.e. cl):
      MyClass *obj = (MyClass*)directory->GetObjectChecked("some object of MyClass","MyClass"));

  Note: We recommend using the method TDirectory::GetObject:
      MyClass *obj = 0;
      directory->GetObject("some object inheriting from MyClass",obj);
      if (obj) { ... we found what we are looking for ... }

 Returns the full path of the directory. E.g. file:/dir1/dir2.
 The returned path will be re-used by the next call to GetPath().

 Returns the full path of the directory. E.g. file:/dir1/dir2.
 The returned path will be re-used by the next call to GetPath().

 recursive method to fill full path for directory

 Create a sub-directory and return a pointer to the created directory.
 Returns 0 in case of error.
 Returns 0 if a directory with the same name already exists.
 Note that the directory name may be of the form "a/b/c" to create a hierarchy of directories.
 In this case, the function returns the pointer to the "a" directory if the operation is successful.

 For example the step to the steps to create first a/b/c and then a/b/d without receiving
 and errors are:
    TFile * file = new TFile("afile","RECREATE");
    file->mkdir("a");
    file->cd("a");
    gDirectory->mkdir("b");
    gDirectory->cd("b");
    gDirectory->mkdir("d");

 List Directory contents.

  Indentation is used to identify the directory tree
  Subdirectories are listed first, then objects in memory.

  The option can has the following format:
     [<regexp>]
  The <regexp> will be used to match the name of the objects.
  By default memory and disk objects are listed.

 Paint all objects in the directory.

 Print all objects in the directory.

 Print the path of the directory.

 Recursively remove object from a Directory.

 Remove an object from the in-memory list.

 Removes subdirectory from the directory
 When directory is deleted, all keys in all subdirectories will be
 read first and deleted from file (if exists)
 Equivalent call is Delete("name;*");

 Save object in filename,
 if filename is 0 or "", a file with "objectname.root" is created.
 The name of the key is the object name.
 If the operation is successful, it returns the number of bytes written to the file
 otherwise it returns 0.
 By default a message is printed. Use option "q" to not print the message.

 Set the name for directory
 If the directory name is changed after the directory was written once,
 ROOT currently would NOT change the name of correspondent key in the
 mother directory.
 DO NOT use this method to 'rename a directory'.
 Renaming a directory is currently NOT supported.

 Encode the name and cycle into buffer like: "aap;2".

 Decode a namecycle "aap;2" into name "aap" and cycle "2". Destination
 buffer size for name (including string terminator) should be specified in
 namesize.

 Register a TContext pointing to this TDirectory object

 See TDirectoryFile::WriteTObject for details

 UnRegister a TContext pointing to this TDirectory object