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
47class TClass;
48class TBuffer;
49class TDirectory;
51class TObject;
52class TNamed;
53class TCollection;
54class TFileMergeInfo;
55class TString;
56
57//Moved from TSystem.
62 kItimerResolution = 10 // interval-timer resolution in ms
63};
64
65enum 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.
70class TClassStreamer; // Streamer functor for a class
71class TMemberStreamer; // Streamer functor for a data member
72typedef void (*ClassStreamerFunc_t)(TBuffer&, void*); // Streamer function for a class
73typedef void (*ClassConvStreamerFunc_t)(TBuffer&, void*, const TClass*); // Streamer function for a class with conversion.
74typedef 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
79typedef void (*VoidFuncPtr_t)(); //pointer to void function
80typedef 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
94typedef void (*ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient);
96typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);
97
98// TBuffer.h declares and implements the following 2 operators
99template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
100template <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
105namespace 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 *);
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 void Register(const char *cname, Version_t id,
166 const std::type_info &info,
167 DictFuncPtr_t dict, Int_t pragmabits) const override {
168 ROOT::AddClass(cname, id, info, dict, pragmabits);
169 }
170
171 void Unregister(const char *classname) const override {
172 ROOT::RemoveClass(classname);
173 }
174
176 const std::type_info &info, TVirtualIsAProxy *isa,
177 const char *dfil, const char *ifil,
178 Int_t dl, Int_t il) const override {
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
193typedef std::atomic<TClass*> atomic_TClass_ptr;
194
195#include "TIsAProxy.h"
196#include <string>
197
198namespace ROOT { namespace Internal {
199
201public:
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
209template <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())
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 being called both by \_ClassDefOutline\_ and \_ClassDefInline\_.
267/// \note DeclFileLine() is not part of it, since Cling uses that as trigger for
268/// associating as class title the comment string found right after the macro.
269#define _ClassDefBase_(name, id, virtual_keyword, overrd) \
270private: \
271 static_assert(std::is_integral<decltype(id)>::value, \
272 "ClassDef(Inline) macro: the specified class version number is not an integer."); \
273 /** \cond HIDDEN_SYMBOLS */ virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd \
274 { \
275 static std::atomic<UChar_t> recurseBlocker(0); \
276 if (R__likely(recurseBlocker >= 2)) { \
277 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
278 } else if (recurseBlocker == 1) { \
279 return false; \
280 } else if (recurseBlocker++ == 0) { \
281 ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = \
282 ::ROOT::Internal::HasConsistentHashMember(_QUOTE_(name)) || \
283 ::ROOT::Internal::HasConsistentHashMember(*IsA()); \
284 ++recurseBlocker; \
285 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
286 } \
287 return false; /* unreacheable */ \
288 } /** \endcond */ \
289 \
290public: \
291 /** \return Version of this class */ static Version_t Class_Version() { return id; } \
292 /** \return TClass describing current object */ virtual_keyword TClass *IsA() const overrd \
293 { return name::Class(); } \
294 /** \cond HIDDEN_SYMBOLS */ virtual_keyword void ShowMembers(TMemberInspector &insp) const overrd \
295 { \
296 ::ROOT::Class_ShowMembers(name::Class(), this, insp); \
297 } /** \endcond */ \
298 void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
299 /** \return Name of the file containing the class declaration */ static const char *DeclFileName() { return __FILE__; }
300
301#define _ClassDefOutline_(name,id, virtual_keyword, overrd) \
302 _ClassDefBase_(name,id, virtual_keyword, overrd) \
303private: \
304 /** \cond HIDDEN_SYMBOLS \brief Pointer holding the address of the TClass describing this class */ \
305 static atomic_TClass_ptr fgIsA; /** \endcond */ \
306public: \
307 /** \cond HIDDEN_SYMBOLS \deprecated */ static int ImplFileLine(); /** \endcond */ \
308 /** \cond HIDDEN_SYMBOLS \deprecated */ static const char *ImplFileName(); /** \endcond */ \
309 /** \return Name of this class */ static const char *Class_Name(); \
310 /** \cond HIDDEN_SYMBOLS */ static TClass *Dictionary(); /** \endcond */ \
311 /** \return TClass describing this class */ static TClass *Class(); \
312 virtual_keyword void Streamer(TBuffer&) overrd;
313
314#define _ClassDefInline_(name, id, virtual_keyword, overrd) \
315 _ClassDefBase_(name, id, virtual_keyword, overrd) public : \
316 /** \cond HIDDEN_SYMBOLS \deprecated */ static int ImplFileLine() { return -1; } /** \endcond */ \
317 /** \cond HIDDEN_SYMBOLS \deprecated */ static const char *ImplFileName() { return 0; } /** \endcond */ \
318 /** \return Name of this class */ static const char *Class_Name() \
319 { \
320 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Name(); \
321 } \
322 /** \cond HIDDEN_SYMBOLS */ static TClass *Dictionary() \
323 { \
324 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Dictionary(); \
325 } /** \endcond */ \
326 /** \return TClass describing this class */ static TClass *Class() \
327 { \
328 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Class(); \
329 } \
330 virtual_keyword void Streamer(TBuffer &R__b) overrd \
331 { \
332 ::ROOT::Internal::DefaultStreamer(R__b, name::Class(), this); \
333 }
334
335#define ClassDef(name,id) \
336 _ClassDefOutline_(name,id,virtual,) \
337 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
338
339#define ClassDefOverride(name,id) \
340 _ClassDefOutline_(name,id,,override) \
341 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
342
343#define ClassDefNV(name,id) \
344 _ClassDefOutline_(name,id,,) \
345 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
346
347#define ClassDefInline(name,id) \
348 _ClassDefInline_(name,id,virtual,) \
349 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
350
351#define ClassDefInlineOverride(name,id) \
352 _ClassDefInline_(name,id,,override) \
353 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
354
355#define ClassDefInlineNV(name,id) \
356 _ClassDefInline_(name,id,,) \
357 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
358
359//#define _ClassDefInterp_(name,id) ClassDefInline(name,id)
360
361#define R__UseDummy(name) \
362 class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }
363
364#define ClassImpUnique(name,key) \
365 namespace ROOT { \
366 /** \cond HIDDEN_SYMBOLS */ TGenericClassInfo *GenerateInitInstance(const name*); /** \endcond */ \
367 namespace { \
368 static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) __attribute__((unused)) = \
369 GenerateInitInstance((name*)0x0)->SetImplFile(__FILE__, __LINE__); \
370 R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
371 } \
372 }
373
374/// \deprecated
375#define ClassImp(name) ClassImpUnique(name,default)
376
377/// Macro for Namespace
378#define NamespaceImpUnique(name,key) \
379 namespace name { \
380 namespace ROOTDict { \
381 /** \cond HIDDEN_SYMBOLS */ \
382 ::ROOT::TGenericClassInfo *GenerateInitInstance(); /** \endcond */ \
383 namespace { \
384 static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) = \
385 GenerateInitInstance()->SetImplFile(__FILE__, __LINE__); \
386 R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
387 } \
388 } \
389 }
390
391#define NamespaceImp(name) NamespaceImpUnique(name,default)
392
393//---- ClassDefT macros for templates with one template argument ---------------
394// ClassDefT corresponds to ClassDef
395// ClassDefT2 goes in the same header as ClassDefT but must be
396// outside the class scope
397// ClassImpT corresponds to ClassImp
398
399
400/// This ClassDefT is stricly redundant and is kept only for
401/// backward compatibility. \deprecated
402#define ClassDefT(name,id) \
403 _ClassDefOutline_(name,id,virtual,) \
404 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
405
406#define ClassDefTNV(name,id) \
407 _ClassDefOutline_(name,id,virtual,) \
408 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
409
410
411#define ClassDefT2(name,Tmpl)
412
413#define templateClassImpUnique(name, key) \
414 namespace ROOT { \
415 /** \cond HIDDEN_SYMBOLS */ static TNamed * \
416 _R__UNIQUE_(_NAME2_(R__dummyholder, key)) = ::ROOT::RegisterClassTemplate(_QUOTE_(name), __FILE__, __LINE__); \
417 /** \endcond */ \
418 R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyholder, key))); \
419 }
420#define templateClassImp(name) templateClassImpUnique(name,default)
421
422#define ClassImpT(name,Tmpl) templateClassImp(name)
423
424//---- ClassDefT macros for templates with two template arguments --------------
425// ClassDef2T2 goes in the same header as ClassDefT but must be
426// outside the class scope
427// ClassImp2T corresponds to ClassImpT
428
429#define ClassDef2T2(name,Tmpl1,Tmpl2)
430#define ClassImp2T(name,Tmpl1,Tmpl2) templateClassImp(name)
431
432
433//---- ClassDefT macros for templates with three template arguments ------------
434// ClassDef3T2 goes in the same header as ClassDefT but must be
435// outside the class scope
436// ClassImp3T corresponds to ClassImpT
437
438#define ClassDef3T2(name,Tmpl1,Tmpl2,Tmpl3)
439#define ClassImp3T(name,Tmpl1,Tmpl2,Tmpl3) templateClassImp(name)
440
441
442//---- Macro to set the class version of non instrumented classes --------------
443
444#define RootClassVersion(name,VersionNumber) \
445namespace ROOT { /** \cond HIDDEN_SYMBOLS */ \
446 TGenericClassInfo *GenerateInitInstance(const name*); /** \endcond */ \
447 /** \cond HIDDEN_SYMBOLS */ \
448 static Short_t _R__UNIQUE_(R__dummyVersionNumber) = \
449 GenerateInitInstance((name*)0x0)->SetVersion(VersionNumber); \
450 /** \endcond */ \
451 R__UseDummy(_R__UNIQUE_(R__dummyVersionNumber)); \
452}
453
454#define RootStreamer(name,STREAMER) \
455namespace ROOT { \
456 /** \cond HIDDEN_SYMBOLS */ \
457 TGenericClassInfo *GenerateInitInstance(const name*); /** \endcond */ \
458 /** \cond HIDDEN_SYMBOLS */ \
459 static Short_t _R__UNIQUE_(R__dummyStreamer) = \
460 GenerateInitInstance((name*)0x0)->SetStreamer(STREAMER); \
461 /** \endcond */ \
462 R__UseDummy(_R__UNIQUE_(R__dummyStreamer)); \
463}
464
465//---- Macro to load a library into the interpreter --------------
466// Call as R__LOAD_LIBRARY(libEvent)
467// This macro intentionally does not take string as argument, to
468// prevent compilation errors with complex diagnostics due to
469// TString BAD_DO_NOT_TRY = "lib";
470// R__LOAD_LIBRARY(BAD_DO_NOT_TRY + "BAD_DO_NOT_TRY.so") // ERROR!
471#ifdef __CLING__
472# define _R_PragmaStr(x) _Pragma(#x)
473# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(cling load ( #LIBRARY ))
474# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(cling add_include_path ( #PATH ))
475# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(cling add_library_path ( #PATH ))
476#elif defined(R__WIN32)
477# define _R_PragmaStr(x) __pragma(#x)
478# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(comment(lib, #LIBRARY))
479# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
480# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
481#else
482// No way to inform linker though preprocessor :-(
483// We could even inform the user:
484/*
485# define R__LOAD_LIBRARY(LIBRARY) \
486 _R_PragmaStr(message "Compiler cannot handle linking against " #LIBRARY \
487 ". Use -L and -l instead.")
488*/
489# define R__LOAD_LIBRARY(LIBRARY)
490# define R__ADD_INCLUDE_PATH(PATH)
491# define R__ADD_LIBRARY_PATH(PATH)
492#endif
493
494// Convenience macros to disable cling pointer check.
495#ifdef __CLING__
496# define R__CLING_PTRCHECK(ONOFF) __attribute__((annotate("__cling__ptrcheck(" #ONOFF ")")))
497#else
498# define R__CLING_PTRCHECK(ONOFF)
499#endif
500
501#endif
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
int Int_t
Definition: RtypesCore.h:45
short Version_t
Definition: RtypesCore.h:65
long Long_t
Definition: RtypesCore.h:54
short Short_t
Definition: RtypesCore.h:39
long long Long64_t
Definition: RtypesCore.h:80
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:80
void(* VoidFuncPtr_t)()
Definition: Rtypes.h:79
TBuffer & operator<<(TBuffer &buf, const Tmpl *obj)
Definition: TBuffer.h:399
void(* MemberStreamerFunc_t)(TBuffer &, void *, Int_t)
Definition: Rtypes.h:74
void(* ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient)
Definition: Rtypes.h:94
EColor
Definition: Rtypes.h:65
@ kTeal
Definition: Rtypes.h:67
@ kGray
Definition: Rtypes.h:65
@ kPink
Definition: Rtypes.h:67
@ kRed
Definition: Rtypes.h:66
@ kOrange
Definition: Rtypes.h:67
@ kBlack
Definition: Rtypes.h:65
@ kGreen
Definition: Rtypes.h:66
@ kMagenta
Definition: Rtypes.h:66
@ kWhite
Definition: Rtypes.h:65
@ kCyan
Definition: Rtypes.h:66
@ kBlue
Definition: Rtypes.h:66
@ kAzure
Definition: Rtypes.h:67
@ kYellow
Definition: Rtypes.h:66
@ kViolet
Definition: Rtypes.h:67
@ kSpring
Definition: Rtypes.h:67
TBuffer & operator>>(TBuffer &buf, Tmpl *&obj)
Definition: TBuffer.h:383
std::atomic< TClass * > atomic_TClass_ptr
Definition: Rtypes.h:193
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition: Rtypes.h:72
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition: Rtypes.h:73
ESysConstants
Definition: Rtypes.h:58
@ kItimerResolution
Definition: Rtypes.h:62
@ kMAXSIGNALS
Definition: Rtypes.h:59
@ kMAXPATHLEN
Definition: Rtypes.h:60
@ kBUFFERSIZE
Definition: Rtypes.h:61
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char cname
char name[80]
Definition: TGX11.cxx:110
static const char * Class_Name()
static const char * DeclFileName()
Definition: TStringLong.h:20
static Version_t Class_Version()
Definition: TStringLong.h:20
static void * NewArray(Long_t nElements, void *p)
Definition: Rtypes.h:216
::ROOT::TGenericClassInfo * GenerateInitInstanceLocal()
Definition: Rtypes.h:221
static void SetInstance(::ROOT::TGenericClassInfo &R__instance, NewFunc_t, NewArrFunc_t, DelFunc_t, DelArrFunc_t, DesFunc_t)
static void SetName(const std::string &name, std::string &nameMember)
static void SetfgIsA(atomic_TClass_ptr &isA, TClass *(*dictfun)())
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 override
Definition: Rtypes.h:175
void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const override
Definition: Rtypes.h:165
void Unregister(const char *classname) const override
Definition: Rtypes.h:171
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
virtual void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const =0
virtual void Unregister(const char *classname) const =0
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
Collection abstract base class.
Definition: TCollection.h:65
Describe directory structure in memory.
Definition: TDirectory.h:45
Abstract base class for accessing the data-members of a class.
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
TLine * line
R__EXTERN PyObject * gName
Definition: TPython.cxx:105
void(off) SmallVectorTemplateBase< T
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
const TInitBehavior * DefineBehavior(void *, void *)
Bool_t HasConsistentHashMember(TClass &clRef)
Return true is the Hash/RecursiveRemove setup is consistent, i.e.
Definition: TClass.cxx:7359
std::string GetDemangledTypeName(const std::type_info &t)
double T(double x)
Definition: ChebyshevPol.h:34
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:113
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:115
void(* DesFunc_t)(void *)
Definition: Rtypes.h:112
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:5857
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
void AddClassAlternate(const char *normName, const char *alternate)
Global function called by GenerateInitInstance.
void RemoveClass(const char *cname)
Global function called by the dtor of a class's init class (see the ClassImp macro).
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).
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....
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition: Rtypes.h:109
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:546
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
Short_t SetClassVersion(RootClass *)
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:111
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:108
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:114
Definition: file.py:1