TClass

class TClass : public TDictionary

    private:

            TMethod* GetClassMethod(Long_t faddr)
            TMethod* GetClassMethod(const char* name, const char* signature)
      TStreamerInfo* GetCurrentStreamerInfo()
                void Init(const char* name, Version_t cversion, const type_info* info, TVirtualIsAProxy* isa, ShowMembersFunc_t showmember, const char* dfil, const char* ifil, Int_t dl, Int_t il)
                void SetClassSize(Int_t sizof)
                void SetClassVersion(Version_t version)

    public:

                               TClass()
                               TClass(const char* name)
                               TClass(const char* name, Version_t cversion, const char* dfil = "0", const char* ifil = "0", Int_t dl = 0, Int_t il = 0)
                               TClass(const char* name, Version_t cversion, const type_info& info, TVirtualIsAProxy* isa, ShowMembersFunc_t showmember, const char* dfil, const char* ifil, Int_t dl, Int_t il)
                               TClass(const TClass&)
                       virtual ~TClass()
                          void AddImplFile(const char* filename, int line)
                          void AddInstance(Bool_t heap = kFALSE)
                          void AddRef(TClassRef* ref)
                          void AdoptMemberStreamer(const char* name, TMemberStreamer* strm)
                          void AdoptStreamer(TClassStreamer* strm)
                  static Int_t AutoBrowse(TObject* obj, TBrowser* browser)
                  virtual void Browse(TBrowser* b)
                         Int_t Browse(void* obj, TBrowser* b) const
                          void BuildEmulatedRealData(const char* name, Int_t offset, TClass* cl)
                          void BuildRealData(void* pointer = 0)
                        Bool_t CanIgnoreTObjectStreamer()
                        Bool_t CanSplit() const
                static TClass* Class()
                          void CopyCollectionProxy(const TVirtualCollectionProxy&)
                          void Destructor(void* obj, Bool_t dtorOnly = kFALSE)
                  virtual void Draw(Option_t* option = "")
                  virtual void Dump() const
                          void Dump(void* obj) const
                         void* DynamicCast(const TClass* base, void* obj, Bool_t up = kTRUE)
                         char* EscapeChars(const char* text) const
                       TClass* GetActualClass(const void* object) const
                       TClass* GetBaseClass(const char* classname)
                       TClass* GetBaseClass(const TClass* base)
                         Int_t GetBaseClassOffset(const TClass* base)
                       TClass* GetBaseDataMember(const char* datamember)
                        UInt_t GetCheckSum(UInt_t code = 0) const
                static TClass* GetClass(const char* name, Bool_t load = kTRUE)
                static TClass* GetClass(const type_info& typeinfo, Bool_t load = kTRUE)
                 G__ClassInfo* GetClassInfo() const
                     Version_t GetClassVersion() const
      TVirtualCollectionProxy* GetCollectionProxy() const
                  TDataMember* GetDataMember(const char* datamember) const
                         Int_t GetDataMemberOffset(const char* membername) const
                       Short_t GetDeclFileLine() const
                   const char* GetDeclFileName() const
               ROOT::DelFunc_t GetDelete() const
            ROOT::DelArrFunc_t GetDeleteArray() const
               ROOT::DesFunc_t GetDestructor() const
          static VoidFuncPtr_t GetDict(const char* cname)
          static VoidFuncPtr_t GetDict(const type_info& info)
                        TList* GetEditorList() const
                        UInt_t GetHeapInstanceCount() const
                       Short_t GetImplFileLine() const
                   const char* GetImplFileName() const
                        UInt_t GetInstanceCount() const
             TVirtualIsAProxy* GetIsAProxy() const
                        TList* GetListOfAllPublicDataMembers()
                        TList* GetListOfAllPublicMethods()
                        TList* GetListOfBases()
                        TList* GetListOfDataMembers()
                        TList* GetListOfMethods()
                        TList* GetListOfRealData() const
                          void GetMenuItems(TList* listitems)
                        TList* GetMenuList() const
                      TMethod* GetMethod(const char* method, const char* params)
                      TMethod* GetMethodAllAny(const char* method)
                      TMethod* GetMethodAny(const char* method)
                      TMethod* GetMethodWithPrototype(const char* method, const char* proto)
                         Int_t GetNdata()
               ROOT::NewFunc_t GetNew() const
            ROOT::NewArrFunc_t GetNewArray() const
                         Int_t GetNmethods()
                    TRealData* GetRealData(const char* name) const
                   const char* GetSharedLibs() const
             ShowMembersFunc_t GetShowMembersWrapper() const
               TClassStreamer* GetStreamer() const
                TStreamerInfo* GetStreamerInfo(Int_t version = 0)
                    TObjArray* GetStreamerInfos() const
              const type_info* GetTypeInfo() const
                        Bool_t HasDefaultConstructor() const
                          void IgnoreTObjectStreamer(Bool_t ignore = kTRUE)
                virtual Bool_t InheritsFrom(const char* cl) const
                virtual Bool_t InheritsFrom(const TClass* cl) const
               virtual TClass* IsA() const
       static TClass::ENewType IsCallingNew()
                virtual Bool_t IsFolder() const
                        Bool_t IsFolder(void* obj) const
                        Bool_t IsForeign() const
                        Bool_t IsLoaded() const
                        Bool_t IsStartingWithTObject() const
                        Bool_t IsTObject() const
                static TClass* Load(TBuffer& b)
                          void MakeCustomMenuList()
                         void* New(TClass::ENewType defConstructor = kClassNew)
                         void* New(void* arena, TClass::ENewType defConstructor = kClassNew)
                virtual Long_t Property() const
                         Int_t ReadBuffer(TBuffer& b, void* pointer, Int_t version, UInt_t start, UInt_t count)
                         Int_t ReadBuffer(TBuffer& b, void* pointer)
                          void RemoveRef(TClassRef* ref)
                          void ReplaceWith(TClass* newcl, Bool_t recurse = kTRUE) const
                          void ResetClassInfo(Long_t tagnum)
                          void ResetInstanceCount()
                          void ResetMenuList()
                          void SetDelete(ROOT::DelFunc_t deleteFunc)
                          void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
                          void SetDestructor(ROOT::DesFunc_t destructorFunc)
                          void SetGlobalIsA(IsAGlobalFunc_t)
                          void SetMemberStreamer(const char* name, MemberStreamerFunc_t strm)
                          void SetNew(ROOT::NewFunc_t newFunc)
                          void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
                TStreamerInfo* SetStreamerInfo(Int_t version, const char* info = "")
                          void SetUnloaded()
                  virtual void ShowMembers(TMemberInspector& insp, char* parent)
                         Int_t Size() const
                          void Store(TBuffer& b) const
                          void Streamer(void* obj, TBuffer& b)
                  virtual void Streamer(TBuffer& b)
                          void StreamerNVirtual(TBuffer& b)
                         Int_t WriteBuffer(TBuffer& b, void* pointer, const char* info = "")

