Logo ROOT  
Reference Guide
TClass.h
Go to the documentation of this file.
1 // @(#)root/meta:$Id$
2 // Author: Rene Brun 07/01/95
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TClass
13 #define ROOT_TClass
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // TClass //
18 // //
19 // Dictionary of a class. //
20 // //
21 //////////////////////////////////////////////////////////////////////////
22 
23 #include "TDictionary.h"
24 #include "TString.h"
25 
26 #ifdef R__LESS_INCLUDES
27 class TObjArray;
28 #else
29 #include "TObjArray.h"
30 // Not used in this header file; user code should #include this directly.
31 // #include "TObjString.h"
32 // #include "ThreadLocalStorage.h"
33 // #include <set>
34 #endif
35 
36 #include <map>
37 #include <string>
38 #include <unordered_set>
39 #include <vector>
40 #include <atomic>
41 
42 class TBaseClass;
43 class TBrowser;
44 class TDataMember;
45 class TCling;
46 class TMethod;
47 class TRealData;
48 class TBuffer;
51 class TMethodCall;
52 class TVirtualIsAProxy;
53 class TVirtualRefProxy;
54 class THashTable;
55 class TListOfFunctions;
57 class TListOfDataMembers;
58 class TListOfEnums;
59 class TViewPubFunctions;
61 class TFunctionTemplate;
62 class TProtoClass;
63 
64 namespace ROOT {
65  class TGenericClassInfo;
66  class TMapTypeToTClass;
67  class TMapDeclIdToTClass;
68  namespace Detail {
69  class TSchemaRuleSet;
70  class TCollectionProxyInfo;
71  }
72  namespace Internal {
73  class TCheckHashRecursiveRemoveConsistency;
74  }
75 }
76 
77 typedef ROOT::TMapTypeToTClass IdMap_t;
78 typedef ROOT::TMapDeclIdToTClass DeclIdMap_t;
79 
80 class TClass : public TDictionary {
81 
82 friend class TCling;
83 friend void ROOT::ResetClassVersion(TClass*, const char*, Short_t);
85 friend class TProtoClass;
87 friend class TStreamerInfo;
88 
89 public:
90  // TClass status bits
91  enum EStatusBits {
92  kReservedLoading = BIT(7), // Internal status bits, set and reset only during initialization
93 
97  kUnloaded = BIT(16), // The library containing the dictionary for this class was
98  // loaded and has been unloaded from memory.
99  kIsTObject = BIT(17),
101  kIsEmulation = BIT(19), // Deprecated
102  kStartWithTObject = BIT(20), // see comments for IsStartingWithTObject()
103  kWarned = BIT(21),
105  kHasCustomStreamerMember = BIT(23) // The class has a Streamer method and it is implemented by the user or an older (not StreamerInfo based) automatic streamer.
106  };
108  enum ECheckSum {
110  kNoEnum = 1, // Used since v3.3
111  kReflexNoComment = 2, // Up to v5.34.18 (has no range/comment and no typedef at all)
112  kNoRange = 3, // Up to v5.17
113  kWithTypeDef = 4, // Up to v5.34.18 and v5.99/06
114  kReflex = 5, // Up to v5.34.18 (has no typedef at all)
115  kNoRangeCheck = 6, // Up to v5.34.18 and v5.99/06
116  kNoBaseCheckSum = 7, // Up to v5.34.18 and v5.99/06
117  kLatestCheckSum = 8
118  };
119 
120  // Describe the current state of the TClass itself.
121  enum EState {
122  kNoInfo, // The state has not yet been initialized, i.e. the TClass
123  // was just created and/or there is no trace of it in the interpreter.
124  kForwardDeclared, // The interpreted knows the entity is a class but that's it.
125  kEmulated, // The information about the class only comes from a TStreamerInfo
126  kInterpreted, // The class is described completely/only in the interpreter database.
127  kHasTClassInit, // The class has a TClass proper bootstrap coming from a run
128  // through rootcling/genreflex/TMetaUtils and the library
129  // containing this dictionary has been loaded in memory.
131  kNamespaceForMeta // Very transient state necessary to bootstrap namespace entries
132  // in ROOT Meta w/o interpreter information
133  };
134 
135  // "Typed" pointer that recalls how TClass::New allocated the object.
136  // It is returned by TClass:NewObject and should be passed to TClass::DeleteArray or TClass::Destructor
137  // to delete the object.
138  // It is also used in TVirtualCollectionProxy for the same reasons.
139  struct ObjectPtr
140  {
141  void *fPtr = nullptr;
142 
144 
145  ObjectPtr(void *ptr = nullptr, TVirtualStreamerInfo *allocator = nullptr) : fPtr(ptr), fAllocator(allocator) {}
146 
147  void *GetPtr() const { return fPtr; }
148 
150 
151  operator bool() const { return fPtr != nullptr; }
152  };
153 
154 private:
155 
156 
157 
159  // A class which is used to collect decl names starting from normalised
160  // names (typedef resolution is excluded here, just string manipulation
161  // is performed). At the heart of the implementation, an unordered set.
162  public:
163  TDeclNameRegistry(Int_t verbLevel=0);
164  void AddQualifiedName(const char *name);
165  Bool_t HasDeclName(const char *name) const;
167  private:
169  std::unordered_set<std::string> fClassNamesSet;
170  mutable std::atomic_flag fSpinLock; // MSVC doesn't support = ATOMIC_FLAG_INIT;
171  };
172 
174  // Trivial RAII used to insert names in the registry
176  const char* fName;
178  public:
179  InsertTClassInRegistryRAII(TClass::EState &state, const char *name, TDeclNameRegistry &emuRegistry);
181  };
182 
183  // TClass objects can be created as a result of opening a TFile (in which
184  // they are in emulated mode) or as a result of loading the dictionary for
185  // the corresponding class. When a dictionary is loaded any pre-existing
186  // emulated TClass is replaced by the one created/coming from the dictionary.
187  // To have a reference that always point to the 'current' TClass object for
188  // a given class, one should use a TClassRef.
189  // TClassRef works by holding on to the fPersistentRef which is updated
190  // atomically whenever a TClass is replaced. During the replacement the
191  // value of fPersistentRef is set to zero, leading the TClassRef to call
192  // TClass::GetClass which is also locked by the replacement. At the end
193  // of the replacement, fPersistentRef points to the new TClass object.
194  std::atomic<TClass**> fPersistentRef;//!Persistent address of pointer to this TClass object and its successors.
195 
196  typedef std::atomic<std::map<std::string, TObjArray*>*> ConvSIMap_t;
197 
198  mutable TObjArray *fStreamerInfo; //Array of TVirtualStreamerInfo
199  mutable ConvSIMap_t fConversionStreamerInfo; //Array of the streamer infos derived from another class.
200  TList *fRealData; //linked list for persistent members including base classes
201  std::atomic<TList*> fBase; //linked list for base classes
202  std::atomic<TListOfDataMembers*> fData; //linked list for data members; non-owning.
203  std::atomic<TListOfDataMembers*> fUsingData;//linked list for data members pulled in through using decls.
204 
205  std::atomic<TListOfEnums*> fEnums; //linked list for the enums
206  TListOfFunctionTemplates *fFuncTemplate; //linked list for function templates [Not public until implemented as active list]
207  std::atomic<TListOfFunctions*> fMethod; //linked list for methods
208 
209  TViewPubDataMembers*fAllPubData; //all public data members (including from base classes)
210  TViewPubFunctions *fAllPubMethod; //all public methods (including from base classes)
211  mutable TList *fClassMenuList; //list of class menu items
212 
213  const char *fDeclFileName; //name of class declaration file
214  const char *fImplFileName; //name of class implementation file
215  Short_t fDeclFileLine; //line of class declaration
216  Short_t fImplFileLine; //line of class implementation
217  UInt_t fInstanceCount; //number of instances of this class
218  UInt_t fOnHeap; //number of instances on heap
219  mutable std::atomic<UInt_t> fCheckSum; //checksum of data members and base classes
220  TVirtualCollectionProxy *fCollectionProxy; //Collection interface
221  Version_t fClassVersion; //Class version Identifier
222  ClassInfo_t *fClassInfo; //pointer to CINT class info class
223  TString fContextMenuTitle;//context menu title
224  const std::type_info *fTypeInfo; //pointer to the C++ type information.
225  ShowMembersFunc_t fShowMembers; //pointer to the class's ShowMembers function
226  TClassStreamer *fStreamer; //pointer to streamer function
227  TString fSharedLibs; //shared libraries containing class code
228 
229  TVirtualIsAProxy *fIsA; //!pointer to the class's IsA proxy.
230  IsAGlobalFunc_t fGlobalIsA; //pointer to a global IsA function.
231  mutable std::atomic<TMethodCall*> fIsAMethod; //!saved info to call a IsA member function
232 
233  ROOT::MergeFunc_t fMerge; //pointer to a function implementing Merging objects of this class.
234  ROOT::ResetAfterMergeFunc_t fResetAfterMerge; //pointer to a function implementing Merging objects of this class.
235  ROOT::NewFunc_t fNew; //pointer to a function newing one object.
236  ROOT::NewArrFunc_t fNewArray; //pointer to a function newing an array of objects.
237  ROOT::DelFunc_t fDelete; //pointer to a function deleting one object.
238  ROOT::DelArrFunc_t fDeleteArray; //pointer to a function deleting an array of objects.
239  ROOT::DesFunc_t fDestructor; //pointer to a function call an object's destructor.
240  ROOT::DirAutoAdd_t fDirAutoAdd; //pointer which implements the Directory Auto Add feature for this class.']'
241  ClassStreamerFunc_t fStreamerFunc; //Wrapper around this class custom Streamer member function.
242  ClassConvStreamerFunc_t fConvStreamerFunc; //Wrapper around this class custom conversion Streamer member function.
243  Int_t fSizeof; //Sizeof the class.
244 
245  // Bit field
246  Int_t fCanSplit : 3; //!Indicates whether this class can be split or not. Values are -1, 0, 1, 2
247 
248  /// Indicates whether this class represents a pair and was not created from a dictionary nor interpreter info but has
249  /// compiler compatible offset and size (and all the info is in the StreamerInfo per se)
251 
252  mutable std::atomic<Long_t> fProperty; //!Property See TClass::Property() for details
253  mutable Long_t fClassProperty; //!C++ Property of the class (is abstract, has virtual table, etc.)
254 
255  // fHasRootPcmInfo needs to be atomic as long as GetListOfBases needs to modify it.
256  std::atomic<Bool_t> fHasRootPcmInfo; //!Whether info was loaded from a root pcm.
257  mutable std::atomic<Bool_t> fCanLoadClassInfo; //!Indicates whether the ClassInfo is supposed to be available.
258  mutable std::atomic<Bool_t> fIsOffsetStreamerSet; //!saved remember if fOffsetStreamer has been set.
259  mutable std::atomic<Bool_t> fVersionUsed; //!Indicates whether GetClassVersion has been called
260 
262  kNotInitialized = 0,
263  kSet = BIT(0),
264  // kInconsistent when kSet & !kConsistent.
265  kConsistentHash = BIT(1)
266  };
268  return l & static_cast<UChar_t>(r);
269  }
270  mutable std::atomic<UChar_t> fRuntimeProperties; //! Properties that can only be evaluated at run-time
271 
272  mutable Long_t fOffsetStreamer; //!saved info to call Streamer
273  Int_t fStreamerType; //!cached of the streaming method to use
274  EState fState; //!Current 'state' of the class (Emulated,Interpreted,Loaded)
275  mutable std::atomic<TVirtualStreamerInfo*> fCurrentInfo; //!cached current streamer info.
276  mutable std::atomic<TVirtualStreamerInfo*> fLastReadInfo; //!cached streamer info used in the last read.
277  TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if this class represents a reference
278  ROOT::Detail::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules
279 
280  typedef void (*StreamerImpl_t)(const TClass* pThis, void *obj, TBuffer &b, const TClass *onfile_class);
281 #ifdef R__NO_ATOMIC_FUNCTION_POINTER
282  mutable StreamerImpl_t fStreamerImpl; //! Pointer to the function implementing streaming for this class
283 #else
284  mutable std::atomic<StreamerImpl_t> fStreamerImpl; //! Pointer to the function implementing streaming for this class
285 #endif
286 
289  TMethod *GetClassMethod(Long_t faddr);
291  Int_t GetBaseClassOffsetRecurse(const TClass *toBase);
292  void Init(const char *name, Version_t cversion, const std::type_info *info,
293  TVirtualIsAProxy *isa,
294  const char *dfil, const char *ifil,
295  Int_t dl, Int_t il,
296  ClassInfo_t *classInfo,
297  Bool_t silent);
298  void ForceReload (TClass* oldcl);
299  void LoadClassInfo() const;
300 
301  static TClass *LoadClassDefault(const char *requestedname, Bool_t silent);
302  static TClass *LoadClassCustom(const char *requestedname, Bool_t silent);
303 
304  void SetClassVersion(Version_t version);
305  void SetClassSize(Int_t sizof) { fSizeof = sizof; }
307 
308  void SetStreamerImpl();
309 
310  void SetRuntimeProperties();
311 
312  // Various implementation for TClass::Stramer
313  static void StreamerExternal(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
314  static void StreamerTObject(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
315  static void StreamerTObjectInitialized(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
316  static void StreamerTObjectEmulated(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
317  static void StreamerInstrumented(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
318  static void ConvStreamerInstrumented(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
319  static void StreamerStreamerInfo(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
320  static void StreamerDefault(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class);
321 
322  static IdMap_t *GetIdMap(); //Map from typeid to TClass pointer
323  static DeclIdMap_t *GetDeclIdMap(); //Map from DeclId_t to TClass pointer
324  static std::atomic<Int_t> fgClassCount; //provides unique id for a each class
325  //stored in TObject::fUniqueID
326  static TDeclNameRegistry fNoInfoOrEmuOrFwdDeclNameRegistry; // Store decl names of the forwardd and no info instances
327  static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char*);
328 
329  // Internal status bits, set and reset only during initialization and thus under the protection of the global lock.
331  // Internal streamer type.
333 
334  // These are the above-referenced hash tables. (The pointers are null
335  // if no entries have been made.)
337 
338  TVirtualStreamerInfo *GetStreamerInfoImpl(Int_t version, Bool_t silent) const;
339 
340  mutable TVirtualMutex *fOVRMutex = nullptr;
341  typedef std::multimap<void*, Version_t> RepoCont_t;
343 
344  void UnregisterAddressInRepository(const char *where, void *location, const TClass *what) const;
345  void MoveAddressInRepository(const char *where, void *oldadd, void *newadd, const TClass *what) const;
346  void RegisterAddressInRepository(const char *where, void *location, const TClass *what) const;
347 
348 private:
349  TClass(const TClass& tc) = delete;
350  TClass& operator=(const TClass&) = delete;
351 
352  bool IsClassStructOrUnion() const { return Property() & (kIsClass|kIsStruct|kIsUnion); }
353  TList *CreateListOfDataMembers(std::atomic<TListOfDataMembers*> &data, TDictionary::EMemberSelection selection, bool load);
354 
355 protected:
356  TVirtualStreamerInfo *FindStreamerInfo(TObjArray *arr, UInt_t checksum) const;
357  void GetMissingDictionariesForBaseClasses(TCollection &result, TCollection &visited, bool recurse);
358  void GetMissingDictionariesForMembers(TCollection &result, TCollection &visited, bool recurse);
359  void GetMissingDictionariesWithRecursionCheck(TCollection &result, TCollection &visited, bool recurse);
360  void GetMissingDictionariesForPairElements(TCollection &result, TCollection &visited, bool recurse);
361 
362 public:
363  TClass();
364  TClass(const char *name, Bool_t silent = kFALSE);
365  TClass(const char *name, Version_t cversion, Bool_t silent = kFALSE);
366  TClass(const char *name, Version_t cversion, EState theState, Bool_t silent = kFALSE);
367  TClass(ClassInfo_t *info, Version_t cversion,
368  const char *dfil, const char *ifil = 0,
369  Int_t dl = 0, Int_t il = 0, Bool_t silent = kFALSE);
370  TClass(const char *name, Version_t cversion,
371  const char *dfil, const char *ifil = 0,
372  Int_t dl = 0, Int_t il = 0, Bool_t silent = kFALSE);
373  TClass(const char *name, Version_t cversion,
374  const std::type_info &info, TVirtualIsAProxy *isa,
375  const char *dfil, const char *ifil,
376  Int_t dl, Int_t il, Bool_t silent = kFALSE);
377  virtual ~TClass();
378 
379  void AddInstance(Bool_t heap = kFALSE) { fInstanceCount++; if (heap) fOnHeap++; }
380  void AddImplFile(const char *filename, int line);
381  static Bool_t AddRule(const char *rule);
382  static Int_t ReadRules(const char *filename);
383  static Int_t ReadRules();
385  virtual void Browse(TBrowser *b);
386  void BuildRealData(void *pointer=0, Bool_t isTransient = kFALSE);
387  void BuildEmulatedRealData(const char *name, Long_t offset, TClass *cl, Bool_t isTransient = kFALSE);
388  void CalculateStreamerOffset() const;
389  Bool_t CallShowMembers(const void* obj, TMemberInspector &insp, Bool_t isTransient = kFALSE) const;
390  Bool_t CanSplit() const;
392  Long_t ClassProperty() const;
393  TObject *Clone(const char *newname="") const;
395  void Draw(Option_t *option="");
396  void Dump() const { TDictionary::Dump(); }
397  void Dump(const void *obj, Bool_t noAddr = kFALSE) const;
398  char *EscapeChars(const char *text) const;
399  TVirtualStreamerInfo *FindStreamerInfo(UInt_t checksum, Bool_t isTransient = kFALSE) const;
400  TVirtualStreamerInfo *GetConversionStreamerInfo( const char* onfile_classname, Int_t version ) const;
401  TVirtualStreamerInfo *FindConversionStreamerInfo( const char* onfile_classname, UInt_t checksum ) const;
402  TVirtualStreamerInfo *GetConversionStreamerInfo( const TClass* onfile_cl, Int_t version ) const;
403  TVirtualStreamerInfo *FindConversionStreamerInfo( const TClass* onfile_cl, UInt_t checksum ) const;
405  Bool_t HasDefaultConstructor(Bool_t testio = kFALSE) const;
409  UInt_t GetCheckSum(Bool_t &isvalid) const;
410  UInt_t GetCheckSum(ECheckSum code, Bool_t &isvalid) const;
412  TVirtualIsAProxy *GetIsAProxy() const;
413  TMethod *GetClassMethod(const char *name, const char *params, Bool_t objectIsConst = kFALSE);
414  TMethod *GetClassMethodWithPrototype(const char *name, const char *proto,
415  Bool_t objectIsConst = kFALSE,
418  if (!fVersionUsed.load(std::memory_order_relaxed))
420  return fClassVersion;
421  }
422  Int_t GetClassSize() const { return Size(); }
423  TDataMember *GetDataMember(const char *datamember) const;
424  Long_t GetDataMemberOffset(const char *membername) const;
425  const char *GetDeclFileName() const;
427  ROOT::DelFunc_t GetDelete() const;
430  ClassInfo_t *GetClassInfo() const {
432  LoadClassInfo();
433  return fClassInfo;
434  }
435  const char *GetContextMenuTitle() const { return fContextMenuTitle; }
437  auto current = fCurrentInfo.load(std::memory_order_relaxed);
438  if (current) return current;
439  else return DetermineCurrentStreamerInfo();
440  }
445  TList *GetListOfEnums(Bool_t load = kTRUE);
449  TCollection *GetListOfMethodOverloads(const char* name) const;
450  TList *GetListOfRealData() const { return fRealData; }
453  const char *GetImplFileName() const { return fImplFileName; }
455  TClass *GetActualClass(const void *object) const;
456  TClass *GetBaseClass(const char *classname);
457  TClass *GetBaseClass(const TClass *base);
458  Int_t GetBaseClassOffset(const TClass *toBase, void *address = 0, bool isDerivedObject = true);
459  TClass *GetBaseDataMember(const char *datamember);
464  UInt_t GetHeapInstanceCount() const { return fOnHeap; }
465  void GetMenuItems(TList *listitems);
466  TList *GetMenuList() const;
467  TMethod *GetMethod(const char *method, const char *params, Bool_t objectIsConst = kFALSE);
468  TMethod *GetMethodWithPrototype(const char *method, const char *proto, Bool_t objectIsConst = kFALSE,
470  TMethod *GetMethodAny(const char *method);
471  TMethod *GetMethodAllAny(const char *method);
472  Int_t GetNdata();
473  ROOT::MergeFunc_t GetMerge() const;
475  ROOT::NewFunc_t GetNew() const;
477  Int_t GetNmethods();
478  TClass *const*GetPersistentRef() const { return fPersistentRef; }
479  TRealData *GetRealData(const char *name) const;
483  const char *GetSharedLibs();
485  EState GetState() const { return fState; }
486  TClassStreamer *GetStreamer() const;
489  const TObjArray *GetStreamerInfos() const { return fStreamerInfo; }
490  TVirtualStreamerInfo *GetStreamerInfo(Int_t version=0, Bool_t isTransient = kFALSE) const;
493  const std::type_info *GetTypeInfo() const { return fTypeInfo; };
494 
495  /// @brief Return 'true' if we can guarantee that if this class (or any class in
496  /// this class inheritance hierarchy) overload TObject::Hash it also starts
497  /// the RecursiveRemove process from its own destructor.
499  {
500  if (!fRuntimeProperties)
503  }
504  Bool_t HasDictionary() const;
505  static Bool_t HasDictionarySelection(const char* clname);
506  Bool_t HasLocalHashMember() const;
507  void GetMissingDictionaries(THashTable& result, bool recurse = false);
508  void IgnoreTObjectStreamer(Bool_t ignore=kTRUE);
509  Bool_t InheritsFrom(const char *cl) const;
510  Bool_t InheritsFrom(const TClass *cl) const;
511  void InterpretedShowMembers(void* obj, TMemberInspector &insp, Bool_t isTransient);
512  Bool_t IsFolder() const { return kTRUE; }
513  Bool_t IsLoaded() const;
514  Bool_t IsForeign() const;
517  Bool_t IsVersioned() const { return !( GetClassVersion()<=1 && IsForeign() ); }
518  Bool_t IsTObject() const;
519  static TClass *LoadClass(const char *requestedname, Bool_t silent);
520  void ls(Option_t *opt="") const;
521  void MakeCustomMenuList();
522  Bool_t MatchLegacyCheckSum(UInt_t checksum) const;
523  void Move(void *arenaFrom, void *arenaTo) const;
524  void *New(ENewType defConstructor = kClassNew, Bool_t quiet = kFALSE) const;
525  void *New(void *arena, ENewType defConstructor = kClassNew) const;
526  void *NewArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
527  void *NewArray(Long_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
528  ObjectPtr NewObject(ENewType defConstructor = kClassNew, Bool_t quiet = kFALSE) const;
529  ObjectPtr NewObject(void *arena, ENewType defConstructor = kClassNew) const;
530  ObjectPtr NewObjectArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
531  ObjectPtr NewObjectArray(Long_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
532  virtual void PostLoadCheck();
533  Long_t Property() const;
534  Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count);
535  Int_t ReadBuffer(TBuffer &b, void *pointer);
537  void RemoveStreamerInfo(Int_t slot);
538  void ReplaceWith(TClass *newcl) const;
539  void ResetCaches();
540  void ResetClassInfo(Long_t tagnum);
541  void ResetClassInfo();
543  void ResetMenuList();
544  Int_t Size() const;
545  void SetCanSplit(Int_t splitmode);
547  void SetContextMenuTitle(const char *title);
550  void SetDeclFile(const char *name, int line) { fDeclFileName = name; fDeclFileLine = line; }
551  void SetDelete(ROOT::DelFunc_t deleteFunc);
552  void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc);
553  void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc);
554  void SetDestructor(ROOT::DesFunc_t destructorFunc);
555  void SetImplFileName(const char *implFileName) { fImplFileName = implFileName; }
556  void SetMerge(ROOT::MergeFunc_t mergeFunc);
558  void SetNew(ROOT::NewFunc_t newFunc);
559  void SetNewArray(ROOT::NewArrFunc_t newArrayFunc);
560  TVirtualStreamerInfo *SetStreamerInfo(Int_t version, const char *info="");
561  void SetUnloaded();
562  Int_t WriteBuffer(TBuffer &b, void *pointer, const char *info="");
563 
565  void AdoptStreamer(TClassStreamer *strm);
566  void AdoptMemberStreamer(const char *name, TMemberStreamer *strm);
567  void SetMemberStreamer(const char *name, MemberStreamerFunc_t strm);
570 
571  // Function to retrieve the TClass object and dictionary function
572  static void AddClass(TClass *cl);
573  static void AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass* cl);
574  static void RemoveClass(TClass *cl);
576  static TClass *GetClass(const char *name, Bool_t load = kTRUE, Bool_t silent = kFALSE);
577  static TClass *GetClass(const char *name, Bool_t load, Bool_t silent, size_t hint_pair_offset, size_t hint_pair_size);
578  static TClass *GetClass(const std::type_info &typeinfo, Bool_t load = kTRUE, Bool_t silent = kFALSE, size_t hint_pair_offset = 0, size_t hint_pair_size = 0);
579  static TClass *GetClass(ClassInfo_t *info, Bool_t load = kTRUE, Bool_t silent = kFALSE);
580  template<typename T>
581  static TClass *GetClass(Bool_t load = kTRUE, Bool_t silent = kFALSE);
582  static Bool_t GetClass(DeclId_t id, std::vector<TClass*> &classes);
583  static DictFuncPtr_t GetDict (const char *cname);
584  static DictFuncPtr_t GetDict (const std::type_info &info);
585 
586  static Int_t AutoBrowse(TObject *obj, TBrowser *browser);
587  static ENewType IsCallingNew();
588  static TClass *Load(TBuffer &b);
589  void Store(TBuffer &b) const;
590 
591  // Pseudo-method apply to the 'obj'. In particular those are used to
592  // implement TObject like methods for non-TObject classes.
593  Int_t Browse(void *obj, TBrowser *b) const;
594  void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);
595  void DeleteArray(ObjectPtr ary, Bool_t dtorOnly = kFALSE);
596  void Destructor(void *obj, Bool_t dtorOnly = kFALSE);
597  void Destructor(ObjectPtr obj, Bool_t dtorOnly = kFALSE);
598  void *DynamicCast(const TClass *base, void *obj, Bool_t up = kTRUE);
599  const void *DynamicCast(const TClass *base, const void *obj, Bool_t up = kTRUE);
600  Bool_t IsFolder(void *obj) const;
601 
602  inline void Streamer(void *obj, TBuffer &b, const TClass *onfile_class = 0) const
603  {
604  // Inline for performance, skipping one function call.
605 #ifdef R__NO_ATOMIC_FUNCTION_POINTER
606  fStreamerImpl(this,obj,b,onfile_class);
607 #else
608  auto t = fStreamerImpl.load();
609  t(this,obj,b,onfile_class);
610 #endif
611  }
612 
613  ClassDef(TClass,0) //Dictionary containing class information
614 };
615 
616 namespace ROOT {
617 namespace Internal {
618 template <typename T>
619 TClass *GetClassHelper(Bool_t, Bool_t, std::true_type)
620 {
621  return T::Class();
622 }
623 
624 template <typename T>
626  static TClass *GetClass(Bool_t load, Bool_t silent) {
627  return TClass::GetClass(typeid(T), load, silent);
628  }
629 };
630 
631 template <typename F, typename S>
632 struct TClassGetClassHelper<std::pair<F, S> > {
633  static TClass *GetClass(Bool_t load, Bool_t silent) {
634  std::pair<F, S> *p = nullptr;
635  size_t hint_offset = ((char*)&(p->second)) - (char*)p;
636  return TClass::GetClass(typeid(std::pair<F, S>), load, silent, hint_offset, sizeof(std::pair<F,S>));
637  }
638 };
639 
640 template <typename T>
641 TClass *GetClassHelper(Bool_t load, Bool_t silent, std::false_type)
642 {
643  return TClassGetClassHelper<T>::GetClass(load, silent);
644 }
645 
646 } // namespace Internal
647 } // namespace ROOT
648 
649 template <typename T>
651 {
653  return ROOT::Internal::GetClassHelper<T>(load, silent, tag);
654 }
655 
656 namespace ROOT {
657 
658 template <typename T> TClass *GetClass(T * /* dummy */) { return TClass::GetClass<T>(); }
659 template <typename T> TClass *GetClass(const T * /* dummy */) { return TClass::GetClass<T>(); }
660 
661 #ifndef R__NO_CLASS_TEMPLATE_SPECIALIZATION
662  // This can only be used when the template overload resolution can distinguish between T* and T**
663  template <typename T> TClass* GetClass( T** /* dummy */) { return TClass::GetClass<T>(); }
664  template <typename T> TClass* GetClass(const T** /* dummy */) { return TClass::GetClass<T>(); }
665  template <typename T> TClass* GetClass( T* const* /* dummy */) { return TClass::GetClass<T>(); }
666  template <typename T> TClass* GetClass(const T* const* /* dummy */) { return TClass::GetClass<T>(); }
667 #endif
668 
669  extern TClass *CreateClass(const char *cname, Version_t id,
670  const char *dfil, const char *ifil,
671  Int_t dl, Int_t il);
672 }
673 
674 #endif // ROOT_TClass
l
auto * l
Definition: textangle.C:4
TClass::fAllPubData
TViewPubDataMembers * fAllPubData
Definition: TClass.h:209
TClass::fClassVersion
Version_t fClassVersion
Definition: TClass.h:221
TClass::GetNewArray
ROOT::NewArrFunc_t GetNewArray() const
Return the wrapper around new ThisClass[].
Definition: TClass.cxx:7391
TClass::StreamerInstrumented
static void StreamerInstrumented(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of instrumented class with a library.
Definition: TClass.cxx:6776
TClass::fRefProxy
TVirtualRefProxy * fRefProxy
cached streamer info used in the last read.
Definition: TClass.h:277
MemberStreamerFunc_t
void(* MemberStreamerFunc_t)(TBuffer &, void *, Int_t)
Definition: Rtypes.h:74
TClass::GetMissingDictionariesForPairElements
void GetMissingDictionariesForPairElements(TCollection &result, TCollection &visited, bool recurse)
Definition: TClass.cxx:3957
ROOT::DesFunc_t
void(* DesFunc_t)(void *)
Definition: Rtypes.h:112
TMemberInspector
Abstract base class for accessing the data-members of a class.
Definition: TMemberInspector.h:31
TClass::Browse
virtual void Browse(TBrowser *b)
This method is called by a browser to get the class information.
Definition: TClass.cxx:1988
TClass::EStreamerType
EStreamerType
Definition: TClass.h:332
TClass::kClassSaved
@ kClassSaved
Definition: TClass.h:94
TListOfFunctions
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
Definition: TListOfFunctions.h:35
TClass::StreamerImpl_t
void(* StreamerImpl_t)(const TClass *pThis, void *obj, TBuffer &b, const TClass *onfile_class)
Schema evolution rules.
Definition: TClass.h:280
TClass::GetBaseDataMember
TClass * GetBaseDataMember(const char *datamember)
Return pointer to (base) class that contains datamember.
Definition: TClass.cxx:2805
TClass::kIsEmulation
@ kIsEmulation
Definition: TClass.h:101
ROOT::Detail::TCollectionProxyInfo
Definition: TCollectionProxyInfo.h:53
TClass::GetCollectionProxy
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition: TClass.cxx:2875
TBrowser
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
TClass::kDefault
@ kDefault
Definition: TClass.h:332
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TClass::GetMethodAny
TMethod * GetMethodAny(const char *method)
Return pointer to method without looking at parameters.
Definition: TClass.cxx:4358
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TClass::GetHeapInstanceCount
UInt_t GetHeapInstanceCount() const
Definition: TClass.h:464
TClass::StreamerTObject
static void StreamerTObject(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects.
Definition: TClass.cxx:6740
TListOfFunctionTemplates
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
Definition: TListOfFunctionTemplates.h:35
TClass::GetListOfAllPublicMethods
const TList * GetListOfAllPublicMethods(Bool_t load=kTRUE)
Returns a list of all public methods of this class and its base classes.
Definition: TClass.cxx:3829
TClass::fConvStreamerFunc
ClassConvStreamerFunc_t fConvStreamerFunc
Definition: TClass.h:242
Version_t
short Version_t
Definition: RtypesCore.h:65
TClass::kLatestCheckSum
@ kLatestCheckSum
Definition: TClass.h:117
TClass::GetMethodAllAny
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition: TClass.cxx:4368
TClass::Streamer
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=0) const
Definition: TClass.h:602
TClass::UnregisterAddressInRepository
void UnregisterAddressInRepository(const char *where, void *location, const TClass *what) const
Definition: TClass.cxx:318
TObjArray
An array of TObjects.
Definition: TObjArray.h:37
TClass::fOnHeap
UInt_t fOnHeap
Definition: TClass.h:218
TClass::kNoEnum
@ kNoEnum
Definition: TClass.h:110
TClass::kNamespaceForMeta
@ kNamespaceForMeta
Definition: TClass.h:131
kIsClass
@ kIsClass
Definition: TDictionary.h:65
TClass::NewObjectArray
ObjectPtr NewObjectArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
Definition: TClass.cxx:5193
ROOT::ResetAfterMergeFunc_t
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:115
TClass::SetDirectoryAutoAdd
void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc)
Install a new wrapper around the directory auto add function.
Definition: TClass.cxx:6968
Option_t
const char Option_t
Definition: RtypesCore.h:66
TClass::RemoveClass
static void RemoveClass(TClass *cl)
static: Remove a class from the list and map of classes
Definition: TClass.cxx:520
TClass::GetListOfAllPublicDataMembers
TList * GetListOfAllPublicDataMembers(Bool_t load=kTRUE)
Returns a list of all public data members of this class and its base classes.
Definition: TClass.cxx:3846
TClass::ObjectPtr
Definition: TClass.h:140
TClass::GetInstanceCount
UInt_t GetInstanceCount() const
Definition: TClass.h:463
IsAGlobalFunc_t
TClass *(* IsAGlobalFunc_t)(const TClass *, const void *obj)
Definition: Rtypes.h:96
ROOT::kConversionMatch
@ kConversionMatch
Definition: TDictionary.h:162
TClass::Size
Int_t Size() const
Return size of object of this class.
Definition: TClass.cxx:5688
TClass::StreamerTObjectEmulated
static void StreamerTObjectEmulated(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects when we do not have the library defining the class.
Definition: TClass.cxx:6763
TClass::GetRealData
TRealData * GetRealData(const char *name) const
Return pointer to TRealData element with name "name".
Definition: TClass.cxx:3447
TClass::MakeCustomMenuList
void MakeCustomMenuList()
Makes a customizable version of the popup menu list, i.e.
Definition: TClass.cxx:4267
TClass::GetActualClass
TClass * GetActualClass(const void *object) const
Return a pointer the the real class of the object.
Definition: TClass.cxx:2586
TClass::kReflex
@ kReflex
Definition: TClass.h:114
TClass::SetDestructor
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition: TClass.cxx:6957
TClass::FindStreamerInfoAbstractEmulated
TVirtualStreamerInfo * FindStreamerInfoAbstractEmulated(UInt_t checksum) const
For the case where the requestor class is emulated and this class is abstract, returns a pointer to t...
Definition: TClass.cxx:4756
ROOT::DelFunc_t
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
TClass::fCollectionProxy
TVirtualCollectionProxy * fCollectionProxy
Definition: TClass.h:220
TClass::StreamerDefault
static void StreamerDefault(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Default streaming in cases where either we have no way to know what to do or if Property() has not ye...
Definition: TClass.cxx:6813
TClass::Property
Long_t Property() const
Returns the properties of the TClass as a bit field stored as a Long_t value.
Definition: TClass.cxx:6029
TClass::kUnloading
@ kUnloading
Definition: TClass.h:330
TClass::ECheckSum
ECheckSum
Definition: TClass.h:108
TClass::kClassNew
@ kClassNew
Definition: TClass.h:107
TClass::GetMissingDictionaries
void GetMissingDictionaries(THashTable &result, bool recurse=false)
Get the classes that have a missing dictionary starting from this one.
Definition: TClass.cxx:4071
TClass::TDeclNameRegistry::fSpinLock
std::atomic_flag fSpinLock
Definition: TClass.h:170
TClass::kLoading
@ kLoading
Definition: TClass.h:330
TClass::~TClass
virtual ~TClass()
TClass dtor. Deletes all list that might have been created.
Definition: TClass.cxx:1638
TClass::SetStreamerImpl
void SetStreamerImpl()
Internal routine to set fStreamerImpl based on the value of fStreamerType.
Definition: TClass.cxx:6158
TClass::TDeclNameRegistry::fClassNamesSet
std::unordered_set< std::string > fClassNamesSet
Definition: TClass.h:169
r
ROOT::R::TRInterface & r
Definition: Object.C:4
TClass::GetMethodList
TListOfFunctions * GetMethodList()
Return (create an empty one if needed) the list of functions.
Definition: TClass.cxx:4339
TClass::CalculateStreamerOffset
void CalculateStreamerOffset() const
Calculate the offset between an object of this class to its base class TObject.
Definition: TClass.cxx:2161
TClass::TDeclNameRegistry::HasDeclName
Bool_t HasDeclName(const char *name) const
Definition: TClass.cxx:223
TClass::CanIgnoreTObjectStreamer
Bool_t CanIgnoreTObjectStreamer()
Definition: TClass.h:391
TClass::MoveAddressInRepository
void MoveAddressInRepository(const char *where, void *oldadd, void *newadd, const TClass *what) const
Definition: TClass.cxx:337
TClass::GetPersistentRef
TClass *const * GetPersistentRef() const
Definition: TClass.h:478
TClass::HasInterpreterInfoInMemory
Bool_t HasInterpreterInfoInMemory() const
Definition: TClass.h:406
TClass::RepoCont_t
std::multimap< void *, Version_t > RepoCont_t
Definition: TClass.h:341
TClass::IsClassStructOrUnion
bool IsClassStructOrUnion() const
Definition: TClass.h:352
TClass::ObjectPtr::fPtr
void * fPtr
Definition: TClass.h:141
TClass::Dump
void Dump() const
Dump contents of object on stdout.
Definition: TClass.h:396
TClass::GetResetAfterMerge
ROOT::ResetAfterMergeFunc_t GetResetAfterMerge() const
Return the wrapper around Merge.
Definition: TClass.cxx:7375
TClass::EState
EState
Definition: TClass.h:121
TClass::fNewArray
ROOT::NewArrFunc_t fNewArray
Definition: TClass.h:236
TClass::kExternal
@ kExternal
Definition: TClass.h:332
TClass::GetListOfFunctionTemplates
TList * GetListOfFunctionTemplates(Bool_t load=kTRUE)
Return TListOfFunctionTemplates for a class.
Definition: TClass.cxx:3782
TClass::GetReferenceProxy
TVirtualRefProxy * GetReferenceProxy() const
Definition: TClass.h:480
TClass::fDelete
ROOT::DelFunc_t fDelete
Definition: TClass.h:237
TClass::LoadClass
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition: TClass.cxx:5733
TClass::AddClass
static void AddClass(TClass *cl)
static: Add a class to the list and map of classes.
Definition: TClass.cxx:494
TClass::operator=
TClass & operator=(const TClass &)=delete
TClass::HasDefaultConstructor
Bool_t HasDefaultConstructor(Bool_t testio=kFALSE) const
Return true if we have access to a constructor usable for I/O.
Definition: TClass.cxx:7329
TClass::ClassProperty
Long_t ClassProperty() const
Return the C++ property of this class, eg.
Definition: TClass.cxx:2375
TClass::fClassProperty
Long_t fClassProperty
Property See TClass::Property() for details.
Definition: TClass.h:253
TBaseClass
Each class (see TClass) has a linked list of its base class(es).
Definition: TBaseClass.h:33
TClass::GetNdata
Int_t GetNdata()
Return the number of data members of this class Note that in case the list of data members is not yet...
Definition: TClass.cxx:4538
TClass::RegisterStreamerInfo
void RegisterStreamerInfo(TVirtualStreamerInfo *info)
Register the StreamerInfo in the given slot, change the State of the TClass as appropriate.
Definition: TClass.cxx:7236
TClass::fDeclFileLine
Short_t fDeclFileLine
Definition: TClass.h:215
TClass::IsLoaded
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition: TClass.cxx:5896
TClass::kCurrentCheckSum
@ kCurrentCheckSum
Definition: TClass.h:109
TClass::ResetClassInfo
void ResetClassInfo()
Make sure that the current ClassInfo is up to date.
Definition: TClass.cxx:4164
TClass::GetMissingDictionariesForBaseClasses
void GetMissingDictionariesForBaseClasses(TCollection &result, TCollection &visited, bool recurse)
Verify the base classes always.
Definition: TClass.cxx:3911
Int_t
int Int_t
Definition: RtypesCore.h:45
TDataMember
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
TVirtualMutex
This class implements a mutex interface.
Definition: TVirtualMutex.h:32
TClass::GetDataMemberOffset
Long_t GetDataMemberOffset(const char *membername) const
return offset for member name.
Definition: TClass.cxx:3421
TClass::ForceReload
void ForceReload(TClass *oldcl)
we found at least one equivalent.
Definition: TClass.cxx:1325
TClass::CanSplitBaseAllow
Bool_t CanSplitBaseAllow()
Pointer to the function implementing streaming for this class.
Definition: TClass.cxx:2225
TClass::GetClassVersion
Version_t GetClassVersion() const
Definition: TClass.h:417
ROOT::NewArrFunc_t
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition: Rtypes.h:109
TClass::FindConversionStreamerInfo
TVirtualStreamerInfo * FindConversionStreamerInfo(const char *onfile_classname, UInt_t checksum) const
Return a Conversion StreamerInfo from the class 'classname' for the layout represented by 'checksum' ...
Definition: TClass.cxx:7133
ROOT::Internal::TClassGetClassHelper::GetClass
static TClass * GetClass(Bool_t load, Bool_t silent)
Definition: TClass.h:626
TClass::GetBaseClass
TClass * GetBaseClass(const char *classname)
Return pointer to the base class "classname".
Definition: TClass.cxx:2633
TClass::TDeclNameRegistry::~TDeclNameRegistry
~TDeclNameRegistry()
Definition: TClass.cxx:235
TClass::TDeclNameRegistry::fVerbLevel
Int_t fVerbLevel
Definition: TClass.h:168
TClass::WriteBuffer
Int_t WriteBuffer(TBuffer &b, void *pointer, const char *info="")
Function called by the Streamer functions to serialize object at p to buffer b.
Definition: TClass.cxx:6719
TClass::GetStreamerInfo
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition: TClass.cxx:4583
TClass::IsVersioned
Bool_t IsVersioned() const
Definition: TClass.h:517
TClass::GetDeclFileLine
Short_t GetDeclFileLine() const
Definition: TClass.h:426
TClass::ENewType
ENewType
Definition: TClass.h:107
ROOT::GetClass
TClass * GetClass(T *)
Definition: TClass.h:658
TClass::TDeclNameRegistry::TDeclNameRegistry
TDeclNameRegistry(Int_t verbLevel=0)
TDeclNameRegistry class constructor.
Definition: TClass.cxx:185
TClass::GetListOfEnums
TList * GetListOfEnums(Bool_t load=kTRUE)
Return a list containing the TEnums of a class.
Definition: TClass.cxx:3670
TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TClass::SetClassVersion
void SetClassVersion(Version_t version)
Private function.
Definition: TClass.cxx:5659
TClass::fCurrentInfo
std::atomic< TVirtualStreamerInfo * > fCurrentInfo
Current 'state' of the class (Emulated,Interpreted,Loaded)
Definition: TClass.h:275
TClass::kHasNameMapNode
@ kHasNameMapNode
Definition: TClass.h:104
TClass::fDeclFileName
const char * fDeclFileName
Definition: TClass.h:213
TClass::fStreamer
TClassStreamer * fStreamer
Definition: TClass.h:226
TClass::fClassInfo
ClassInfo_t * fClassInfo
Definition: TClass.h:222
TClass::GetTypeInfo
const std::type_info * GetTypeInfo() const
Definition: TClass.h:493
TCling
This class defines an interface to the cling C++ interpreter.
Definition: TCling.h:102
TClass::GetFunctionTemplate
TFunctionTemplate * GetFunctionTemplate(const char *name)
Definition: TClass.cxx:3591
TString
Basic string class.
Definition: TString.h:136
TClass::LoadClassDefault
static TClass * LoadClassDefault(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition: TClass.cxx:5755
ROOT::Internal::TCheckHashRecursiveRemoveConsistency
Definition: TCheckHashRecursiveRemoveConsistency.h:38
TClass::GetSchemaRules
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition: TClass.cxx:1910
TClass::RemoveClassDeclId
static void RemoveClassDeclId(TDictionary::DeclId_t id)
Definition: TClass.cxx:536
TClass::fSharedLibs
TString fSharedLibs
Definition: TClass.h:227
TClass::SetMemberStreamer
void SetMemberStreamer(const char *name, MemberStreamerFunc_t strm)
Install a new member streamer (p will be copied).
Definition: TClass.cxx:6684
TClass::fObjectVersionRepository
RepoCont_t fObjectVersionRepository
Definition: TClass.h:342
TClass::HasInterpreterInfo
Bool_t HasInterpreterInfo() const
Definition: TClass.h:407
TClass::AddImplFile
void AddImplFile(const char *filename, int line)
Definition: TClass.cxx:1930
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TClass::GetDeleteArray
ROOT::DelArrFunc_t GetDeleteArray() const
Return the wrapper around delete [] ThiObject.
Definition: TClass.cxx:7407
TClass::GetCheckSum
UInt_t GetCheckSum(ECheckSum code=kCurrentCheckSum) const
Call GetCheckSum with validity check.
Definition: TClass.cxx:6448
TClass::fCheckSum
std::atomic< UInt_t > fCheckSum
Definition: TClass.h:219
TClass::GetMenuItems
void GetMenuItems(TList *listitems)
Returns list of methods accessible by context menu.
Definition: TClass.cxx:3858
TClass::ObjectPtr::GetAllocator
TVirtualStreamerInfo * GetAllocator() const
Definition: TClass.h:149
TClass::InsertTClassInRegistryRAII
Definition: TClass.h:173
TClass::Load
static TClass * Load(TBuffer &b)
Load class description from I/O buffer and return class object.
Definition: TClass.cxx:5699
TViewPubFunctions
View implementing the TList interface and giving access all the TFunction describing public methods i...
Definition: TViewPubFunctions.h:28
text
TText * text
Definition: entrylist_figure1.C:10
TClass::SetNew
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around 'new'.
Definition: TClass.cxx:6925
b
#define b(i)
Definition: RSha256.hxx:100
TString.h
TClass::GetListOfMethods
TList * GetListOfMethods(Bool_t load=kTRUE)
Return list containing the TMethods of a class.
Definition: TClass.cxx:3796
TClass::ResetMenuList
void ResetMenuList()
Resets the menu list to it's standard value.
Definition: TClass.cxx:4227
TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition: TVirtualStreamerInfo.h:37
TClass::SetGlobalIsA
void SetGlobalIsA(IsAGlobalFunc_t)
This function installs a global IsA function for this class.
Definition: TClass.cxx:6243
bool
TClass::SetMerge
void SetMerge(ROOT::MergeFunc_t mergeFunc)
Install a new wrapper around 'Merge'.
Definition: TClass.cxx:6909
TClass::SetCurrentStreamerInfo
void SetCurrentStreamerInfo(TVirtualStreamerInfo *info)
Set pointer to current TVirtualStreamerInfo.
Definition: TClass.cxx:5680
TClass::fCanLoadClassInfo
std::atomic< Bool_t > fCanLoadClassInfo
Whether info was loaded from a root pcm.
Definition: TClass.h:257
TClass::HasLocalHashMember
Bool_t HasLocalHashMember() const
Returns true if this class has an definition and/or overload of the member function Hash.
Definition: TClass.cxx:7357
TClass::GetDataMember
TDataMember * GetDataMember(const char *datamember) const
Return pointer to datamember object with name "datamember".
Definition: TClass.cxx:3383
ROOT::DirAutoAdd_t
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:113
TClass::FindStreamerInfo
TVirtualStreamerInfo * FindStreamerInfo(TObjArray *arr, UInt_t checksum) const
Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum.
Definition: TClass.cxx:7006
TClass::GetClassMethodWithPrototype
TMethod * GetClassMethodWithPrototype(const char *name, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
Definition: TClass.cxx:4511
TClass::Draw
void Draw(Option_t *option="")
Draw detailed class inheritance structure.
Definition: TClass.cxx:2465
TClass::AdoptMemberStreamer
void AdoptMemberStreamer(const char *name, TMemberStreamer *strm)
Adopt the TMemberStreamer pointer to by p and use it to Stream non basic member name.
Definition: TClass.cxx:6646
TClass::StreamerTObjectInitialized
static void StreamerTObjectInitialized(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects when fIsOffsetStreamerSet is known to have been set.
Definition: TClass.cxx:6754
ClassStreamerFunc_t
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition: Rtypes.h:72
TClass::fStreamerType
Int_t fStreamerType
saved info to call Streamer
Definition: TClass.h:273
TClass::kIgnoreTObjectStreamer
@ kIgnoreTObjectStreamer
Definition: TClass.h:96
TClass::ConvStreamerInstrumented
static void ConvStreamerInstrumented(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of instrumented class with a library.
Definition: TClass.cxx:6785
TClass::SetImplFileName
void SetImplFileName(const char *implFileName)
Definition: TClass.h:555
TClass::GetDelete
ROOT::DelFunc_t GetDelete() const
Return the wrapper around delete ThiObject.
Definition: TClass.cxx:7399
TClass::GetMissingDictionariesWithRecursionCheck
void GetMissingDictionariesWithRecursionCheck(TCollection &result, TCollection &visited, bool recurse)
From the second level of recursion onwards it is different state check.
Definition: TClass.cxx:3974
TClass::GetStreamerFunc
ClassStreamerFunc_t GetStreamerFunc() const
Get a wrapper/accessor function around this class custom streamer (member function).
Definition: TClass.cxx:2917
TClass::Store
void Store(TBuffer &b) const
Store class description on I/O buffer.
Definition: TClass.cxx:5844
TClass::BuildEmulatedRealData
void BuildEmulatedRealData(const char *name, Long_t offset, TClass *cl, Bool_t isTransient=kFALSE)
Build the list of real data for an emulated class.
Definition: TClass.cxx:2090
TClass::fRuntimeProperties
std::atomic< UChar_t > fRuntimeProperties
Definition: TClass.h:270
TClass::kEmulated
@ kEmulated
Definition: TClass.h:125
TClass::kInterpreted
@ kInterpreted
Definition: TClass.h:126
TClass::HasNoInfoOrEmuOrFwdDeclaredDecl
static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char *)
Definition: TClass.cxx:3342
TDictionary.h
TClass::kTObject
@ kTObject
Definition: TClass.h:332
DeclIdMap_t
ROOT::TMapDeclIdToTClass DeclIdMap_t
Definition: TClass.h:78
TClass::CopyCollectionProxy
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Copy the argument.
Definition: TClass.cxx:2448
ROOT::ESTLType
ESTLType
Definition: ESTLType.h:28
TClass::ObjectPtr::GetPtr
void * GetPtr() const
Definition: TClass.h:147
TClass::GetImplFileLine
Short_t GetImplFileLine() const
Definition: TClass.h:454
TClass::fLastReadInfo
std::atomic< TVirtualStreamerInfo * > fLastReadInfo
cached current streamer info.
Definition: TClass.h:276
TClass::SetClassSize
void SetClassSize(Int_t sizof)
Definition: TClass.h:305
TClass::AutoBrowse
static Int_t AutoBrowse(TObject *obj, TBrowser *browser)
Browse external object inherited from TObject.
Definition: TClass.cxx:1944
TClass::GetContextMenuTitle
const char * GetContextMenuTitle() const
Definition: TClass.h:435
TClass::kInstrumented
@ kInstrumented
Definition: TClass.h:332
TClass::MatchLegacyCheckSum
Bool_t MatchLegacyCheckSum(UInt_t checksum) const
Return true if the checksum passed as argument is one of the checksum value produced by the older che...
Definition: TClass.cxx:6437
ROOT::Internal::GetClassHelper
TClass * GetClassHelper(Bool_t, Bool_t, std::true_type)
Definition: TClass.h:619
TProtoClass
Persistent version of a TClass.
Definition: TProtoClass.h:38
TClass::GetMethodWithPrototype
TMethod * GetMethodWithPrototype(const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
Definition: TClass.cxx:4440
TClass::DeleteArray
void DeleteArray(void *ary, Bool_t dtorOnly=kFALSE)
Explicitly call operator delete[] for an array.
Definition: TClass.cxx:5513
TClass::CreateListOfDataMembers
TList * CreateListOfDataMembers(std::atomic< TListOfDataMembers * > &data, TDictionary::EMemberSelection selection, bool load)
Create the list containing the TDataMembers (of actual data members or members pulled in through usin...
Definition: TClass.cxx:3725
TClass::SetCollectionProxy
void SetCollectionProxy(const ROOT::Detail::TCollectionProxyInfo &)
Create the collection proxy object (and the streamer object) from using the information in the TColle...
Definition: TClass.cxx:6187
TClass::HasConsistentHashMember
Bool_t HasConsistentHashMember()
Return 'true' if we can guarantee that if this class (or any class in this class inheritance hierarch...
Definition: TClass.h:498
ROOT::MergeFunc_t
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:114
ROOT::DelArrFunc_t
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:111
TClass::kHasTClassInit
@ kHasTClassInit
Definition: TClass.h:127
TClass::ReplaceWith
void ReplaceWith(TClass *newcl) const
Definition: TClass.cxx:4126
TClass::AdoptSchemaRules
void AdoptSchemaRules(ROOT::Detail::TSchemaRuleSet *rules)
Adopt a new set of Data Model Evolution rules.
Definition: TClass.cxx:1898
TClass::NewObject
ObjectPtr NewObject(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Definition: TClass.cxx:4976
TClass::EscapeChars
char * EscapeChars(const char *text) const
Introduce an escape character (@) in front of a special chars.
Definition: TClass.cxx:2547
TClass::StreamerStreamerInfo
static void StreamerStreamerInfo(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of where we should directly use the StreamerInfo.
Definition: TClass.cxx:6798
TClass::GetCollectionType
ROOT::ESTLType GetCollectionType() const
Return the 'type' of the STL the TClass is representing.
Definition: TClass.cxx:2864
TListOfDataMembers
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
Definition: TListOfDataMembers.h:33
TClass::SetResetAfterMerge
void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc)
Install a new wrapper around 'ResetAfterMerge'.
Definition: TClass.cxx:6917
TClass::SetRuntimeProperties
void SetRuntimeProperties()
Internal routine to set calculate the class properties that can only be known at run-time,...
Definition: TClass.cxx:6137
TClass::InheritsFrom
Bool_t InheritsFrom(const char *cl) const
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4858
TClass::AdoptStreamer
void AdoptStreamer(TClassStreamer *strm)
Adopt a TClassStreamer object.
Definition: TClass.cxx:6834
TClass::ReadBuffer
Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count)
Function called by the Streamer functions to deserialize information from buffer b into object at p.
Definition: TClass.cxx:6698
TClass::InsertTClassInRegistryRAII::fNoInfoOrEmuOrFwdDeclNameRegistry
TDeclNameRegistry & fNoInfoOrEmuOrFwdDeclNameRegistry
Definition: TClass.h:177
TVirtualRefProxy
Definition: TVirtualRefProxy.h:81
TClass::InsertTClassInRegistryRAII::fName
const char * fName
Definition: TClass.h:176
TClass::ERuntimeProperties
ERuntimeProperties
Indicates whether GetClassVersion has been called.
Definition: TClass.h:261
TClass::fMerge
ROOT::MergeFunc_t fMerge
saved info to call a IsA member function
Definition: TClass.h:233
TClass::ResetCaches
void ResetCaches()
To clean out all caches.
Definition: TClass.cxx:4199
TClass::InsertTClassInRegistryRAII::fState
TClass::EState & fState
Definition: TClass.h:175
TClass::fStreamerInfo
TObjArray * fStreamerInfo
Definition: TClass.h:198
THashTable
THashTable implements a hash table to store TObject's.
Definition: THashTable.h:35
TClass::fPersistentRef
std::atomic< TClass ** > fPersistentRef
Definition: TClass.h:194
TStreamerInfo
Describe Streamer information for one class version.
Definition: TStreamerInfo.h:44
TClass::fOffsetStreamer
Long_t fOffsetStreamer
Properties that can only be evaluated at run-time.
Definition: TClass.h:272
TClass::fShowMembers
ShowMembersFunc_t fShowMembers
Definition: TClass.h:225
TClass::New
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition: TClass.cxx:4962
TClass::IsForeign
Bool_t IsForeign() const
Return kTRUE is the class is Foreign (the class does not have a Streamer method).
Definition: TClass.cxx:5931
TClass::kForeign
@ kForeign
Definition: TClass.h:332
TClass::GetListOfBases
TList * GetListOfBases()
Return list containing the TBaseClass(es) of a class.
Definition: TClass.cxx:3620
TClass::GetNmethods
Int_t GetNmethods()
Return the number of methods of this class Note that in case the list of methods is not yet created,...
Definition: TClass.cxx:4557
TClass::GetListOfRealData
TList * GetListOfRealData() const
Definition: TClass.h:450
TDictionary::DeclId_t
const void * DeclId_t
Definition: TDictionary.h:223
TClass::fDeleteArray
ROOT::DelArrFunc_t fDeleteArray
Definition: TClass.h:238
TClass::TClass
TClass()
Definition: TClass.cxx:1060
TClass::GetConversionStreamerInfo
TVirtualStreamerInfo * GetConversionStreamerInfo(const char *onfile_classname, Int_t version) const
Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this clas...
Definition: TClass.cxx:7026
TClass::fUsingData
std::atomic< TListOfDataMembers * > fUsingData
Definition: TClass.h:203
TClass::kHasLocalHashMember
@ kHasLocalHashMember
Definition: TClass.h:95
TClass::GetMethod
TMethod * GetMethod(const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Find the best method (if there is one) matching the parameters.
Definition: TClass.cxx:4395
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TClass::operator&
friend bool operator&(UChar_t l, ERuntimeProperties r)
Definition: TClass.h:267
TClass::FindClassOrBaseMethodWithId
TMethod * FindClassOrBaseMethodWithId(DeclId_t faddr)
Find a method with decl id in this class or its bases.
Definition: TClass.cxx:4424
TClass::GetConvStreamerFunc
ClassConvStreamerFunc_t GetConvStreamerFunc() const
Get a wrapper/accessor function around this class custom conversion streamer (member function).
Definition: TClass.cxx:2925
TMethod
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:38
Long_t
long Long_t
Definition: RtypesCore.h:54
TClass::fProperty
std::atomic< Long_t > fProperty
Definition: TClass.h:252
TClass::fStreamerFunc
ClassStreamerFunc_t fStreamerFunc
Definition: TClass.h:241
TClass::fIsAMethod
std::atomic< TMethodCall * > fIsAMethod
Definition: TClass.h:231
TClass::RemoveStreamerInfo
void RemoveStreamerInfo(Int_t slot)
Remove and delete the StreamerInfo in the given slot.
Definition: TClass.cxx:7260
TClass::Clone
TObject * Clone(const char *newname="") const
Create a Clone of this TClass object using a different name but using the same 'dictionary'.
Definition: TClass.cxx:2385
TClass::GetDeclFileName
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
Definition: TClass.cxx:3407
TClass::kIsTObject
@ kIsTObject
Definition: TClass.h:99
TClass::HasDataMemberInfo
Bool_t HasDataMemberInfo() const
Definition: TClass.h:404
TClass::fData
std::atomic< TListOfDataMembers * > fData
Definition: TClass.h:202
TClass::GetClassSize
Int_t GetClassSize() const
Definition: TClass.h:422
TClass::kWithTypeDef
@ kWithTypeDef
Definition: TClass.h:113
TClass::kNoRangeCheck
@ kNoRangeCheck
Definition: TClass.h:115
what
static const char * what
Definition: stlLoader.cc:6
TClass::SetDelete
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around 'delete'.
Definition: TClass.cxx:6941
BIT
#define BIT(n)
Definition: Rtypes.h:85
TClass::GetStreamerInfos
const TObjArray * GetStreamerInfos() const
Definition: TClass.h:489
sqlio::ObjectPtr
const char * ObjectPtr
Definition: TSQLStructure.cxx:53
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TClass::fDirAutoAdd
ROOT::DirAutoAdd_t fDirAutoAdd
Definition: TClass.h:240
TClass::CanSplit
Bool_t CanSplit() const
Return true if the data member of this TClass can be saved separately.
Definition: TClass.cxx:2298
TClass::SetConvStreamerFunc
void SetConvStreamerFunc(ClassConvStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom conversion streamer.
Definition: TClass.cxx:6885
TClass::DetermineCurrentStreamerInfo
TVirtualStreamerInfo * DetermineCurrentStreamerInfo()
Determine and set pointer to current TVirtualStreamerInfo.
Definition: TClass.cxx:5668
TClass::NewArray
void * NewArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
Definition: TClass.cxx:5177
TClass::GetClass
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2946
TClass::AdoptReferenceProxy
void AdoptReferenceProxy(TVirtualRefProxy *proxy)
Adopt the Reference proxy pointer to indicate that this class represents a reference.
Definition: TClass.cxx:6628
TClass::GetListOfUsingDataMembers
TList * GetListOfUsingDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of using declarations of a class.
Definition: TClass.cxx:3770
TClass::fIsA
TVirtualIsAProxy * fIsA
Definition: TClass.h:229
TClass::GetClassInfo
ClassInfo_t * GetClassInfo() const
Definition: TClass.h:430
TClass::GetMenuList
TList * GetMenuList() const
Return the list of menu items associated with the class.
Definition: TClass.cxx:4325
TClass::GetImplFileName
const char * GetImplFileName() const
Definition: TClass.h:453
ShowMembersFunc_t
void(* ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient)
Definition: Rtypes.h:94
Short_t
short Short_t
Definition: RtypesCore.h:39
TClass::InsertTClassInRegistryRAII::~InsertTClassInRegistryRAII
~InsertTClassInRegistryRAII()
Definition: TClass.cxx:254
TClass::GetListOfMethodOverloads
TCollection * GetListOfMethodOverloads(const char *name) const
Return the collection of functions named "name".
Definition: TClass.cxx:3811
TClass::PostLoadCheck
virtual void PostLoadCheck()
Do the initialization that can only be done after the CINT dictionary has been fully populated and ca...
Definition: TClass.cxx:5941
TClass::kHasCustomStreamerMember
@ kHasCustomStreamerMember
Definition: TClass.h:105
ROOT::CreateClass
TClass * CreateClass(const char *cname, Version_t id, const std::type_info &info, TVirtualIsAProxy *isa, const char *dfil, const char *ifil, Int_t dl, Int_t il)
Global function called by a class' static Dictionary() method (see the ClassDef macro).
Definition: TClass.cxx:5853
TClass::fFuncTemplate
TListOfFunctionTemplates * fFuncTemplate
Definition: TClass.h:206
line
TLine * line
Definition: entrylistblock_figure1.C:235
TClass::fContextMenuTitle
TString fContextMenuTitle
Definition: TClass.h:223
TClass::IsFolder
Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition: TClass.h:512
TClass::fgClassCount
static std::atomic< Int_t > fgClassCount
Definition: TClass.h:324
TClass::BuildRealData
void BuildRealData(void *pointer=0, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition: TClass.cxx:2009
TClass::fClassMenuList
TList * fClassMenuList
Definition: TClass.h:211
TClass::IsTObject
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition: TClass.cxx:5922
void
typedef void((*Func_t)())
TClass::fSchemaRules
ROOT::Detail::TSchemaRuleSet * fSchemaRules
Pointer to reference proxy if this class represents a reference.
Definition: TClass.h:278
TClass::GetDict
static DictFuncPtr_t GetDict(const char *cname)
Return a pointer to the dictionary loading function generated by rootcint.
Definition: TClass.cxx:3366
ROOT::Internal::TClassGetClassHelper
Definition: TClass.h:625
TDictionary
This class defines an abstract interface that must be implemented by all classes that contain diction...
Definition: TDictionary.h:167
unsigned int
TClass::fHasRootPcmInfo
std::atomic< Bool_t > fHasRootPcmInfo
C++ Property of the class (is abstract, has virtual table, etc.)
Definition: TClass.h:256
TClass::SetDeclFile
void SetDeclFile(const char *name, int line)
Definition: TClass.h:550
TClass::fConversionStreamerInfo
ConvSIMap_t fConversionStreamerInfo
Definition: TClass.h:199
TClass::ConvSIMap_t
std::atomic< std::map< std::string, TObjArray * > * > ConvSIMap_t
Persistent address of pointer to this TClass object and its successors.
Definition: TClass.h:196
TObject::Dump
virtual void Dump() const
Dump contents of object on stdout.
Definition: TObject.cxx:268
ROOT::EFunctionMatchMode
EFunctionMatchMode
Definition: TDictionary.h:160
TClass::TDeclNameRegistry::AddQualifiedName
void AddQualifiedName(const char *name)
Extract this part of the name.
Definition: TClass.cxx:196
TClass::fImplFileName
const char * fImplFileName
Definition: TClass.h:214
TClass::GetCurrentStreamerInfo
TVirtualStreamerInfo * GetCurrentStreamerInfo()
Definition: TClass.h:436
TClass::GetStreamer
TClassStreamer * GetStreamer() const
Return the Streamer Class allowing streaming (if any).
Definition: TClass.cxx:2892
TClass::kLoaded
@ kLoaded
Definition: TClass.h:130
TClass::GetLastReadInfo
TVirtualStreamerInfo * GetLastReadInfo() const
Definition: TClass.h:441
TClass::AddInstance
void AddInstance(Bool_t heap=kFALSE)
Definition: TClass.h:379
TClass::fEnums
std::atomic< TListOfEnums * > fEnums
Definition: TClass.h:205
TClass::kStartWithTObject
@ kStartWithTObject
Definition: TClass.h:102
TListOfEnums
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
Definition: TListOfEnums.h:33
TClass::fIsOffsetStreamerSet
std::atomic< Bool_t > fIsOffsetStreamerSet
Indicates whether the ClassInfo is supposed to be available.
Definition: TClass.h:258
TClass::fCanSplit
Int_t fCanSplit
Definition: TClass.h:246
TClass::SetContextMenuTitle
void SetContextMenuTitle(const char *title)
Change (i.e. set) the title of the TNamed.
Definition: TClass.cxx:6212
TClass::fAllPubMethod
TViewPubFunctions * fAllPubMethod
Definition: TClass.h:210
proto
const char * proto
Definition: civetweb.c:16604
TClass::GetMissingDictionariesForMembers
void GetMissingDictionariesForMembers(TCollection &result, TCollection &visited, bool recurse)
Verify the Data Members.
Definition: TClass.cxx:3928
TClass::fNew
ROOT::NewFunc_t fNew
Definition: TClass.h:235
kIsStruct
@ kIsStruct
Definition: TDictionary.h:66
TClass::IsStartingWithTObject
Bool_t IsStartingWithTObject() const
Returns true if this class inherits from TObject and if the start of the TObject parts is at the very...
Definition: TClass.cxx:5913
TClass::fgClassTypedefHash
static THashTable * fgClassTypedefHash
Definition: TClass.h:336
TClass::SetUnloaded
void SetUnloaded()
Call this method to indicate that the shared library containing this class's code has been removed (u...
Definition: TClass.cxx:6252
TClass::LoadClassInfo
void LoadClassInfo() const
Try to load the ClassInfo if available.
Definition: TClass.cxx:5808
TClass::ResetInstanceCount
void ResetInstanceCount()
Definition: TClass.h:542
TClass::DynamicCast
void * DynamicCast(const TClass *base, void *obj, Bool_t up=kTRUE)
Cast obj of this class type up to baseclass cl if up is true.
Definition: TClass.cxx:4899
TClass::SetLastReadInfo
void SetLastReadInfo(TVirtualStreamerInfo *info)
Definition: TClass.h:442
TClass::SetDeleteArray
void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
Install a new wrapper around 'delete []'.
Definition: TClass.cxx:6949
TClass::GetDirectoryAutoAdd
ROOT::DirAutoAdd_t GetDirectoryAutoAdd() const
Return the wrapper around the directory auto add function.
Definition: TClass.cxx:7423
TClass::ERuntimeProperties::kConsistentHash
@ kConsistentHash
TObjArray.h
TClass::GetListOfDataMembers
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
Definition: TClass.cxx:3754
TClass::GetNew
ROOT::NewFunc_t GetNew() const
Return the wrapper around new ThisClass().
Definition: TClass.cxx:7383
TRealData
The TRealData class manages the effective list of all data members for a given class.
Definition: TRealData.h:30
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TClass::HasDictionarySelection
static Bool_t HasDictionarySelection(const char *clname)
Check whether a class has a dictionary or ROOT can load one.
Definition: TClass.cxx:3901
TClass::GetStreamerInfoImpl
TVirtualStreamerInfo * GetStreamerInfoImpl(Int_t version, Bool_t silent) const
Definition: TClass.cxx:4618
UChar_t
unsigned char UChar_t
Definition: RtypesCore.h:38
TClass::kForwardDeclared
@ kForwardDeclared
Definition: TClass.h:124
TClass::SetNewArray
void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
Install a new wrapper around 'new []'.
Definition: TClass.cxx:6933
TClass::Destructor
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition: TClass.cxx:5384
TClass::IgnoreTObjectStreamer
void IgnoreTObjectStreamer(Bool_t ignore=kTRUE)
When the class kIgnoreTObjectStreamer bit is set, the automatically generated Streamer will not call ...
Definition: TClass.cxx:4825
TClass::GetIsAProxy
TVirtualIsAProxy * GetIsAProxy() const
Return the proxy implementing the IsA functionality.
Definition: TClass.cxx:2933
TViewPubDataMembers
View implementing the TList interface and giving access all the TDictionary describing public data me...
Definition: TViewPubDataMembers.h:28
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
ROOT::TGenericClassInfo
Definition: TGenericClassInfo.h:40
TClass::kNoRange
@ kNoRange
Definition: TClass.h:112
TClass::RegisterAddressInRepository
void RegisterAddressInRepository(const char *where, void *location, const TClass *what) const
Definition: TClass.cxx:290
TClass::ERuntimeProperties::kSet
@ kSet
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
TClass::ObjectPtr::ObjectPtr
ObjectPtr(void *ptr=nullptr, TVirtualStreamerInfo *allocator=nullptr)
Definition: TClass.h:145
TDictionary::EMemberSelection
EMemberSelection
Kinds of members to include in lists.
Definition: TDictionary.h:215
TClass::GetBaseClassOffset
Int_t GetBaseClassOffset(const TClass *toBase, void *address=0, bool isDerivedObject=true)
Definition: TClass.cxx:2769
TClass::ERuntimeProperties::kNotInitialized
@ kNotInitialized
ClassConvStreamerFunc_t
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition: Rtypes.h:73
TClass::GetBaseClassOffsetRecurse
Int_t GetBaseClassOffsetRecurse(const TClass *toBase)
Return data member offset to the base class "cl".
Definition: TClass.cxx:2683
name
char name[80]
Definition: TGX11.cxx:110
TClass::InsertTClassInRegistryRAII::InsertTClassInRegistryRAII
InsertTClassInRegistryRAII(TClass::EState &state, const char *name, TDeclNameRegistry &emuRegistry)
Definition: TClass.cxx:248
TClass::LoadClassCustom
static TClass * LoadClassCustom(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition: TClass.cxx:5785
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34
TClass::GetState
EState GetState() const
Definition: TClass.h:485
TClass::fSizeof
Int_t fSizeof
Definition: TClass.h:243
ROOT::NewFunc_t
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:108
TClass::SetCanSplit
void SetCanSplit(Int_t splitmode)
Set the splitability of this class:
Definition: TClass.cxx:5642
TClass::GetIdMap
static IdMap_t * GetIdMap()
Definition: TClass.cxx:469
TClass::fMethod
std::atomic< TListOfFunctions * > fMethod
Definition: TClass.h:207
TClass::fInstanceCount
UInt_t fInstanceCount
Definition: TClass.h:217
ROOT::ResetClassVersion
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
Definition: TClassTable.cxx:808
TClass::kNoInfo
@ kNoInfo
Definition: TClass.h:122
TClass::GetDeclIdMap
static DeclIdMap_t * GetDeclIdMap()
Definition: TClass.cxx:480
TClassStreamer
Definition: TClassStreamer.h:26
TClass::fImplFileLine
Short_t fImplFileLine
Definition: TClass.h:216
TClass::fResetAfterMerge
ROOT::ResetAfterMergeFunc_t fResetAfterMerge
Definition: TClass.h:234
TClass::IsCallingNew
static ENewType IsCallingNew()
Static method returning the defConstructor flag passed to TClass::New().
Definition: TClass.cxx:5886
TMethodCall
Method or function calling interface.
Definition: TMethodCall.h:37
TCollection
Collection abstract base class.
Definition: TCollection.h:63
TClass::IsSyntheticPair
Bool_t IsSyntheticPair() const
Definition: TClass.h:516
TClass::GetMerge
ROOT::MergeFunc_t GetMerge() const
Return the wrapper around Merge.
Definition: TClass.cxx:7367
TClass::ReadRules
static Int_t ReadRules()
Read the class.rules files from the default location:.
Definition: TClass.cxx:1798
DictFuncPtr_t
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:80
TClass::GetClassMethod
TMethod * GetClassMethod(Long_t faddr)
Look for a method in this class that has the interface function address faddr.
Definition: TClass.cxx:4467
TVirtualIsAProxy
Definition: TVirtualIsAProxy.h:27
TClass::fDestructor
ROOT::DesFunc_t fDestructor
Definition: TClass.h:239
TMemberStreamer
Definition: TMemberStreamer.h:26
kIsUnion
@ kIsUnion
Definition: TDictionary.h:67
TClass::Init
void Init(const char *name, Version_t cversion, const std::type_info *info, TVirtualIsAProxy *isa, const char *dfil, const char *ifil, Int_t dl, Int_t il, ClassInfo_t *classInfo, Bool_t silent)
Initialize a TClass object.
Definition: TClass.cxx:1350
TClass::kIsForeign
@ kIsForeign
Definition: TClass.h:100
type
int type
Definition: TGX11.cxx:121
TClass::Move
void Move(void *arenaFrom, void *arenaTo) const
Register the fact that an object was moved from the memory location 'arenaFrom' to the memory locatio...
Definition: TClass.cxx:4311
TClass::fRealData
TList * fRealData
Definition: TClass.h:200
TClass::GetStreamerInfoAbstractEmulated
TVirtualStreamerInfo * GetStreamerInfoAbstractEmulated(Int_t version=0) const
For the case where the requestor class is emulated and this class is abstract, returns a pointer to t...
Definition: TClass.cxx:4693
TClass::TClass
TClass(const TClass &tc)=delete
TClass::CallShowMembers
Bool_t CallShowMembers(const void *obj, TMemberInspector &insp, Bool_t isTransient=kFALSE) const
Call ShowMembers() on the obj of this class type, passing insp and parent.
Definition: TClass.cxx:2183
TClass::kWarned
@ kWarned
Definition: TClass.h:103
TClass::AddClassToDeclIdMap
static void AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass *cl)
static: Add a TClass* to the map of classes.
Definition: TClass.cxx:511
TClass::GetDestructor
ROOT::DesFunc_t GetDestructor() const
Return the wrapper around the destructor.
Definition: TClass.cxx:7415
TClass::kEmulatedStreamer
@ kEmulatedStreamer
Definition: TClass.h:332
TClass::kReflexNoComment
@ kReflexNoComment
Definition: TClass.h:111
Class
void Class()
Definition: Class.C:29
TClass::InterpretedShowMembers
void InterpretedShowMembers(void *obj, TMemberInspector &insp, Bool_t isTransient)
Do a ShowMembers() traversal of all members and base classes' members using the reflection informatio...
Definition: TClass.cxx:2220
TClass::AddRule
static Bool_t AddRule(const char *rule)
Add a schema evolution customization rule.
Definition: TClass.cxx:1868
TClass::SetStreamerFunc
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition: TClass.cxx:6862
TClass::fOVRMutex
TVirtualMutex * fOVRMutex
Definition: TClass.h:340
TClass::fVersionUsed
std::atomic< Bool_t > fVersionUsed
saved remember if fOffsetStreamer has been set.
Definition: TClass.h:259
TClass::fState
EState fState
cached of the streaming method to use
Definition: TClass.h:274
TClass::GetShowMembersWrapper
ShowMembersFunc_t GetShowMembersWrapper() const
Definition: TClass.h:484
TClass::kRealNew
@ kRealNew
Definition: TClass.h:107
TClass::fBase
std::atomic< TList * > fBase
Definition: TClass.h:201
TClass::SetStreamerInfo
TVirtualStreamerInfo * SetStreamerInfo(Int_t version, const char *info="")
Info is a string describing the names and types of attributes written by the class Streamer function.
Definition: TClass.cxx:6316
TClass::StreamerExternal
static void StreamerExternal(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
There is special streamer for the class.
Definition: TClass.cxx:6728
TClass::fGlobalIsA
IsAGlobalFunc_t fGlobalIsA
pointer to the class's IsA proxy.
Definition: TClass.h:230
TClass::fStreamerImpl
std::atomic< StreamerImpl_t > fStreamerImpl
Definition: TClass.h:284
ROOT
VSD Structures.
Definition: EExecutionPolicy.hxx:4
TClass::fIsSyntheticPair
Bool_t fIsSyntheticPair
Indicates whether this class can be split or not. Values are -1, 0, 1, 2.
Definition: TClass.h:250
TClass::fTypeInfo
const std::type_info * fTypeInfo
Definition: TClass.h:224
TClass::kReservedLoading
@ kReservedLoading
Definition: TClass.h:92
ROOT::Detail::TSchemaRuleSet
Definition: TSchemaRuleSet.h:25
TClass::kNoBaseCheckSum
@ kNoBaseCheckSum
Definition: TClass.h:116
TClass::kUnloaded
@ kUnloaded
Definition: TClass.h:97
TObject::EStatusBits
EStatusBits
Definition: TObject.h:57
TVirtualCollectionProxy
Definition: TVirtualCollectionProxy.h:38
TClass::fNoInfoOrEmuOrFwdDeclNameRegistry
static TDeclNameRegistry fNoInfoOrEmuOrFwdDeclNameRegistry
Definition: TClass.h:326
TList
A doubly linked list.
Definition: TList.h:44
TClass::ls
void ls(Option_t *opt="") const
The ls function lists the contents of a class on stdout.
Definition: TClass.cxx:4242
TClass::kDummyNew
@ kDummyNew
Definition: TClass.h:107
TClass::ObjectPtr::fAllocator
TVirtualStreamerInfo * fAllocator
Definition: TClass.h:143
int
IdMap_t
ROOT::TMapTypeToTClass IdMap_t
Definition: TClass.h:77
TClass::GetSharedLibs
const char * GetSharedLibs()
Get the list of shared libraries containing the code for class cls.
Definition: TClass.cxx:3607
TFunctionTemplate
Dictionary for function template This class describes one single function template.
Definition: TFunctionTemplate.h:26
TClass::TDeclNameRegistry
Definition: TClass.h:158
TClass::HasDictionary
Bool_t HasDictionary() const
Check whether a class has a dictionary or not.
Definition: TClass.cxx:3890