ROOT » CORE » BASE » TROOT

class TROOT: public TDirectory

                R O O T top level object description

    The TROOT object is the entry point to the ROOT system.
    The single instance of TROOT is accessible via the global gROOT.
    Using the gROOT pointer one has access to basically every object
    created in a ROOT based program. The TROOT object is essentially a
    container of several lists pointing to the main ROOT objects.

    The following lists are accessible from gROOT object:
       gROOT->GetListOfClasses
       gROOT->GetListOfColors
       gROOT->GetListOfTypes
       gROOT->GetListOfGlobals
       gROOT->GetListOfGlobalFunctions
       gROOT->GetListOfFiles
       gROOT->GetListOfMappedFiles
       gROOT->GetListOfSockets
       gROOT->GetListOfSecContexts
       gROOT->GetListOfCanvases
       gROOT->GetListOfStyles
       gROOT->GetListOfFunctions
       gROOT->GetListOfSpecials (for example graphical cuts)
       gROOT->GetListOfGeometries
       gROOT->GetListOfBrowsers
       gROOT->GetListOfCleanups
       gROOT->GetListOfMessageHandlers

   The TROOT class provides also many useful services:
     - Get pointer to an object in any of the lists above
     - Time utilities TROOT::Time

   The ROOT object must be created as a static object. An example
   of a main program creating an interactive version is shown below:

Example of a main program

       #include "TRint.h"

       int main(int argc, char **argv)
       {
          TRint *theApp = new TRint("ROOT example", &argc, argv);

          // Init Intrinsics, build all windows, and enter event loop
          theApp->Run();

          return(0);
       }
End of Main program

Function Members (Methods)