Data Members

    private:

                    TObjArray* fStreamerInfo     Array of TStreamerInfo
                        TList* fRealData         linked list for persistent members including base classes
                        TList* fBase             linked list for base classes
                        TList* fData             linked list for data members
                        TList* fMethod           linked list for methods
                        TList* fAllPubData       all public data members (including from base classes)
                        TList* fAllPubMethod     all public methods (including from base classes)
                   const char* fDeclFileName     name of class declaration file
                   const char* fImplFileName     name of class implementation file
                       Short_t fDeclFileLine     line of class declaration
                       Short_t fImplFileLine     line of class implementation
                        UInt_t fInstanceCount    number of instances of this class
                        UInt_t fOnHeap           number of instances on heap
                        UInt_t fCheckSum         checksum of data members and base classes
      TVirtualCollectionProxy* fCollectionProxy  Collection interface
                     Version_t fClassVersion     Class version Identifier
                 G__ClassInfo* fClassInfo        pointer to CINT class info class
                        TList* fClassMenuList    list of class menu items
                        TList* fClassEditors     list of class editors
              const type_info* fTypeInfo         pointer to the C++ type information.
             ShowMembersFunc_t fShowMembers      pointer to the class's ShowMembers function
               TClassStreamer* fStreamer         pointer to streamer function
                       TString fSharedLibs       shared libraries containing class code
             TVirtualIsAProxy* fIsA              !pointer to the class's IsA proxy.
               IsAGlobalFunc_t fGlobalIsA        pointer to a global IsA function.
                  TMethodCall* fIsAMethod        !saved info to call a IsA member function
                         void* fNew              pointer to a function newing one object.
                         void* fNewArray         pointer to a function newing an array of objects.
                         void* fDelete           pointer to a function deleting one object.
                         void* fDeleteArray      pointer to a function deleting an array of objects.
                         void* fDestructor       pointer to a function call an object's destructor.
                         Int_t fSizeof           Sizeof the class.
                        Bool_t fVersionUsed      !Indicates whether GetClassVersion has been called
                        Long_t fProperty         !Property
                         void* fInterStreamer    !saved info to call Streamer
                        Long_t fOffsetStreamer   !saved info to call Streamer
                         Int_t fStreamerType     !cached of the streaming method to use
                TStreamerInfo* fCurrentInfo      !cached current streamer info.
                    TClassRef* fRefStart         !List of references to this object
       static TClass::ENewType fgCallingNew      Intent of why/how TClass::New() is called
                  static Int_t fgClassCount      provides unique id for a each class

    public:

         static const enum TClass:: kClassSaved             
         static const enum TClass:: kIgnoreTObjectStreamer  
         static const enum TClass:: kUnloaded               
         static const enum TClass:: kIsTObject              
         static const enum TClass:: kIsForeign              
         static const enum TClass:: kIsEmulation            
         static const enum TClass:: kStartWithTObject       
      static const TClass::ENewType kRealNew                
      static const TClass::ENewType kClassNew               
      static const TClass::ENewType kDummyNew               
         static const enum TClass:: kLoading                
         static const enum TClass:: kDefault                
         static const enum TClass:: kEmulated               
         static const enum TClass:: kTObject                
         static const enum TClass:: kInstrumented           
         static const enum TClass:: kForeign                
         static const enum TClass:: kExternal               

