class TROOT: public TDirectory

 Clean up and free resources used by ROOT (files, network sockets,
 shared memory segments, etc.).

 Add a class to the list and map of classes.

 Add a class generator.  This generator will be called by TClass::GetClass
 in case its does not find a loaded rootcint dictionary to request the
 creation of a TClass object.

 Add browsable objects to TBrowser.

 return class status bit kClassSaved for class cl
 This function is called by the SavePrimitive functions writing
 the C++ code for an object.

 Close any files and sockets that gROOT knows about.
 This can be used to insures that the files and sockets are closed before any library is unloaded!

 Find an object in one Root folder

 Returns address of a ROOT object if it exists

 If name contains at least one "/" the function calls FindObjectany
 else
 This function looks in the following order in the ROOT lists:
     - List of files
     - List of memory mapped files
     - List of functions
     - List of geometries
     - List of canvases
     - List of styles
     - List of specials
     - List of materials in current geometry
     - List of shapes in current geometry
     - List of matrices in current geometry
     - List of Nodes in current geometry
     - Current Directory in memory
     - Current Directory on file

 Returns address and folder of a ROOT object if it exists

 This function looks in the following order in the ROOT lists:
     - List of files
     - List of memory mapped files
     - List of functions
     - List of geometries
     - List of canvases
     - List of styles
     - List of specials
     - List of materials in current geometry
     - List of shapes in current geometry
     - List of matrices in current geometry
     - List of Nodes in current geometry
     - Current Directory in memory
     - Current Directory on file

 Return a pointer to the first object with name starting at //root.
 This function scans the list of all folders.
 if no object found in folders, it scans the memory list of all files.

 Scan the memory lists of all files for an object with name

 Returns class name of a ROOT object including CINT globals.

 Return path name of obj somewhere in the //root/... path.
 The function returns the first occurence of the object in the list
 of folders. The returned string points to a static char array in TROOT.
 If this function is called in a loop or recursively, it is the
 user's responsability to copy this string in his area.

 return a TClass object corresponding to 'name' assuming it is an STL container.
 In particular we looking for possible alternative name (default template
 parameter, typedefs template arguments, typedefed name).

 Return pointer to class with name. Obsolete, use TClass::GetClass directly

 Return pointer to class from its name. Obsolete, use TClass::GetClass directly
 See TClass::GetClass

 Return address of color with index color.

 Return a default canvas.

 Return pointer to type with name.

 Return pointer to file with name.

 Return pointer to style with name

 Return pointer to function with name.

 Return pointer to global variable by name. If load is true force
 reading of all currently defined globals from CINT (more expensive).

 Return pointer to global variable with address addr. If load is true
 force reading of all currently defined globals from CINT (more
 expensive).

 Return pointer to global function by name. If params != 0
 it will also resolve overloading. If load is true force reading
 of all currently defined global functions from CINT (more expensive).
 The param string must be of the form: "3189,\"aap\",1.3".

 Return pointer to global function by name. If proto != 0
 it will also resolve overloading. If load is true force reading
 of all currently defined global functions from CINT (more expensive).
 The proto string must be of the form: "int, char*, float".

 Return pointer to Geometry with name

 Return list containing the TGlobals currently defined.
 Since globals are created and deleted during execution of the
 program, we need to update the list of globals every time we
 execute this method. However, when calling this function in
 a (tight) loop where no interpreter symbols will be created
 you can set load=kFALSE (default).

 Return list containing the TFunctions currently defined.
 Since functions are created and deleted during execution of the
 program, we need to update the list of functions every time we
 execute this method. However, when calling this function in
 a (tight) loop where no interpreter symbols will be created
 you can set load=kFALSE (default).

 Return list containing all TDataTypes (typedefs) currently defined.
 Since types can be added and removed during execution of the
 program, we need to update the list of types every time we
 execute this method. However, when calling this function in
 a (tight) loop where no new types will be created
 you can set load=kFALSE (default).

 Execute command when system has been idle for idleTimeInSec seconds.

 Return 1 if the name of the given include file corresponds to a class that
  is known to ROOT, e.g. "TLorentzVector.h" versus TLorentzVector.

 Initialize operating system interface.

 Load and initialize thread library.

 Helper function used by TClass::GetClass().
 This function attempts to load the dictionary for 'classname'
 either from the TClassTable or from the list of generator.
 If silent is 'true', do not warn about missing dictionary for the class.
 (typically used for class that are used only for transient members)

 Check if class "classname" is known to the interpreter (in fact,
 this check is not needed anymore, so classname is ignored). If
 not it will load library "libname". If the library name does
 not start with "lib", "lib" will be prepended and a search will
 be made in the DynamicPath (see .rootrc). If not found a search
 will be made on libname (without "lib" prepended) and if not found
 a direct try of libname will be made (in case it contained an
 absolute path).
 If check is true it will only check if libname exists and is
 readable.
 Returns 0 on successful loading, -1 in case libname does not
 exist or in case of error and -2 in case of version mismatch.

 To list all objects of the application.
 Loop on all objects created in the ROOT linked lists.
 Objects may be files and windows or any other object directly
 attached to the ROOT linked list.

 Load a macro in the interpreter's memory. Equivalent to the command line
 command ".L filename". If the filename has "+" or "++" appended
 the macro will be compiled by ACLiC. The filename must have the format:
 [path/]macro.C[+|++[g|O]].
 The possible error codes are defined by TInterpreter::EErrorCode.
 If check is true it will only check if filename exists and is
 readable.
 Returns 0 on successful loading and -1 in case filename does not
 exist or in case of error.

 Execute a macro in the interpreter. Equivalent to the command line
 command ".x filename". If the filename has "+" or "++" appended
 the macro will be compiled by ACLiC. The filename must have the format:
 [path/]macro.C[+|++[g|O]][(args)].
 The possible error codes are defined by TInterpreter::EErrorCode.
 If padUpdate is true (default) update the current pad.
 Returns the macro return value.

 Process message id called by obj.

 Process interpreter command via TApplication::ProcessLine().
 On Win32 the line will be processed asynchronously by sending
 it to the CINT interpreter thread. For explicit synchronous processing
 use ProcessLineSync(). On non-Win32 platforms there is no difference
 between ProcessLine() and ProcessLineSync().
 The possible error codes are defined by TInterpreter::EErrorCode. In
 particular, error will equal to TInterpreter::kProcessing until the
 CINT interpreted thread has finished executing the line.
 Returns the result of the command, cast to a Long_t.

 Process interpreter command via TApplication::ProcessLine().
 On Win32 the line will be processed synchronously (i.e. it will
 only return when the CINT interpreter thread has finished executing
 the line). On non-Win32 platforms there is no difference between
 ProcessLine() and ProcessLineSync().
 The possible error codes are defined by TInterpreter::EErrorCode.
 Returns the result of the command, cast to a Long_t.

 Process interpreter command directly via CINT interpreter.
 Only executable statements are allowed (no variable declarations),
 In all other cases use TROOT::ProcessLine().
 The possible error codes are defined by TInterpreter::EErrorCode.

 Read Subversion revision information and branch name from the
 etc/svnrev.txt file.

 Return date/time make was run.

 Refresh all browsers. Call this method when some command line
 command or script has changed the browser contents. Not needed
 for objects that have the kMustCleanup bit set. Most useful to
 update browsers that show the file system or other objects external
 to the running ROOT session.

 Remove a class from the list and map of classes

 Delete all global interpreter objects created since the last call to Reset

 If option="a" is set reset to startup context (i.e. unload also
 all loaded files, classes, structs, typedefs, etc.).

 This function is typically used at the beginning (or end) of an unnamed macro
 to clean the environment.

 IMPORTANT WARNING:
 Do not use this call from within any function (neither compiled nor
 interpreted.  This should only be used from a unnamed macro
 (which starts with a { (curly braces)  ).  For example, using TROOT::Reset
 from within an interpreted function will lead to the unloading of the
 dictionary and source file, including the one defining the function being
 executed.

 Save the current interpreter context.

 Set the default graphical cut class name for the graphics editor
 By default the graphics editor creates an instance of a class TCutG.
 This function may be called to specify a different class that MUST
 derive from TCutG

 Set editor mode

 Change current style to style with name stylename

 Decrease the indentation level for ls().

return directory level

 Get macro search path. Static utility function.

 Set or extend the macro search path. Static utility function.
 If newpath=0 or "" reset to value specified in the rootrc file.

 Increase the indentation level for ls().

 Functions used by ls() to indent an object hierarchy.

 Return kTRUE if the TROOT object has been initialized.

 Return kTRUE if the memory leak checker is on.

 Return Indentation level for ls().

 Convert version code to an integer, i.e. 331527 -> 51507.

 Convert version as an integer to version code as used in RVersion.h.

 Return ROOT version code as defined in RVersion.h.