public:
virtual~TROOT()
voidTObject::AbstractMethod(const char* method) const
virtual voidTDirectory::Add(TObject* obj, Bool_t replace = kFALSE)
voidAddClass(TClass* cl)
voidAddClassGenerator(TClassGenerator* gen)
static voidTDirectory::AddDirectory(Bool_t add = kTRUE)
static Bool_tTDirectory::AddDirectoryStatus()
virtual voidTDirectory::Append(TObject* obj, Bool_t replace = kFALSE)
virtual Int_tTDirectory::AppendKey(TKey*)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidBrowse(TBrowser* b)
virtual voidTDirectory::Build(TFile* motherFile = 0, TDirectory* motherDir = 0)
virtual Bool_tTDirectory::cd(const char* path = 0)
static Bool_tTDirectory::Cd(const char* path)
static TClass*Class()
virtual const char*TObject::ClassName() const
Bool_tClassSaved(TClass* cl)
virtual voidTDirectory::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual TObject*TDirectory::CloneObject(const TObject* obj, Bool_t autoadd = kTRUE)
virtual voidTDirectory::Close(Option_t* option = "")
voidCloseFiles()
virtual Int_tTNamed::Compare(const TObject* obj) const
static Int_tConvertVersionCode2Int(Int_t code)
static Int_tConvertVersionInt2Code(Int_t v)
virtual voidTDirectory::Copy(TObject&) const
static TDirectory*&TDirectory::CurrentDirectory()
static voidTDirectory::DecodeNameCycle(const char* namecycle, char* name, Short_t& cycle, const size_t namesize = 0)
static Int_tDecreaseDirLevel()
virtual voidTDirectory::Delete(const char* namecycle = "")
virtual voidTDirectory::DeleteAll(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTDirectory::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
static voidTDirectory::EncodeNameCycle(char* buffer, const char* name, Short_t cycle)
voidEndOfProcessCleanups()
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TKey*TDirectory::FindKey(const char*) const
virtual TKey*TDirectory::FindKeyAny(const char*) const
virtual TObject*FindObject(const char* name) const
virtual TObject*FindObject(const TObject* obj) const
virtual TObject*FindObjectAny(const char* name) const
virtual TObject*FindObjectAnyFile(const char* name) const
const char*FindObjectClassName(const char* name) const
const char*FindObjectPathName(const TObject* obj) const
TObject*FindSpecialObject(const char* name, void*& where)
TClass*FindSTLClass(const char* name, Bool_t load, Bool_t silent = kFALSE) const
voidForceStyle(Bool_t force = kTRUE)
Bool_tFromPopUp() const
virtual TObject*TDirectory::Get(const char* namecycle)
TApplication*GetApplication() const
virtual Int_tTDirectory::GetBufferSize() const
Int_tGetBuiltDate() const
Int_tGetBuiltTime() const
TClass*GetClass(const char* name, Bool_t load = kTRUE, Bool_t silent = kFALSE) const
TClass*GetClass(const type_info& typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE) const
TSeqCollection*GetClipboard() const
TColor*GetColor(Int_t color) const
const char*GetConfigFeatures() const
const char*GetConfigOptions() const
const char*GetCutClassName() const
const char*GetDefCanvasName() const
virtual TDirectory*TDirectory::GetDirectory(const char* namecycle, Bool_t printError = false, const char* funcname = "GetDirectory")
static Int_tGetDirLevel()
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Bool_tGetEditHistograms() const
Int_tGetEditorMode() const
static const char**&GetExtraInterpreterArgs()
virtual TFile*GetFile() const
TFile*GetFile(const char* name) const
Bool_tGetForceStyle() const
TObject*GetFunction(const char* name) const
TFunctionTemplate*GetFunctionTemplate(const char* name)
TObject*GetGeometry(const char* name) const
const char*GetGitBranch() const
const char*GetGitCommit() const
const char*GetGitDate()
TGlobal*GetGlobal(const char* name, Bool_t load = kFALSE) const
TGlobal*GetGlobal(const TObject* obj, Bool_t load = kFALSE) const
TFunction*GetGlobalFunction(const char* name, const char* params = 0, Bool_t load = kFALSE)
TFunction*GetGlobalFunctionWithPrototype(const char* name, const char* proto = 0, Bool_t load = kFALSE)
virtual const char*TObject::GetIconName() const
TInterpreter*GetInterpreter() const
virtual TKey*TDirectory::GetKey(const char*, Short_t = 9999) const
virtual TList*TDirectory::GetList() const
TList*GetListOfBrowsables() const
TSeqCollection*GetListOfBrowsers() const
TSeqCollection*GetListOfCanvases() const
TCollection*GetListOfClasses() const
TCollection*GetListOfClassGenerators() const
TSeqCollection*GetListOfCleanups() const
TSeqCollection*GetListOfClosedObjects() const
TSeqCollection*GetListOfColors() const
TSeqCollection*GetListOfDataSets() const
TCollection*GetListOfEnums(Bool_t load = kFALSE)
TSeqCollection*GetListOfFiles() const
TCollection*GetListOfFunctionOverloads(const char* name) const
TCollection*GetListOfFunctions() const
TCollection*GetListOfFunctionTemplates()
TSeqCollection*GetListOfGeometries() const
TCollection*GetListOfGlobalFunctions(Bool_t load = kFALSE)
TCollection*GetListOfGlobals(Bool_t load = kFALSE)
virtual TList*TDirectory::GetListOfKeys() const
TSeqCollection*GetListOfMappedFiles() const
TSeqCollection*GetListOfMessageHandlers() const
TSeqCollection*GetListOfProofs() const
TSeqCollection*GetListOfSecContexts() const
TSeqCollection*GetListOfSockets() const
TSeqCollection*GetListOfSpecials() const
TSeqCollection*GetListOfStreamerInfo() const
TSeqCollection*GetListOfStyles() const
TSeqCollection*GetListOfTasks() const
TCollection*GetListOfTypes(Bool_t load = kFALSE)
static const char*GetMacroPath()
virtual TObject*TDirectory::GetMother() const
virtual TDirectory*TDirectory::GetMotherDir() const
virtual const char*TNamed::GetName() const
virtual Int_tTDirectory::GetNbytesKeys() const
Int_tGetNclasses() const
virtual Int_tTDirectory::GetNkeys() const
Int_tGetNtypes() const
virtual void*TDirectory::GetObjectChecked(const char* namecycle, const char* classname)
virtual void*TDirectory::GetObjectChecked(const char* namecycle, const TClass* cl)
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual void*TDirectory::GetObjectUnchecked(const char* namecycle)
virtual Option_t*TObject::GetOption() const
virtual const char*TDirectory::GetPath() const
virtual const char*TDirectory::GetPathStatic() const
TPluginManager*GetPluginManager() const
TFolder*GetRootFolder() const
virtual Long64_tTDirectory::GetSeekDir() const
virtual Long64_tTDirectory::GetSeekKeys() const
virtual Long64_tTDirectory::GetSeekParent() const
TVirtualPad*GetSelectedPad() const
const TObject*GetSelectedPrimitive() const
TStyle*GetStyle(const char* name) const
virtual const char*TNamed::GetTitle() const
static const char*GetTutorialsDir()
TDataType*GetType(const char* name, Bool_t load = kFALSE) const
virtual UInt_tTObject::GetUniqueID() const
TUUIDTDirectory::GetUUID() const
TProcessUUID*GetUUIDs() const
const char*GetVersion() const
Int_tGetVersionCode() const
Int_tGetVersionDate() const
Int_tGetVersionInt() const
Int_tGetVersionTime() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
voidIdle(UInt_t idleTimeInSec, const char* command = 0)
Int_tIgnoreInclude(const char* fname, const char* expandedfname)
static Int_tIncreaseDirLevel()
static voidIndentLevel()
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
static Bool_tInitialized()
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tIsBatch() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
Bool_tIsEscaped() const
Bool_tIsExecutingMacro() const
virtual Bool_tIsFolder() const
Bool_tIsInterrupted() const
Bool_tIsLineProcessing() const
virtual Bool_tTDirectory::IsModified() const
Bool_tTObject::IsOnHeap() const
Bool_tIsProofServ() const
Bool_tIsRootFile(const char* filename) const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tTDirectory::IsWritable() const
Bool_tTObject::IsZombie() const
TClass*LoadClass(const char* name, Bool_t silent = kFALSE) const
Int_tLoadClass(const char* classname, const char* libname, Bool_t check = kFALSE)
Int_tLoadMacro(const char* filename, Int_t* error = 0, Bool_t check = kFALSE)
virtual voidls(Option_t* option = "") const
Long_tMacro(const char* filename, Int_t* error = 0, Bool_t padUpdate = kTRUE)
TCanvas*MakeDefCanvas() const
voidTObject::MayNotUse(const char* method) const
static Bool_tMemCheck()
voidMessage(Int_t id, const TObject* obj)
virtual TDirectory*TDirectory::mkdir(const char* name, const char* title = "")
Bool_tMustClean() const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
virtual TFile*TDirectory::OpenFile(const char*, Option_t* = "", const char* = "", Int_t = 1, Int_t = 0)
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTDirectory::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTDirectory::Print(Option_t* option = "") const
Long_tProcessLine(const char* line, Int_t* error = 0)
Long_tProcessLineFast(const char* line, Int_t* error = 0)
Long_tProcessLineSync(const char* line, Int_t* error = 0)
virtual voidTDirectory::Purge(Short_t = 1)
virtual voidTDirectory::pwd() const
virtual Int_tTObject::Read(const char* name)
virtual voidTDirectory::ReadAll(Option_t* = "")
Bool_tReadingObject() const
virtual Int_tTDirectory::ReadKeys(Bool_t = kTRUE)
virtual Int_tTDirectory::ReadTObject(TObject*, const char*)
virtual voidTDirectory::RecursiveRemove(TObject* obj)
voidRefreshBrowsers()
static voidRegisterModule(const char* modulename, const char** headers, const char** includePaths, const char* payLoadCode, const char* fwdDeclCode, void(*)() triggerFunc, const TROOT::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip, const char** classesHeaders)
virtual TObject*TDirectory::Remove(TObject*)
voidRemoveClass(TClass*)
voidReset(Option_t* option = "")
voidTObject::ResetBit(UInt_t f)
virtual voidTDirectory::rmdir(const char* name)
static Int_tRootVersionCode()
virtual voidTDirectory::Save()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
voidSaveContext()
virtual Int_tTDirectory::SaveObjectAs(const TObject*, const char* = "", Option_t* = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual voidTDirectory::SaveSelf(Bool_t = kFALSE)
voidSetApplication(TApplication* app)
voidSetBatch(Bool_t batch = kTRUE)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTDirectory::SetBufferSize(Int_t)
voidSetCutClassName(const char* name = "TCutG")
voidSetDefCanvasName(const char* name = "c1")
static voidSetDirLevel(Int_t level = 0)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetEditHistograms(Bool_t flag = kTRUE)
voidSetEditorMode(const char* mode = "")
voidSetEscape(Bool_t flag = kTRUE)
voidSetExecutingMacro(Bool_t flag = kTRUE)
voidSetFromPopUp(Bool_t flag = kTRUE)
voidSetInterrupt(Bool_t flag = kTRUE)
voidSetLineHasBeenProcessed()
voidSetLineIsProcessing()
static voidSetMacroPath(const char* newpath)
virtual voidTDirectory::SetModified()
virtual voidTDirectory::SetMother(TObject* mother)
voidSetMustClean(Bool_t flag = kTRUE)
virtual voidTDirectory::SetName(const char* newname)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetReadingObject(Bool_t flag = kTRUE)
virtual voidTDirectory::SetSeekDir(Long64_t)
voidSetSelectedPad(TVirtualPad* pad)
voidSetSelectedPrimitive(const TObject* obj)
voidSetStyle(const char* stylename = "Default")
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTDirectory::SetTRefAction(TObject*, TObject*)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidTDirectory::SetWritable(Bool_t)
virtual voidShowMembers(TMemberInspector& insp) const
virtual Int_tTDirectory::Sizeof() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTime(Int_t casetime = 1)
Int_tTimer() const
TROOT(const char* name, const char* title, VoidFuncPtr_t* initfunc = 0)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTDirectory::Write(const char* = 0, Int_t = 0, Int_t = 0)
virtual Int_tTDirectory::Write(const char* = 0, Int_t = 0, Int_t = 0) const
virtual voidTDirectory::WriteDirHeader()
virtual voidTDirectory::WriteKeys()
virtual Int_tTDirectory::WriteObjectAny(const void*, const char*, const char*, Option_t* = "", Int_t = 0)
virtual Int_tTDirectory::WriteObjectAny(const void*, const TClass*, const char*, Option_t* = "", Int_t = 0)
virtual Int_tTDirectory::WriteTObject(const TObject* obj, const char* name = 0, Option_t* = "", Int_t = 0)
protected:
Bool_tTDirectory::cd1(const char* path)
static Bool_tTDirectory::Cd1(const char* path)
virtual voidTDirectory::CleanTargets()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTDirectory::FillFullPath(TString& buf) const
TListOfFunctions*GetGlobalFunctions()
voidInitInterpreter()
voidInitSystem()
voidInitThreads()
voidTObject::MakeZombie()
void*operator new(size_t l)
void*operator new(size_t l, void* ptr)
voidReadGitInfo()
voidTDirectory::RegisterContext(TDirectory::TContext* ctxt)
TROOT()
voidTDirectory::UnregisterContext(TDirectory::TContext* ctxt)
private:
TROOT&operator=(const TROOT&)
TROOT(const TROOT&)

Data Members

public:
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TObject::EStatusBitsTObject::kHasUUID
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TObject::(anonymous)TObject::kOverwrite
static TObject::(anonymous)TObject::kSingleKey
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
atomic<TApplication*>fApplicationPointer to current application
Bool_tfBatchTrue if session without graphics
TList*fBrowsablesList of browsables
TSeqCollection*fBrowsersList of browsers
Int_tfBuiltDateDate of ROOT built
Int_tfBuiltTimeTime of ROOT built
TSeqCollection*fCanvasesList of canvases
TCollection*fClassGeneratorsList of user defined class generators;
TCollection*fClassesList of classes definition
TSeqCollection*fCleanupsList of recursiveRemove collections
TSeqCollection*fClipboardList of clipbard objects
TSeqCollection*fClosedObjectsList of closed objects from the list of files and sockets, so we can delete them if neededCl.
TSeqCollection*fColorsList of colors
TStringfConfigFeaturesROOT ./configure detected build features
TStringfConfigOptionsROOT ./configure set build options
TDirectory::TContext*TDirectory::fContext!Pointer to a list of TContext object pointing to this TDirectory
TStringfCutClassNameName of default CutG class in graphics editor
TSeqCollection*fDataSetsList of data sets (TDSet or TChain)
TStringfDefCanvasNameName of default canvas
Bool_tfEditHistogramsTrue if histograms can be edited with the mouse
Int_tfEditorModeCurrent Editor mode
TROOT::AListOfEnums_tfEnumsList of enum types
Bool_tfEscapeTrue if ESC has been pressed
Bool_tfExecutingMacroTrue while executing a TMacro
TSeqCollection*fFilesList of files
Bool_tfForceStyleForce setting of current style when reading objects
Bool_tfFromPopUpTrue if command executed from a popup menu
TListOfFunctionTemplates*fFuncTemplateList of global function templates
TCollection*fFunctionsList of analytic functions
TSeqCollection*fGeometriesList of geometries
TStringfGitBranchGit branch
TStringfGitCommitGit commit SHA1 of built
TStringfGitDateDate and time when make was run
TListOfFunctions*fGlobalFunctionsList of global functions
TListOfDataMembers*fGlobalsList of global variables
TInterpreter*fInterpreterCommand interpreter
Bool_tfInterruptTrue if macro should be interrupted
TList*TDirectory::fListList of objects in memory
TSeqCollection*fMappedFilesList of memory mapped files
TSeqCollection*fMessageHandlersList of message handlers
TObject*TDirectory::fMotherpointer to mother of the directory
Bool_tfMustCleanTrue if object destructor scans canvases
TStringTNamed::fNameobject identifier
TStringTDirectory::fPathBuffer!Buffer for GetPath() function
TPluginManager*fPluginManagerKeeps track of plugin library handlers
const TObject*fPrimitiveCurrently selected primitive
TSeqCollection*fProofsList of proof sessions
Bool_tfReadingObjectTrue while reading an object [Deprecated (will be removed in next release)
TFolder*fRootFoldertop level folder //root
TSeqCollection*fSecContextsList of security contexts (TSecContext)
TVirtualPad*fSelectPadCurrently selected pad
TSeqCollection*fSocketsList of network sockets
TSeqCollection*fSpecialsList of special objects
TSeqCollection*fStreamerInfoList of active StreamerInfo classes
TSeqCollection*fStylesList of styles
TSeqCollection*fTasksList of tasks
Int_tfTimerTimer flag
TStringTNamed::fTitleobject title
TCollection*fTypesList of data types definition
TUUIDTDirectory::fUUIDUnique identifier
TProcessUUID*fUUIDsPointer to TProcessID managing TUUIDs
TStringfVersionROOT version (from CMZ VERSQQ) ex 0.05/01
Int_tfVersionCodeROOT version code as used in RVersion.h
Int_tfVersionDateDate of ROOT version (ex 951226)
Int_tfVersionIntROOT version in integer format (501)
Int_tfVersionTimeTime of ROOT version (ex 1152)
static Bool_tTDirectory::fgAddDirectory!flag to add histograms, graphs,etc to the directory
private:
Int_tfLineIsProcessingTo synchronize multi-threads
static Int_tfgDirLevelIndentation level for ls()
static Bool_tfgMemCheckTurn on memory leak checker
static Bool_tfgRootInitSingleton initialization flag

Class Charts

Inheritance Chart:
TObject
TNamed
TDirectory
TROOT

Function documentation

TROOT()
 Default ctor.
TROOT(const char* name, const char* title, VoidFuncPtr_t* initfunc = 0)
 Initialize the ROOT system. The creation of the TROOT object initializes
 the ROOT system. It must be the first ROOT related action that is
 performed by a program. The TROOT object must be created on the stack
 (can not be called via new since "operator new" is protected). The
 TROOT object is either created as a global object (outside the main()
 program), or it is one of the first objects created in main().
 Make sure that the TROOT object stays in scope for as long as ROOT
 related actions are performed. TROOT is a so called singleton so
 only one instance of it can be created. The single TROOT object can
 always be accessed via the global pointer gROOT.
 The name and title arguments can be used to identify the running
 application. The initfunc argument can contain an array of
 function pointers (last element must be 0). These functions are
 executed at the end of the constructor. This way one can easily
 extend the ROOT system without adding permanent dependencies
 (e.g. the graphics system is initialized via such a function).
~TROOT()
 Clean up and free resources used by ROOT (files, network sockets,
 shared memory segments, etc.).
void AddClass(TClass* cl)
 Add a class to the list and map of classes.
 This routine is deprecated, use TClass::AddClass directly.
void AddClassGenerator(TClassGenerator* gen)
 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.
void Browse(TBrowser* b)
 Add browsable objects to TBrowser.
Bool_t ClassSaved(TClass* cl)
 return class status bit kClassSaved for class cl
 This function is called by the SavePrimitive functions writing
 the C++ code for an object.
void CloseFiles()
 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!
void EndOfProcessCleanups()
 Execute the cleanups necessary at the end of the process, in particular
 those that must be executed before the library start being unloaded.
TObject * FindObject(const TObject* obj) const
 Find an object in one Root folder
TObject * FindObject(const char* name) const
 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
TObject * FindSpecialObject(const char* name, void*& where)
 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
TObject * FindObjectAny(const char* name) const
 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.
TObject * FindObjectAnyFile(const char* name) const
 Scan the memory lists of all files for an object with name
const char * FindObjectClassName(const char* name) const
 Returns class name of a ROOT object including CINT globals.
const char * FindObjectPathName(const TObject* obj) const
 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 their area.
TClass * FindSTLClass(const char* name, Bool_t load, Bool_t silent = kFALSE) const
 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).
TClass * GetClass(const char* name, Bool_t load = kTRUE, Bool_t silent = kFALSE) const
 Return pointer to class with name. Obsolete, use TClass::GetClass directly
TClass * GetClass(const type_info& typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE) const
 Return pointer to class from its name. Obsolete, use TClass::GetClass directly
 See TClass::GetClass
TColor * GetColor(Int_t color) const
 Return address of color with index color.
TCanvas * MakeDefCanvas() const
 Return a default canvas.
TDataType * GetType(const char* name, Bool_t load = kFALSE) const
 Return pointer to type with name.
TFile * GetFile(const char* name) const
 Return pointer to file with name.
TStyle * GetStyle(const char* name) const
 Return pointer to style with name
TObject * GetFunction(const char* name) const
 Return pointer to function with name.
TFunctionTemplate * GetFunctionTemplate(const char* name)
TGlobal * GetGlobal(const char* name, Bool_t load = kFALSE) const
 Return pointer to global variable by name. If load is true force
 reading of all currently defined globals from CINT (more expensive).
TGlobal * GetGlobal(const TObject* obj, Bool_t load = kFALSE) const
 Return pointer to global variable with address addr.
TListOfFunctions * GetGlobalFunctions()
 Internal routine returning, and creating if necessary, the list
 of global function.
TCollection * GetListOfFunctionOverloads(const char* name) const
 Return the collection of functions named "name".
TFunction * GetGlobalFunction(const char* name, const char* params = 0, Bool_t load = kFALSE)
 Return pointer to global function by name.
 If params != 0 it will also resolve overloading other it returns the first
 name match.
 If params == 0 and load is true force reading of all currently defined
 global functions from Cling.
 The param string must be of the form: "3189,\"aap\",1.3".
TFunction * GetGlobalFunctionWithPrototype(const char* name, const char* proto = 0, Bool_t load = kFALSE)
 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".
TObject * GetGeometry(const char* name) const
 Return pointer to Geometry with name
TCollection * GetListOfEnums(Bool_t load = kFALSE)
TCollection * GetListOfFunctionTemplates()
TCollection * GetListOfGlobals(Bool_t load = kFALSE)
 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).
TCollection * GetListOfGlobalFunctions(Bool_t load = kFALSE)
 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).