Class Description

                                                                      
  The ROOT global object gROOT contains a list of all defined         
  classes. This list is build when a reference to a class dictionary  
  is made. When this happens, the static "class"::Dictionary()        
  function is called to create a TClass object describing the         
  class. The Dictionary() function is defined in the ClassDef         
  macro and stored (at program startup or library load time) together 
  with the class name in the TClassTable singleton object.            
  For a description of all dictionary classes see TDictionary.        
                                                                      

 Default ctor.

 Create a TClass object. This object contains the full dictionary
 of a class. It has list to baseclasses, datamembers and methods.
 Use this ctor to create a standalone TClass object. Most useful
 to get a TClass interface to an interpreted class. Used by TTabCom.
 Normally you would use gROOT->GetClass("class") to get access to a
 TClass object for a certain class.

 Create a TClass object. This object contains the full dictionary
 of a class. It has list to baseclasses, datamembers and methods.

 Create a TClass object. This object contains the full dictionary
 of a class. It has list to baseclasses, datamembers and methods.

 Initialize a TClass object. This object contains the full dictionary
 of a class. It has list to baseclasses, datamembers and methods.

 TClass dtor. Deletes all list that might have been created.

 Register a TClassRef object which points to this TClass object.
 When this TClass object is deleted, 'ref' will be 'Reset'.

 Browse external object inherited from TObject.
 It passes through inheritance tree and calls TBrowser::Add
 in appropriate cases. Static function.

 This method is called by a browser to get the class information.

 Build a full list of persistent data members.
 Scans the list of all data members in the class itself and also
 in all base classes. For each persistent data member, inserts a
 TRealData object in the list fRealData.

 If pointer is not 0, uses the object at pointer
 otherwise creates a temporary object of this class.

 Build the list of real data for an emulated class

 Return true if the data member of this TClass can be saved separately.

 Copy the argument.

 Draw detailed class inheritance structure.
 If a class B inherits from a class A, the description of B is drawn
 on the right side of the description of A.
 Member functions overridden by B are shown in class A with a blue line
 erasing the corresponding member function

 Dump contents of object on stdout.
 Using the information in the object dictionary
 each data member is interpreted.
 If a data member is a pointer, the pointer value is printed
 'obj' is assume to point to an object of the class describe by this TClass

 The following output is the Dump of a TArrow object:
   fAngle                   0           Arrow opening angle (degrees)
   fArrowSize               0.2         Arrow Size
   fOption.*fData
   fX1                      0.1         X of 1st point
   fY1                      0.15        Y of 1st point
   fX2                      0.67        X of 2nd point
   fY2                      0.83        Y of 2nd point
   fUniqueID                0           object unique identifier
   fBits                    50331648    bit field status word
   fLineColor               1           line color
   fLineStyle               1           line style
   fLineWidth               1           line width
   fFillColor               19          fill area color
   fFillStyle               1001        fill area style

 Introduce an escape character (@) in front of a special chars.
 You need to use the result immediately before it is being overwritten.

 Return a pointer the the real class of the object.
 This is equivalent to object->IsA() when the class has a ClassDef.
 It is REQUIRED that object is coming from a proper pointer to the
 class represented by 'this'.
 Example: Special case:
    class MyClass : public AnotherClass, public TObject
 then on return, one must do:
    TObject *obj = (TObject*)((void*)myobject)directory->Get("some object of MyClass");
    MyClass::Class()->GetActualClass(obj); // this would be wrong!!!
 Also if the class represented by 'this' and NONE of its parents classes
 have a virtual ptr table, the result will be 'this' and NOT the actual
 class.

 Return pointer to the base class "classname". Returns 0 in case
 "classname" is not a base class. Takes care of multiple inheritance.

 Return pointer to the base class "cl". Returns 0 in case "cl"
 is not a base class. Takes care of multiple inheritance.

 Return data member offset to the base class "cl".
 Returns -1 in case "cl" is not a base class.
 Takes care of multiple inheritance.

 Return pointer to (base) class that contains datamember.

 Return pointer to class from its name
 See TROOT::GetClass

 Return pointer to class from it type_info
 See TROOT::GetClass

 Return a pointer to the dictionary loading function generated by
 rootcint

 Return a pointer to the dictionary loading function generated by
 rootcint

 Return pointer to datamember object with name "datamember".

 return offset for member name. name can be a data member in
 the class itself, one of its base classes, or one member in
 one of the aggregated classes.

 In case of an emulated class, the list of emulated TRealData is built

 return pointer to TRealData element with name.
 name can be a data member in the class itself,
 one of its base classes, or one member in
 one of the aggregated classes.

 In case of an emulated class, the list of emulated TRealData is built

 Get the list of shared libraries containing the code for class cls.
 The first library in the list is the one containing the class, the
 others are the libraries the first one depends on. Returns 0
 in case the library is not found.

 Return list containing the TBaseClass(es) of a class.

 Return list containing the TDataMembers of a class.

 Return list containing the TMethods of a class.

 Returns a list of all public methods of this class and its base classes.
 Refers to a subset of the methods in GetListOfMethods() so don't do
 GetListOfAllPublicMethods()->Delete().
 Algorithm used to get the list is:
 - put all methods of the class in the list (also protected and private
   ones).
 - loop over all base classes and add only those methods not already in the
   list (also protected and private ones).
 - once finished, loop over resulting list and remove all private and
   protected methods.

 Returns a list of all public data members of this class and its base
 classes. Refers to a subset of the data members in GetListOfDatamembers()
 so don't do GetListOfAllPublicDataMembers()->Delete().

 Returns list of methods accessible by context menu.

 Unregister the TClassRef object.

 Inform the other objects to replace this object by the new TClass (newcl)

 Make sure that the current G__ClassInfo is up to date.

 Resets the menu list to it's standard value.

 Makes a customizable version of the popup menu list, i.e. makes a list
 of TClassMenuItem objects of methods accessible by context menu.
 The standard (and different) way consists in having just one element
 in this list, corresponding to the whole standard list.
 Once the customizable version is done, one can remove or add elements.

 Return pointer to method without looking at parameters.
 Does not look in (possible) base classes.

 Return pointer to method without looking at parameters.
 Does look in all base classes.

 Find the best method (if there is one) matching the parameters.
 The params string must contain argument values, like "3189, \"aap\", 1.3".
 The function invokes GetClassMethod to search for a possible method
 in the class itself or in its base classes. Returns 0 in case method
 is not found.

 Find the method with a given prototype. The proto string must be of the
 form: "char*,int,double". Returns 0 in case method is not found.

 Look for a method in this class that has the interface function
 address faddr.

 Look for a method in this class that has the name and
 signature

 Return the number of data members of this class
 Note that in case the list of data members is not yet created, it will be done
 by GetListOfDataMembers().

 Return the number of methods of this class
 Note that in case the list of methods is not yet created, it will be done
 by GetListOfMethods().

 returns a pointer to the TStreamerInfo object for version
 If the object doest not exist, it is created

  When the class kIgnoreTObjectStreamer bit is set, the automatically
  generated Streamer will not call TObject::Streamer.
  This option saves the TObject space overhead on the file.
  However, the information (fBits, fUniqueID) of TObject is lost.

  Note that this function must be called for the class deriving
  directly from TObject, eg, assuming that BigTrack derives from Track
  and Track derives from TObject, one must do:
     Track::Class()->IgnoreTObjectStreamer();
  and not:
     BigTrack::Class()->IgnoreTObjectStreamer();

 Return kTRUE if this class inherits from a class with name "classname".
 note that the function returns KTRUE in case classname is the class itself

 Return kTRUE if this class inherits from class cl.
 note that the function returns KTRUE in case cl is the class itself

 Cast obj of this class type up to baseclass cl if up is true.
 Cast obj of this class type down from baseclass cl if up is false.
 If this class is not a baseclass of cl return 0, else the pointer
 to the cl part of this (up) or to this (down).

 Return a pointer to a newly allocated object of this class.
 The class must have a default constructor. For meaning of
 defConstructor, see TClass::IsCallingNew().

 The constructor actually called here can be customized by
 using the rootcint pragma:
    #pragma link C++ ioctortype UserClass;
 For example, with this pragma and a class named MyClass,
 this method will called the first of the following 3
 constructors which exists and is public:
    MyClass(UserClass*);
    MyClass(TRootIOCtor*);
    MyClass(); // Or a constructor with all its arguments defaulted.

 When more than one pragma ioctortype is used, the first seen as priority
 For example with:
    #pragma link C++ ioctortype UserClass1;
    #pragma link C++ ioctortype UserClass2;
 We look in the following order:
    MyClass(UserClass1*);
    MyClass(UserClass2*);
    MyClass(TRootIOCtor*);
    MyClass(); // Or a constructor with all its arguments defaulted.

 Return a pointer to a newly allocated object of this class.
 The class must have a default constructor. For meaning of
 defConstructor, see TClass::IsCallingNew().

 Explicitely call destructor for object.

 Return size of object of this class.

 Load class description from I/O buffer and return class object.

 Store class description on I/O buffer.

 Return true if the shared library of this class is currently in the a
 process's memory.  Return false, after the shared library has been
 unloaded or if this is an 'emulated' class created from a file's StreamerInfo.

 Returns true if this class inherits from TObject and if the start of
 the TObject parts is at the very beginning of the objects.
 Concretly this means that the following code is proper for this class:
     ThisClass *ptr;
     void *void_ptr = (void)ptr;
     TObject *obj = (TObject*)void_ptr;
 This code would be wrong if 'ThisClass' did not inherit 'first' from
 TObject.

 Set TObject::fBits and fStreamerType to cache information about the
 class.  The bits are
    kIsTObject : the class inherits from TObject
    kStartWithTObject:  TObject is the left-most class in the inheritance tree
    kIsForeign : the class doe not have a Streamer method
 The value of fStreamerType are
    kTObject : the class inhetis from TObject
    kForeign : the class does not have a Streamer method
    kInstrumented: the class does have a Streamer method
    kExternal: the class has a free standing way of streaming itself
    kEmulated: the class is missing its shared library.

 This function installs a global IsA function for this class.
 The global IsA function will be used if there is no local IsA function (fIsA)

 A global IsA function has the signature:

    TClass *func( TClass *cl, const void *obj);

 'cl' is a pointer to the  TClass object that corresponds to the
 'pointer type' used to retrieve the value 'obj'

  For example with:
    TNamed * m = new TNamed("example","test");
    TObject* o = m
 and
    the global IsA function would be called with TObject::Class() as
    the first parameter and the exact numerical value in the pointer
    'o'.

  In other word, inside the global IsA function. it is safe to C-style
  cast the value of 'obj' into a pointer to the class described by 'cl'.

 Call this method to indicate that the shared library containing this
 class's code has been removed (unloaded) from the process's memory

 Info is a string describing the names and types of attributes
 written by the class Streamer function.
 If info is an empty string (when called by TObject::StreamerInfo)
 the default Streamer info string is build. This corresponds to
 the case of an automatically generated Streamer.
 In case of user defined Streamer function, it is the user responsability
 to implement a StreamerInfo function (override TObject::StreamerInfo).
 The user must call IsA()->SetStreamerInfo(info) from this function.

 Compute and/or return the class check sum.
 The class ckecksum is used by the automatic schema evolution algorithm
 to uniquely identify a class version.
 The check sum is built from the names/types of base classes and
 data members.
 Algorithm from Victor Perevovchikov (perev@bnl.gov).

 if code==1 data members of type enum are not counted in the checksum

 Adopt the TMemberStreamer pointer to by p and use it to Stream non basic
 member name.

 Function called by the Streamer functions to deserialize information
 from buffer b into object at p.
 This function assumes that the class version and the byte count information
 have been read.
   version  is the version number of the class
   start    is the starting position in the buffer b
   count    is the number of bytes for this object in the buffer

 Function called by the Streamer functions to deserialize information
 from buffer b into object at p.

 Function called by the Streamer functions to serialize object at p
 to buffer b. The optional argument info may be specified to give an
 alternative StreamerInfo instead of using the default StreamerInfo
 automatically built from the class definition.
 For more information, see class TStreamerInfo.

 Stream the object.

 Adopt a TClassStreamer object.  Ownership is transfered to this TClass
 object.

 Return true if we have access to a default constructor.

