Logo ROOT  
Reference Guide
Rtypes.h
Go to the documentation of this file.
1 /* @(#)root/base:$Id$ */
2 
3 /*************************************************************************
4  * Copyright (C) 1995-2014, Rene Brun and Fons Rademakers. *
5  * All rights reserved. *
6  * *
7  * For the licensing terms see $ROOTSYS/LICENSE. *
8  * For the list of contributors see $ROOTSYS/README/CREDITS. *
9  *************************************************************************/
10 
11 #ifndef ROOT_Rtypes
12 #define ROOT_Rtypes
13 
14 //////////////////////////////////////////////////////////////////////////
15 // //
16 // Rtypes //
17 // //
18 // Basic types used by ROOT; ClassDef macros. //
19 // //
20 //////////////////////////////////////////////////////////////////////////
21 
22 
23 #include "RtypesCore.h"
24 // #include "DllImport.h" // included via RtypesCore.h, not used here
25 
26 #ifndef R__LESS_INCLUDES
27 #include <cstdio>
28 #include "strtok.h" // provides R__STRTOK_R with <cstring> include
29 #include "strlcpy.h" // part of string.h on systems that have it
30 #include "snprintf.h" // part of stdio.h on systems that have it
31 #include <type_traits>
32 #endif
33 
34 #include <typeinfo>
35 #include <atomic>
36 
37 #ifndef __CLING__
38 // __attribute__ is not supported on Windows, but it is internally needed by Cling
39 // for autoloading and Clad rely on __attribute__((annotate("D")))
40 #if defined(R__WIN32)
41 #define __attribute__(unused)
42 #endif
43 #endif
44 
45 //---- forward declared class types --------------------------------------------
46 
47 class TClass;
48 class TBuffer;
49 class TDirectory;
50 class TMemberInspector;
51 class TObject;
52 class TNamed;
53 class TCollection;
54 class TFileMergeInfo;
55 class TString;
56 
57 //Moved from TSystem.
60  kMAXPATHLEN = 8192,
61  kBUFFERSIZE = 8192,
62  kItimerResolution = 10 // interval-timer resolution in ms
63 };
64 
65 enum EColor { kWhite =0, kBlack =1, kGray=920,
66  kRed =632, kGreen =416, kBlue=600, kYellow=400, kMagenta=616, kCyan=432,
67  kOrange=800, kSpring=820, kTeal=840, kAzure =860, kViolet =880, kPink=900 };
68 
69 // There is several streamer concepts.
70 class TClassStreamer; // Streamer functor for a class
71 class TMemberStreamer; // Streamer functor for a data member
72 typedef void (*ClassStreamerFunc_t)(TBuffer&, void*); // Streamer function for a class
73 typedef void (*ClassConvStreamerFunc_t)(TBuffer&, void*, const TClass*); // Streamer function for a class with conversion.
74 typedef void (*MemberStreamerFunc_t)(TBuffer&, void*, Int_t); // Streamer function for a data member
75 
76 // This class is used to implement proxy around collection classes.
78 
79 typedef void (*VoidFuncPtr_t)(); //pointer to void function
80 typedef TClass* (*DictFuncPtr_t)(); //pointer to dictionary function
81 // NOTE: the previous name must be changed.
82 
83 //--- bit manipulation ---------------------------------------------------------
84 
85 #define BIT(n) (1ULL << (n))
86 #define SETBIT(n,i) ((n) |= BIT(i))
87 #define CLRBIT(n,i) ((n) &= ~BIT(i))
88 #define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
89 
90 
91 
92 //---- ClassDef macros ---------------------------------------------------------
93 
94 typedef void (*ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient);
95 class TVirtualIsAProxy;
96 typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);
97 
98 // TBuffer.h declares and implements the following 2 operators
99 template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
100 template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj);
101 
102 // This might get used if we implement setting a class version.
103 // template <class RootClass> Short_t GetClassVersion(RootClass *);
104 
105 namespace ROOT {
106 
107  class TGenericClassInfo;
108  typedef void *(*NewFunc_t)(void *);
109  typedef void *(*NewArrFunc_t)(Long_t size, void *arena);
110  typedef void (*DelFunc_t)(void *);
111  typedef void (*DelArrFunc_t)(void *);
112  typedef void (*DesFunc_t)(void *);
113  typedef void (*DirAutoAdd_t)(void *, TDirectory *);
114  typedef Long64_t (*MergeFunc_t)(void *, TCollection *, TFileMergeInfo *);
116 
117  template <class RootClass> Short_t SetClassVersion(RootClass *);
118 
119  extern TClass *CreateClass(const char *cname, Version_t id,
120  const std::type_info &info, TVirtualIsAProxy *isa,
121  const char *dfil, const char *ifil,
122  Int_t dl, Int_t il);
123  extern void AddClass(const char *cname, Version_t id, const std::type_info &info,
124  DictFuncPtr_t dict, Int_t pragmabits);
125  extern void RemoveClass(const char *cname);
126  extern void ResetClassVersion(TClass*, const char*, Short_t);
127  extern void AddClassAlternate(const char *normName, const char *alternate);
128 
129  extern TNamed *RegisterClassTemplate(const char *name,
130  const char *file, Int_t line);
131 
132  extern void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector&);
133 
134 #if 0
135  // This function is only implemented in the dictionary file.
136  // The parameter is 'only' for overloading resolution.
137  // Used to be a template <class T> TGenericClassInfo *GenerateInitInstance(const T*);
138  template <class T> TGenericClassInfo *GetClassInfo(const T* t) {
139  TGenericClassInfo *GenerateInitInstance(const T*);
140  return CreateInitInstance(t);
141  };
142 #endif
143 
144  namespace Internal {
146  // This class defines the interface for the class registration and
147  // the TClass creation. To modify the default behavior, one would
148  // inherit from this class and overload ROOT::DefineBehavior().
149  // See TQObject.h and table/inc/Ttypes.h for examples.
150  public:
151  virtual ~TInitBehavior() { }
152 
153  virtual void Register(const char *cname, Version_t id,
154  const std::type_info &info,
155  DictFuncPtr_t dict, Int_t pragmabits) const = 0;
156  virtual void Unregister(const char *classname) const = 0;
157  virtual TClass *CreateClass(const char *cname, Version_t id,
158  const std::type_info &info, TVirtualIsAProxy *isa,
159  const char *dfil, const char *ifil,
160  Int_t dl, Int_t il) const = 0;
161  };
162 
164  public:
165  virtual void Register(const char *cname, Version_t id,
166  const std::type_info &info,
167  DictFuncPtr_t dict, Int_t pragmabits) const {
168  ROOT::AddClass(cname, id, info, dict, pragmabits);
169  }
170 
171  virtual void Unregister(const char *classname) const {
172  ROOT::RemoveClass(classname);
173  }
174 
175  virtual TClass *CreateClass(const char *cname, Version_t id,
176  const std::type_info &info, TVirtualIsAProxy *isa,
177  const char *dfil, const char *ifil,
178  Int_t dl, Int_t il) const {
179  return ROOT::CreateClass(cname, id, info, isa, dfil, ifil, dl, il);
180  }
181  };
182 
183  const TInitBehavior *DefineBehavior(void * /*parent_type*/,
184  void * /*actual_type*/);
185  } // namespace Internal
186 
187 } // namespace ROOT
188 
189 // The macros below use TGenericClassInfo and TInstrumentedIsAProxy, so let's
190 // ensure they are included.
191 #include "TGenericClassInfo.h"
192 
193 typedef std::atomic<TClass*> atomic_TClass_ptr;
194 
195 #include "TIsAProxy.h"
196 #include <string>
197 
198 namespace ROOT { namespace Internal {
199 
201 public:
202  // All implemented in TGenericClassInfo.cxx.
203  static void SetInstance(::ROOT::TGenericClassInfo& R__instance,
205  static void SetName(const std::string& name, std::string& nameMember);
206  static void SetfgIsA(atomic_TClass_ptr& isA, TClass*(*dictfun)());
207 };
208 
209 template <typename T>
211  public TCDGIILIBase {
213  static ::ROOT::TGenericClassInfo *fgGenericInfo;
214  public:
215  static void *New(void *p) { return p ? new(p) T : new T; };
216  static void *NewArray(Long_t nElements, void *p) {
217  return p ? new(p) T[nElements] : new T[nElements]; }
218  static void Delete(void *p) { delete ((T*)p); }
219  static void DeleteArray(void *p) { delete[] ((T*)p); }
220  static void Destruct(void *p) { ((T*)p)->~T(); }
221  static ::ROOT::TGenericClassInfo *GenerateInitInstanceLocal() {
222  static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy<T>(0);
223  static ::ROOT::TGenericClassInfo
224  R__instance(T::Class_Name(), T::Class_Version(),
225  T::DeclFileName(), T::DeclFileLine(),
226  typeid(T), ::ROOT::Internal::DefineBehavior((T*)0, (T*)0),
227  &T::Dictionary, isa_proxy, 0, sizeof(T) );
228  SetInstance(R__instance, &New, &NewArray, &Delete, &DeleteArray, &Destruct);
229  return &R__instance;
230  }
231  // We need a reference to the template instance static member in a concrete function in order
232  // to force its instantiation (even before the function is actually run)
233  // Since we do have a reference to Dictionary (in T::Dictionary), using fgGenericInfo
234  // here will insure that it is initialized at process start or library load time.
235  static TClass *Dictionary() { fgIsA = fgGenericInfo->GetClass(); return fgIsA; }
236  static TClass *Class() { SetfgIsA(fgIsA, &Dictionary); return fgIsA; }
237  static const char* Name() {
238  static std::string gName;
239  if (gName.empty())
240  SetName(GetDemangledTypeName(typeid(T)), gName);
241  return gName.c_str();
242  }
243  };
244 
245  template<typename T>
247  template<typename T>
250  };
251 
252  template <typename T>
255  };
256 
257  template <typename T>
259 
260  void DefaultStreamer(TBuffer &R__b, const TClass *cl, void *objpointer);
262  Bool_t HasConsistentHashMember(const char *clName);
263 }} // namespace ROOT::Internal
264 
265 
266 // Common part of ClassDef definition.
267 // DeclFileLine() is not part of it since CINT uses that as trigger for
268 // the class comment string.
269 #define _ClassDefBase_(name, id, virtual_keyword, overrd) \
270 private: \
271  static_assert(std::is_integral<decltype(id)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); \
272  virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd \
273  { \
274  static std::atomic<UChar_t> recurseBlocker(0); \
275  if (R__likely(recurseBlocker >= 2)) { \
276  return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
277  } else if (recurseBlocker == 1) { \
278  return false; \
279  } else if (recurseBlocker++ == 0) { \
280  ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = \
281  ::ROOT::Internal::HasConsistentHashMember(_QUOTE_(name)) || \
282  ::ROOT::Internal::HasConsistentHashMember(*IsA()); \
283  ++recurseBlocker; \
284  return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
285  } \
286  return false; /* unreacheable */ \
287  } \
288  \
289 public: \
290  static Version_t Class_Version() { return id; } \
291  virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
292  virtual_keyword void ShowMembers(TMemberInspector &insp) const overrd \
293  { \
294  ::ROOT::Class_ShowMembers(name::Class(), this, insp); \
295  } \
296  void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
297  static const char *DeclFileName() { return __FILE__; }
298 
299 #define _ClassDefOutline_(name,id, virtual_keyword, overrd) \
300  _ClassDefBase_(name,id, virtual_keyword, overrd) \
301 private: \
302  static atomic_TClass_ptr fgIsA; \
303 public: \
304  static int ImplFileLine(); \
305  static const char *ImplFileName(); \
306  static const char *Class_Name(); \
307  static TClass *Dictionary(); \
308  static TClass *Class(); \
309  virtual_keyword void Streamer(TBuffer&) overrd;
310 
311 #define _ClassDefInline_(name, id, virtual_keyword, overrd) \
312  _ClassDefBase_(name, id, virtual_keyword, overrd) public : static int ImplFileLine() { return -1; } \
313  static const char *ImplFileName() { return 0; } \
314  static const char *Class_Name() \
315  { \
316  return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Name(); \
317  } \
318  static TClass *Dictionary() \
319  { \
320  return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Dictionary(); \
321  } \
322  static TClass *Class() { return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Class(); } \
323  virtual_keyword void Streamer(TBuffer &R__b) overrd { ::ROOT::Internal::DefaultStreamer(R__b, name::Class(), this); }
324 
325 #define ClassDef(name,id) \
326  _ClassDefOutline_(name,id,virtual,) \
327  static int DeclFileLine() { return __LINE__; }
328 
329 #define ClassDefOverride(name,id) \
330  _ClassDefOutline_(name,id,,override) \
331  static int DeclFileLine() { return __LINE__; }
332 
333 #define ClassDefNV(name,id) \
334  _ClassDefOutline_(name,id,,) \
335  static int DeclFileLine() { return __LINE__; }
336 
337 #define ClassDefInline(name,id) \
338  _ClassDefInline_(name,id,virtual,) \
339  static int DeclFileLine() { return __LINE__; }
340 
341 #define ClassDefInlineOverride(name,id) \
342  _ClassDefInline_(name,id,,override) \
343  static int DeclFileLine() { return __LINE__; }
344 
345 #define ClassDefInlineNV(name,id) \
346  _ClassDefInline_(name,id,,) \
347  static int DeclFileLine() { return __LINE__; }
348 
349 //#define _ClassDefInterp_(name,id) ClassDefInline(name,id)
350 
351 #define R__UseDummy(name) \
352  class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }
353 
354 
355 #define ClassImpUnique(name,key) \
356  namespace ROOT { \
357  TGenericClassInfo *GenerateInitInstance(const name*); \
358  namespace { \
359  static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) __attribute__((unused)) = \
360  GenerateInitInstance((name*)0x0)->SetImplFile(__FILE__, __LINE__); \
361  R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
362  } \
363  }
364 #define ClassImp(name) ClassImpUnique(name,default)
365 
366 // Macro for Namespace
367 
368 #define NamespaceImpUnique(name,key) \
369  namespace name { \
370  namespace ROOT { \
371  ::ROOT::TGenericClassInfo *GenerateInitInstance(); \
372  namespace { \
373  static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) = \
374  GenerateInitInstance()->SetImplFile(__FILE__, __LINE__); \
375  R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
376  } \
377  } \
378  }
379 #define NamespaceImp(name) NamespaceImpUnique(name,default)
380 
381 //---- ClassDefT macros for templates with one template argument ---------------
382 // ClassDefT corresponds to ClassDef
383 // ClassDefT2 goes in the same header as ClassDefT but must be
384 // outside the class scope
385 // ClassImpT corresponds to ClassImp
386 
387 
388 // This ClassDefT is stricly redundant and is kept only for
389 // backward compatibility.
390 
391 #define ClassDefT(name,id) \
392  _ClassDefOutline_(name,id,virtual,) \
393  static int DeclFileLine() { return __LINE__; }
394 
395 #define ClassDefTNV(name,id) \
396  _ClassDefOutline_(name,id,virtual,) \
397  static int DeclFileLine() { return __LINE__; }
398 
399 
400 #define ClassDefT2(name,Tmpl)
401 
402 #define templateClassImpUnique(name, key) \
403  namespace ROOT { \
404  static TNamed * \
405  _R__UNIQUE_(_NAME2_(R__dummyholder, key)) = ::ROOT::RegisterClassTemplate(_QUOTE_(name), __FILE__, __LINE__); \
406  R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyholder, key))); \
407  }
408 #define templateClassImp(name) templateClassImpUnique(name,default)
409 
410 #define ClassImpT(name,Tmpl) templateClassImp(name)
411 
412 //---- ClassDefT macros for templates with two template arguments --------------
413 // ClassDef2T2 goes in the same header as ClassDefT but must be
414 // outside the class scope
415 // ClassImp2T corresponds to ClassImpT
416 
417 #define ClassDef2T2(name,Tmpl1,Tmpl2)
418 #define ClassImp2T(name,Tmpl1,Tmpl2) templateClassImp(name)
419 
420 
421 //---- ClassDefT macros for templates with three template arguments ------------
422 // ClassDef3T2 goes in the same header as ClassDefT but must be
423 // outside the class scope
424 // ClassImp3T corresponds to ClassImpT
425 
426 #define ClassDef3T2(name,Tmpl1,Tmpl2,Tmpl3)
427 #define ClassImp3T(name,Tmpl1,Tmpl2,Tmpl3) templateClassImp(name)
428 
429 
430 //---- Macro to set the class version of non instrumented classes --------------
431 
432 #define RootClassVersion(name,VersionNumber) \
433 namespace ROOT { \
434  TGenericClassInfo *GenerateInitInstance(const name*); \
435  static Short_t _R__UNIQUE_(R__dummyVersionNumber) = \
436  GenerateInitInstance((name*)0x0)->SetVersion(VersionNumber); \
437  R__UseDummy(_R__UNIQUE_(R__dummyVersionNumber)); \
438 }
439 
440 #define RootStreamer(name,STREAMER) \
441 namespace ROOT { \
442  TGenericClassInfo *GenerateInitInstance(const name*); \
443  static Short_t _R__UNIQUE_(R__dummyStreamer) = \
444  GenerateInitInstance((name*)0x0)->SetStreamer(STREAMER); \
445  R__UseDummy(_R__UNIQUE_(R__dummyStreamer)); \
446 }
447 
448 //---- Macro to load a library into the interpreter --------------
449 // Call as R__LOAD_LIBRARY(libEvent)
450 // This macro intentionally does not take string as argument, to
451 // prevent compilation errors with complex diagnostics due to
452 // TString BAD_DO_NOT_TRY = "lib";
453 // R__LOAD_LIBRARY(BAD_DO_NOT_TRY + "BAD_DO_NOT_TRY.so") // ERROR!
454 #ifdef __CLING__
455 # define _R_PragmaStr(x) _Pragma(#x)
456 # define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(cling load ( #LIBRARY ))
457 # define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(cling add_include_path ( #PATH ))
458 # define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(cling add_library_path ( #PATH ))
459 #elif defined(R__WIN32)
460 # define _R_PragmaStr(x) __pragma(#x)
461 # define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(comment(lib, #LIBRARY))
462 # define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
463 # define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
464 #else
465 // No way to inform linker though preprocessor :-(
466 // We could even inform the user:
467 /*
468 # define R__LOAD_LIBRARY(LIBRARY) \
469  _R_PragmaStr(message "Compiler cannot handle linking against " #LIBRARY \
470  ". Use -L and -l instead.")
471 */
472 # define R__LOAD_LIBRARY(LIBRARY)
473 # define R__ADD_INCLUDE_PATH(PATH)
474 # define R__ADD_LIBRARY_PATH(PATH)
475 #endif
476 
477 // Convenience macros to disable cling pointer check.
478 #ifdef __CLING__
479 # define R__CLING_PTRCHECK(ONOFF) __attribute__((annotate("__cling__ptrcheck(" #ONOFF ")")))
480 #else
481 # define R__CLING_PTRCHECK(ONOFF)
482 #endif
483 
484 #endif
TFileMergeInfo
Definition: TFileMergeInfo.h:42
MemberStreamerFunc_t
void(* MemberStreamerFunc_t)(TBuffer &, void *, Int_t)
Definition: Rtypes.h:74
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
ROOT::Internal::TCDGIILIBase::SetName
static void SetName(const std::string &name, std::string &nameMember)
Definition: TGenericClassInfo.cxx:68
kTeal
@ kTeal
Definition: Rtypes.h:67
ROOT::Internal::DefineBehavior
const TInitBehavior * DefineBehavior(void *, void *)
Definition: TGenericClassInfo.cxx:44
ROOT::Internal::TDefaultInitBehavior::Register
virtual void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const
Definition: Rtypes.h:165
Version_t
short Version_t
Definition: RtypesCore.h:65
ROOT::ResetAfterMergeFunc_t
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:115
TIsAProxy.h
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::Name
static const char * Name()
Definition: Rtypes.h:237
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::Dictionary
static TClass * Dictionary()
Definition: Rtypes.h:235
kBUFFERSIZE
@ kBUFFERSIZE
Definition: Rtypes.h:61
ROOT::AddClass
void AddClass(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits)
Global function called by the ctor of a class's init class (see the ClassImp macro).
Definition: TClassTable.cxx:763
kGreen
@ kGreen
Definition: Rtypes.h:66
ROOT::DelFunc_t
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
VoidFuncPtr_t
void(* VoidFuncPtr_t)()
Definition: Rtypes.h:79
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::Delete
static void Delete(void *p)
Definition: Rtypes.h:218
kViolet
@ kViolet
Definition: Rtypes.h:67
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::GenerateInitInstanceLocal
::ROOT::TGenericClassInfo * GenerateInitInstanceLocal()
Definition: Rtypes.h:221
kMAXSIGNALS
@ kMAXSIGNALS
Definition: Rtypes.h:59
ROOT::RegisterClassTemplate
TNamed * RegisterClassTemplate(const char *name, const char *file, Int_t line)
Global function to register the implementation file and line of a class template (i....
Definition: TClassTable.cxx:865
kPink
@ kPink
Definition: Rtypes.h:67
Int_t
int Int_t
Definition: RtypesCore.h:45
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector
Definition: Rtypes.h:211
ROOT::NewArrFunc_t
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition: Rtypes.h:109
kOrange
@ kOrange
Definition: Rtypes.h:67
ROOT::Class_ShowMembers
void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector &)
Indirect call to the implementation of ShowMember allowing [forward] declaration with out a full defi...
Definition: TClass.cxx:538
ROOT::Internal::DefaultStreamer
void DefaultStreamer(TBuffer &R__b, const TClass *cl, void *objpointer)
Default streamer implementation used by ClassDefInline to avoid requirement to include TBuffer....
Definition: TBuffer.cxx:30
ROOT::Internal::TInitBehavior
Definition: Rtypes.h:145
TBuffer
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::fgGenericInfo
::ROOT::TGenericClassInfo * fgGenericInfo
Definition: Rtypes.h:213
ROOT::TGenericClassInfo::GetClass
TClass * GetClass()
Definition: TGenericClassInfo.cxx:231
ROOT::Internal::GetDemangledTypeName
std::string GetDemangledTypeName(const std::type_info &)
Returns a string with the demangled and normalized name for the given type.
Definition: TGenericClassInfo.cxx:30
TString
Basic string class.
Definition: TString.h:136
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
bool
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::DeleteArray
static void DeleteArray(void *p)
Definition: Rtypes.h:219
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::Destruct
static void Destruct(void *p)
Definition: Rtypes.h:220
ROOT::DirAutoAdd_t
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:113
ROOT::Internal::TCDGIILIBase
Definition: Rtypes.h:200
ROOT::Internal::TDefaultInitBehavior::Unregister
virtual void Unregister(const char *classname) const
Definition: Rtypes.h:171
ClassStreamerFunc_t
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition: Rtypes.h:72
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::Class
static TClass * Class()
Definition: Rtypes.h:236
ROOT::RemoveClass
void RemoveClass(const char *cname)
Global function called by the dtor of a class's init class (see the ClassImp macro).
Definition: TClassTable.cxx:840
ROOT::Internal::TInitBehavior::Register
virtual void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const =0
kBlack
@ kBlack
Definition: Rtypes.h:65
ROOT::MergeFunc_t
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:114
ROOT::Internal::TCDGIILIBase::SetfgIsA
static void SetfgIsA(atomic_TClass_ptr &isA, TClass *(*dictfun)())
Definition: TGenericClassInfo.cxx:76
ROOT::DelArrFunc_t
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:111
kCyan
@ kCyan
Definition: Rtypes.h:66
kMagenta
@ kMagenta
Definition: Rtypes.h:66
ROOT::AddClassAlternate
void AddClassAlternate(const char *normName, const char *alternate)
Global function called by GenerateInitInstance.
Definition: TClassTable.cxx:785
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
kWhite
@ kWhite
Definition: Rtypes.h:65
ROOT::Internal::TCDGIILIBase::SetInstance
static void SetInstance(::ROOT::TGenericClassInfo &R__instance, NewFunc_t, NewArrFunc_t, DelFunc_t, DelArrFunc_t, DesFunc_t)
Definition: TGenericClassInfo.cxx:55
Long_t
long Long_t
Definition: RtypesCore.h:54
kItimerResolution
@ kItimerResolution
Definition: Rtypes.h:62
ROOT::Internal::THashConsistencyHolder::fgHashConsistency
static Bool_t fgHashConsistency
Definition: Rtypes.h:254
ROOT::Internal::TInitBehavior::~TInitBehavior
virtual ~TInitBehavior()
Definition: Rtypes.h:151
ROOT::Internal::HasConsistentHashMember
Bool_t HasConsistentHashMember(TClass &clRef)
Return true is the Hash/RecursiveRemove setup is consistent, i.e.
Definition: TClass.cxx:7199
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
CPyCppyy::PyStrings::gName
R__EXTERN PyObject * gName
Definition: TPython.cxx:105
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::fgIsA
static atomic_TClass_ptr fgIsA
Definition: Rtypes.h:212
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:5762
kRed
@ kRed
Definition: Rtypes.h:66
line
TLine * line
Definition: entrylistblock_figure1.C:235
void
typedef void((*Func_t)())
kSpring
@ kSpring
Definition: Rtypes.h:67
RtypesCore.h
operator>>
TBuffer & operator>>(TBuffer &buf, Tmpl *&obj)
Definition: TBuffer.h:383
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
file
Definition: file.py:1
ROOT::SetClassVersion
Short_t SetClassVersion(RootClass *)
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
ROOT::TGenericClassInfo
Definition: TGenericClassInfo.h:40
ROOT::Internal::TDefaultInitBehavior::CreateClass
virtual 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) const
Definition: Rtypes.h:175
ClassConvStreamerFunc_t
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition: Rtypes.h:73
ROOT::Internal::TDefaultInitBehavior
Definition: Rtypes.h:163
name
char name[80]
Definition: TGX11.cxx:110
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34
kBlue
@ kBlue
Definition: Rtypes.h:66
TDirectory
Describe directory structure in memory.
Definition: TDirectory.h:40
ROOT::NewFunc_t
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:108
EColor
EColor
Definition: Rtypes.h:65
ROOT::ResetClassVersion
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
Definition: TClassTable.cxx:808
TClassStreamer
Definition: TClassStreamer.h:26
kGray
@ kGray
Definition: Rtypes.h:65
TCollection
Collection abstract base class.
Definition: TCollection.h:63
DictFuncPtr_t
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:80
TVirtualIsAProxy
Definition: TVirtualIsAProxy.h:27
TMemberStreamer
Definition: TMemberStreamer.h:26
ESysConstants
ESysConstants
Definition: Rtypes.h:58
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::NewArray
static void * NewArray(Long_t nElements, void *p)
Definition: Rtypes.h:216
kMAXPATHLEN
@ kMAXPATHLEN
Definition: Rtypes.h:60
ROOT::Internal::TInitBehavior::CreateClass
virtual 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) const =0
ROOT::Internal::TInitBehavior::Unregister
virtual void Unregister(const char *classname) const =0
kAzure
@ kAzure
Definition: Rtypes.h:67
kYellow
@ kYellow
Definition: Rtypes.h:66
TGenericClassInfo.h
ROOT
VSD Structures.
Definition: StringConv.hxx:21
ROOT::Internal::THashConsistencyHolder
Definition: Rtypes.h:253
operator<<
TBuffer & operator<<(TBuffer &buf, const Tmpl *obj)
Definition: TBuffer.h:399
TVirtualCollectionProxy
Definition: TVirtualCollectionProxy.h:38
atomic_TClass_ptr
std::atomic< TClass * > atomic_TClass_ptr
Definition: Rtypes.h:193
int
ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector::New
static void * New(void *p)
Definition: Rtypes.h:215