TCollection * GetListOfTypes(Bool_t load = kFALSE)
 Return a dynamic list giving access to all TDataTypes (typedefs)
 currently defined.

 The list is populated on demand.  Calling
    gROOT->GetListOfTypes()->FindObject(nameoftype);
 will return the TDataType corresponding to 'nameoftype'.  If the
 TDataType is not already in the list itself and the type does exist,
 a new TDataType will be created and added to the list.

 Calling
    gROOT->GetListOfTypes()->ls(); // or Print()
 list only the typedefs that have been previously accessed throught the
 list (plus the builtins types).

void Idle(UInt_t idleTimeInSec, const char* command = 0)
 Execute command when system has been idle for idleTimeInSec seconds.
Int_t IgnoreInclude(const char* fname, const char* expandedfname)
 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.
void InitSystem()
 Initialize operating system interface.
void InitThreads()
 Load and initialize thread library.
void InitInterpreter()
 Initialize the interpreter. Should be called only after main(),
 to make sure LLVM/Clang is fully initialized.
TClass * LoadClass(const char* name, Bool_t silent = kFALSE) const
 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)

 The 'requestedname' is expected to be already normalized.
Int_t LoadClass(const char* classname, const char* libname, Bool_t check = kFALSE)
 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.
Bool_t IsRootFile(const char* filename) const
 Return true if the file is local and is (likely) to be a ROOT file