Inline Functions

           TStreamerInfo* GetCurrentStreamerInfo()
                     void SetClassVersion(Version_t version)
                     void SetClassSize(Int_t sizof)
                     void AddInstance(Bool_t heap = kFALSE)
                   Bool_t CanIgnoreTObjectStreamer()
                     void Dump(void* obj) const
                Version_t GetClassVersion() const
              const char* GetDeclFileName() const
                  Short_t GetDeclFileLine() const
            G__ClassInfo* GetClassInfo() const
                   TList* GetListOfRealData() const
              const char* GetImplFileName() const
                  Short_t GetImplFileLine() const
                   UInt_t GetInstanceCount() const
                   UInt_t GetHeapInstanceCount() const
                   TList* GetMenuList() const
                   TList* GetEditorList() const
        ShowMembersFunc_t GetShowMembersWrapper() const
          TClassStreamer* GetStreamer() const
               TObjArray* GetStreamerInfos() const
         const type_info* GetTypeInfo() const
                     void ResetInstanceCount()
         TClass::ENewType IsCallingNew()
                   Bool_t IsFolder(void* obj) const
                  TClass* Class()
                  TClass* IsA() const
                     void ShowMembers(TMemberInspector& insp, char* parent)
                     void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
                   TClass TClass(const TClass&)