TEnv

class TEnv : public TObject

    private:

      const char* Getvalue(const char* name) const

    public:

                     TEnv TEnv(const char* name)
                     TEnv TEnv(const TEnv&)
             virtual void ~TEnv()
           static TClass* Class()
                   Bool_t Defined(const char* name)
          TOrdCollection* GetTable() const
            virtual Int_t GetValue(const char* name, Int_t dflt)
         virtual Double_t GetValue(const char* name, Double_t dflt)
      virtual const char* GetValue(const char* name, const char* dflt) const
          virtual TClass* IsA() const
         virtual TEnvRec* Lookup(const char* n)
             virtual void Print(Option_t* option) const
             virtual void PrintEnv(EEnvLevel level = kEnvAll) const
             virtual void ReadFile(const char* fname, EEnvLevel level)
             virtual void Save()
             virtual void SaveLevel(EEnvLevel level)
             virtual void SetValue(const char* name, const char* value, EEnvLevel level = kEnvChange, const char* type = "0")
             virtual void SetValue(const char* name, EEnvLevel level = kEnvChange)
             virtual void SetValue(const char* name, Int_t value)
             virtual void SetValue(const char* name, Double_t value)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)

Data Members

    private:

      TOrdCollection* fTable   
              TString fRcName  

Class Description

                                                                      
 TEnv                                                                 
                                                                      
 The TEnv class reads a config file, by default .rootrc. Three types  
 of .rootrc files are read: global, user and local files. The global  
 file resides in $ROOTSYS/etc, the user file in ~/ and the local file 
 in the current working directory.                                    
 The format of the .rootrc file is similar to the .Xdefaults format:  
                                                                      
   [+]<SystemName>.<RootName|ProgName>.<name>[(type)]:  <value>       
                                                                      
 Where <SystemName> is either Unix, WinNT, MacOS or Vms,              
 <RootName> the name as given in the TApplication ctor (or "RootApp"  
 in case no explicit TApplication derived object was created),        
 <ProgName> the current program name and <name> the resource name,    
 with optionally a type specification. <value> can be either a        
 string, an integer, a float/double or a boolean with the values      
 TRUE, FALSE, ON, OFF, YES, NO, OK, NOT. Booleans will be returned as 
 an integer 0 or 1. The options [+] allows the concatenation of       
 values to the same resouce name.                                     
                                                                      
 E.g.:                                                                
                                                                      
   Unix.Rint.Root.DynamicPath: .:$ROOTSYS/lib:~/lib                   
   myapp.Root.Debug:  FALSE                                           
   TH.Root.Debug: YES                                                 
   *.Root.MemStat: 1                                                  
                                                                      
 <SystemName> and <ProgName> or <RootName> may be the wildcard "*".   
 A # in the first column starts comment line.                         
                                                                      
 For the currently defined resources (and their default values) see   
 $ROOTSYS/etc/system.rootrc.                                          
                                                                      
 Note that the .rootrc config files contain the config for all ROOT   
 based applications.                                                  
                                                                      
 To add new entries to a TEnv:                                        
 TEnv env(".myfile");                                                 
 env.SetValue("myname","value");                                      
 env.SaveLevel(kEnvLocal);                                            
                                                                      
 All new entries will be saved in the file corresponding to the       
 first SaveLevel() command.  If Save() is used, new entries go        
 into the local file by default.                                      
                                                                      

 Create a resource table and read the (possibly) three resource files, i.e
 $ROOTSYS/system<name> (or ROOTETCDIR/system<name>), $HOME/<name> and
 ./<name>. ROOT always reads ".rootrc" (in TROOT::InitSystem()). You can
 read additional user defined resource files by creating addtional TEnv
 object.

 Delete the resource table.

 Returns the character value for a named resouce.

 Returns the integer value for a resource. If the resource is not found
 return the dflt value.

 Returns the dobule value for a resource. If the resource is not found
 return the dflt value.

 Returns the character value for a named resouce. If the resource is
 not found the dflt value is returned.

 Loop over all resource records and return the one with name.
 Return 0 in case name is not in the resoucre table.

 Print all resources or the global, user or local resources separately.

 Print all resources for a certain level (global, user, local).

 Read and parse the resource file for a certain level.

 Write the resource files for each level. The new files have the same
 name as the original files. The old files are renamed to *.bak.

 Write the resource file for a certain level.

 Set the value of a resource or create a new resource.

 Set the value of a resource or create a new resource.
 Use this method to set a resource like, "name=val".
 If just "name" is given it will be interpreted as "name=1".

 Set or create an integer resource value.

 Set or create a double resource value.

Inline Functions

        TOrdCollection* GetTable() const
                 Bool_t Defined(const char* name)
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)
                   TEnv TEnv(const TEnv&)