void ls(Option_t* option = "") const
 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.
Int_t LoadMacro(const char* filename, Int_t* error = 0, Bool_t check = kFALSE)
 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.
Long_t Macro(const char* filename, Int_t* error = 0, Bool_t padUpdate = kTRUE)
 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.
void Message(Int_t id, const TObject* obj)
 Process message id called by obj.
Long_t ProcessLine(const char* line, Int_t* error = 0)
 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.
Long_t ProcessLineSync(const char* line, Int_t* error = 0)
 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.
Long_t ProcessLineFast(const char* line, Int_t* error = 0)
 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.
void ReadGitInfo()
 Read Git commit information and branch name from the
 etc/gitinfo.txt file.
Bool_t ReadingObject() const
Deprecated (will be removed in next release)
void SetReadingObject(Bool_t flag = kTRUE)
const char * GetGitDate()
 Return date/time make was run.
void RefreshBrowsers()
 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.
void RegisterModule(const char* modulename, const char** headers, const char** includePaths, const char* payLoadCode, const char* fwdDeclCode, void(*)() triggerFunc, const TROOT::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip, const char** classesHeaders)
 Called by static dictionary initialization to register clang modules
 for headers. Calls TCling::RegisterModule() unless gCling
 is NULL, i.e. during startup, where the information is buffered in
 the static GetModuleHeaderInfoBuffer().
void RemoveClass(TClass* )
 Remove a class from the list and map of classes.
 This routine is deprecated, use TClass::RemoveClass directly.
void Reset(Option_t* option = "")
 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.

void SaveContext()
 Save the current interpreter context.
void SetCutClassName(const char* name = "TCutG")
 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
void SetEditorMode(const char* mode = "")
 Set editor mode
void SetStyle(const char* stylename = "Default")
 Change current style to style with name stylename
Int_t DecreaseDirLevel()
 Decrease the indentation level for ls().
Int_t GetDirLevel()
return directory level
const char * GetMacroPath()
 Get macro search path. Static utility function.
void SetMacroPath(const char* newpath)
 Set or extend the macro search path. Static utility function.
 If newpath=0 or "" reset to value specified in the rootrc file.
Int_t IncreaseDirLevel()
 Increase the indentation level for ls().
void IndentLevel()
 Functions used by ls() to indent an object hierarchy.
Bool_t Initialized()
 Return kTRUE if the TROOT object has been initialized.
Bool_t MemCheck()
 Return kTRUE if the memory leak checker is on.
void SetDirLevel(Int_t level = 0)
 Return Indentation level for ls().
Int_t ConvertVersionCode2Int(Int_t code)
 Convert version code to an integer, i.e. 331527 -> 51507.
Int_t ConvertVersionInt2Code(Int_t v)
 Convert version as an integer to version code as used in RVersion.h.
Int_t RootVersionCode()
 Return ROOT version code as defined in RVersion.h.
const char**& GetExtraInterpreterArgs()
const char * GetTutorialsDir()
 Get the tuorials directory in the installtion. Static utility function.
TROOT(const TROOT& )
TROOT& operator=(const TROOT& )
void * operator new(size_t l)
{ return TObject::operator new(l); }
void * operator new(size_t l, void* ptr)
{ return TObject::operator new(l,ptr); }
void ForceStyle(Bool_t force = kTRUE)
{ fForceStyle = force; }
Bool_t FromPopUp() const
{ return fFromPopUp; }
TPluginManager * GetPluginManager() const
{ return fPluginManager; }
TApplication * GetApplication() const
{ return fApplication; }
TInterpreter * GetInterpreter() const
{ return fInterpreter; }
const char * GetConfigOptions() const
{ return fConfigOptions; }
const char * GetConfigFeatures() const
{ return fConfigFeatures; }
const char * GetCutClassName() const
{ return fCutClassName; }
const char * GetDefCanvasName() const
{ return fDefCanvasName; }
Bool_t GetEditHistograms() const
{ return fEditHistograms; }
Int_t GetEditorMode() const
{ return fEditorMode; }
Bool_t GetForceStyle() const
{ return fForceStyle; }
Int_t GetBuiltDate() const
{ return fBuiltDate; }
Int_t GetBuiltTime() const
{ return fBuiltTime; }
const char * GetGitCommit() const
{ return fGitCommit; }
const char * GetGitBranch() const
{ return fGitBranch; }
Int_t GetVersionDate() const
{ return fVersionDate; }
Int_t GetVersionTime() const
{ return fVersionTime; }
Int_t GetVersionInt() const
{ return fVersionInt; }
Int_t GetVersionCode() const
{ return fVersionCode; }
const char * GetVersion() const
{ return fVersion; }
TCollection * GetListOfClasses() const
{ return fClasses; }
TSeqCollection * GetListOfColors() const
{ return fColors; }
TSeqCollection * GetListOfClosedObjects() const
{ return fClosedObjects; }
TSeqCollection * GetListOfFiles() const
{ return fFiles; }
TSeqCollection * GetListOfMappedFiles() const
{ return fMappedFiles; }
TSeqCollection * GetListOfSockets() const
{ return fSockets; }
TSeqCollection * GetListOfCanvases() const
{ return fCanvases; }
TSeqCollection * GetListOfStyles() const
{ return fStyles; }
TCollection * GetListOfFunctions() const
{ return fFunctions; }
TSeqCollection * GetListOfGeometries() const
{ return fGeometries; }
TSeqCollection * GetListOfBrowsers() const
{ return fBrowsers; }
TSeqCollection * GetListOfSpecials() const
{ return fSpecials; }
TSeqCollection * GetListOfTasks() const
{ return fTasks; }
TSeqCollection * GetListOfCleanups() const
{ return fCleanups; }
TSeqCollection * GetListOfStreamerInfo() const
{ return fStreamerInfo; }
TSeqCollection * GetListOfMessageHandlers() const
{ return fMessageHandlers; }
TCollection * GetListOfClassGenerators() const
{ return fClassGenerators; }
TSeqCollection * GetListOfSecContexts() const
{ return fSecContexts; }
TSeqCollection * GetListOfProofs() const
{ return fProofs; }
TSeqCollection * GetClipboard() const
{ return fClipboard; }
TSeqCollection * GetListOfDataSets() const
{ return fDataSets; }
TList * GetListOfBrowsables() const
{ return fBrowsables; }
TFile * GetFile() const
{ if (gDirectory != this) return gDirectory->GetFile(); else return 0;}
const TObject * GetSelectedPrimitive() const
{ return fPrimitive; }
TVirtualPad * GetSelectedPad() const
{ return fSelectPad; }
Int_t GetNclasses() const
{ return fClasses->GetSize(); }
Int_t GetNtypes() const
{ return fTypes->GetSize(); }
TFolder * GetRootFolder() const
{ return fRootFolder; }
TProcessUUID * GetUUIDs() const
{ return fUUIDs; }
Bool_t IsBatch() const
{ return fBatch; }
Bool_t IsExecutingMacro() const
{ return fExecutingMacro; }
Bool_t IsFolder() const
{ return kTRUE; }
Bool_t IsInterrupted() const
{ return fInterrupt; }
Bool_t IsEscaped() const
{ return fEscape; }
Bool_t IsLineProcessing() const
Bool_t IsProofServ() const
{ return fName == "proofserv" ? kTRUE : kFALSE; }
Bool_t MustClean() const
{ return fMustClean; }
void SetApplication(TApplication* app)
{ fApplication = app; }
void SetBatch(Bool_t batch = kTRUE)
{ fBatch = batch; }
void SetDefCanvasName(const char* name = "c1")
{ fDefCanvasName = name; }
void SetEditHistograms(Bool_t flag = kTRUE)
{ fEditHistograms = flag; }
void SetExecutingMacro(Bool_t flag = kTRUE)
{ fExecutingMacro = flag; }
void SetFromPopUp(Bool_t flag = kTRUE)
{ fFromPopUp = flag; }
void SetInterrupt(Bool_t flag = kTRUE)
{ fInterrupt = flag; }
void SetEscape(Bool_t flag = kTRUE)
{ fEscape = flag; }
void SetLineIsProcessing()
void SetLineHasBeenProcessed()
void SetMustClean(Bool_t flag = kTRUE)
{ fMustClean=flag; }
void SetSelectedPrimitive(const TObject* obj)
{ fPrimitive = obj; }
void SetSelectedPad(TVirtualPad* pad)
{ fSelectPad = pad; }
void Time(Int_t casetime = 1)
{ fTimer = casetime; }
Int_t Timer() const
{ return fTimer; }