Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 TBrowser;
49class TBuffer;
50class TDirectory;
52class TObject;
53class TNamed;
54class TCollection;
55class TFileMergeInfo;
56class TString;
57
58//Moved from TSystem.
63 kItimerResolution = 10 // interval-timer resolution in ms
64};
65
66enum EColor { kWhite =0, kBlack =1, kGray =920,
67 kRed =632, kGreen =416, kBlue =600, kYellow =400, kMagenta =616, kCyan =432,
68 kOrange =800, kSpring =820, kTeal =840, kAzure =860, kViolet =880, kPink =900,
69 kGrape =100, kBrown =101, kAsh =102,
70 kP6Blue =103, kP6Yellow =104, kP6Red =105, kP6Grape=106, kP6Gray =107, kP6Violet=108,
71 kP8Blue =109, kP8Orange =110, kP8Red =111, kP8Pink =112, kP8Green =113, kP8Cyan =114, kP8Azure =115, kP8Gray =116,
72 kP10Blue =117, kP10Yellow=118, kP10Red =119, kP10Gray=120, kP10Violet=121, kP10Brown=122, kP10Orange=123, kP10Green=124, kP10Ash=125, kP10Cyan=126
73 };
74
75// There is several streamer concepts.
76class TClassStreamer; // Streamer functor for a class
77class TMemberStreamer; // Streamer functor for a data member
78typedef void (*ClassStreamerFunc_t)(TBuffer&, void*); // Streamer function for a class
79typedef void (*ClassConvStreamerFunc_t)(TBuffer&, void*, const TClass*); // Streamer function for a class with conversion.
80typedef void (*MemberStreamerFunc_t)(TBuffer&, void*, Int_t); // Streamer function for a data member
81
82// This class is used to implement proxy around collection classes.
84
85typedef void (*VoidFuncPtr_t)(); //pointer to void function
86typedef TClass* (*DictFuncPtr_t)(); //pointer to dictionary function
87// NOTE: the previous name must be changed.
88
89//--- bit manipulation ---------------------------------------------------------
90
91#define BIT(n) (1ULL << (n))
92#define SETBIT(n,i) ((n) |= BIT(i))
93#define CLRBIT(n,i) ((n) &= ~BIT(i))
94#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
95
96
97
98//---- ClassDef macros ---------------------------------------------------------
99
100typedef void (*ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient);
101class TVirtualIsAProxy;
102typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);
103
104// TBuffer.h declares and implements the following 2 operators
105template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
106template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj);
107
108// This might get used if we implement setting a class version.
109// template <class RootClass> Short_t GetClassVersion(RootClass *);
110
111namespace ROOT {
112
113 class TGenericClassInfo;
114 class TClassAlt;
115 typedef void *(*NewFunc_t)(void *);
116 typedef void *(*NewArrFunc_t)(Long_t size, void *arena);
117 typedef void (*DelFunc_t)(void *);
118 typedef void (*DelArrFunc_t)(void *);
119 typedef void (*DesFunc_t)(void *);
120 typedef void (*DirAutoAdd_t)(void *, TDirectory *);
122 typedef void (*ResetAfterMergeFunc_t)(void *, TFileMergeInfo *);
123 typedef void (*BrowseFunc_t)(const void *, TBrowser *);
124
125 template <class RootClass> Short_t SetClassVersion(RootClass *);
126
127 extern TClass *CreateClass(const char *cname, Version_t id,
128 const std::type_info &info, TVirtualIsAProxy *isa,
129 const char *dfil, const char *ifil,
130 Int_t dl, Int_t il);
131 extern void AddClass(const char *cname, Version_t id, const std::type_info &info,
133 extern void RemoveClass(const char *cname, TClass *cl);
134 extern void ResetClassVersion(TClass*, const char*, Short_t);
135 extern ROOT::TClassAlt* AddClassAlternate(const char *normName, const char *alternate);
137
138 extern TNamed *RegisterClassTemplate(const char *name,
139 const char *file, Int_t line);
140
141 extern void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector&);
142
143#if 0
144 // This function is only implemented in the dictionary file.
145 // The parameter is 'only' for overloading resolution.
146 // Used to be a template <class T> TGenericClassInfo *GenerateInitInstance(const T*);
147 template <class T> TGenericClassInfo *GetClassInfo(const T* t) {
148 TGenericClassInfo *GenerateInitInstance(const T*);
149 return CreateInitInstance(t);
150 };
151#endif
152
153 namespace Internal {
155 // This class defines the interface for the class registration and
156 // the TClass creation. To modify the default behavior, one would
157 // inherit from this class and overload ROOT::DefineBehavior().
158 // See TQObject.h and table/inc/Ttypes.h for examples.
159 public:
160 virtual ~TInitBehavior() { }
161
162 virtual void Register(const char *cname, Version_t id,
163 const std::type_info &info,
164 DictFuncPtr_t dict, Int_t pragmabits) const = 0;
165 virtual void Unregister(const char *classname, TClass *cl) const = 0;
166 virtual TClass *CreateClass(const char *cname, Version_t id,
167 const std::type_info &info, TVirtualIsAProxy *isa,
168 const char *dfil, const char *ifil,
169 Int_t dl, Int_t il) const = 0;
170 };
171
173 public:
174 void Register(const char *cname, Version_t id,
175 const std::type_info &info,
176 DictFuncPtr_t dict, Int_t pragmabits) const override {
177 ROOT::AddClass(cname, id, info, dict, pragmabits);
178 }
179
180 void Unregister(const char *classname, TClass *cl) const override {
181 ROOT::RemoveClass(classname, cl);
182 }
183
185 const std::type_info &info, TVirtualIsAProxy *isa,
186 const char *dfil, const char *ifil,
187 Int_t dl, Int_t il) const override {
188 return ROOT::CreateClass(cname, id, info, isa, dfil, ifil, dl, il);
189 }
190 };
191
192 const TInitBehavior *DefineBehavior(void * /*parent_type*/,
193 void * /*actual_type*/);
194 } // namespace Internal
195
196} // namespace ROOT
197
198// The macros below use TGenericClassInfo and TInstrumentedIsAProxy, so let's
199// ensure they are included.
200#include "TGenericClassInfo.h"
201
202typedef std::atomic<TClass*> atomic_TClass_ptr;
203
204#include "TIsAProxy.h"
205#include <string>
206
207namespace ROOT { namespace Internal {
208
210public:
211 // All implemented in TGenericClassInfo.cxx.
212 static void SetInstance(::ROOT::TGenericClassInfo& R__instance,
214 static void SetName(const std::string& name, std::string& nameMember);
215 static void SetfgIsA(atomic_TClass_ptr& isA, TClass*(*dictfun)());
216};
217
218template <typename T>
220 public TCDGIILIBase {
222 static ::ROOT::TGenericClassInfo *fgGenericInfo;
223 public:
224 static void *New(void *p) { return p ? new(p) T : new T; };
225 static void *NewArray(Long_t nElements, void *p) {
226 return p ? new(p) T[nElements] : new T[nElements]; }
227 static void Delete(void *p) { delete ((T*)p); }
228 static void DeleteArray(void *p) { delete[] ((T*)p); }
229 static void Destruct(void *p) { ((T*)p)->~T(); }
230 static ::ROOT::TGenericClassInfo *GenerateInitInstanceLocal() {
231 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy<T>(nullptr);
232 static ::ROOT::TGenericClassInfo
233 R__instance(T::Class_Name(), T::Class_Version(),
234 T::DeclFileName(), T::DeclFileLine(),
235 typeid(T), ::ROOT::Internal::DefineBehavior((T*)nullptr, (T*)nullptr),
236 &T::Dictionary, isa_proxy, 0, sizeof(T) );
238 return &R__instance;
239 }
240 // We need a reference to the template instance static member in a concrete function in order
241 // to force its instantiation (even before the function is actually run)
242 // Since we do have a reference to Dictionary (in T::Dictionary), using fgGenericInfo
243 // here will insure that it is initialized at process start or library load time.
244 static TClass *Dictionary() { fgIsA = fgGenericInfo->GetClass(); return fgIsA; }
245 static TClass *Class() { SetfgIsA(fgIsA, &Dictionary); return fgIsA; }
246 static const char* Name() {
247 static std::string gName;
248 if (gName.empty())
249 SetName(GetDemangledTypeName(typeid(T)), gName);
250 return gName.c_str();
251 }
252 };
253
254 template<typename T>
256 template<typename T>
259 };
260
261 template <typename T>
265
266 template <typename T>
268
269 void DefaultStreamer(TBuffer &R__b, const TClass *cl, void *objpointer);
272}} // namespace ROOT::Internal
273
274
275/// Common part being called both by \_ClassDefOutline\_ and \_ClassDefInline\_.
276/// \note DeclFileLine() is not part of it, since Cling uses that as trigger for
277/// associating as class title the comment string found right after the macro.
278#define _ClassDefBase_(name, id, virtual_keyword, overrd) \
279private: \
280 static_assert(std::is_integral<decltype(id)>::value, \
281 "ClassDef(Inline) macro: the specified class version number is not an integer."); \
282 /** \cond HIDDEN_SYMBOLS */ virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd \
283 { \
284 static std::atomic<UChar_t> recurseBlocker(0); \
285 if (R__likely(recurseBlocker >= 2)) { \
286 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
287 } else if (recurseBlocker == 1) { \
288 return false; \
289 } else if (recurseBlocker++ == 0) { \
290 ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = \
291 ::ROOT::Internal::HasConsistentHashMember(_QUOTE_(name)) || \
292 ::ROOT::Internal::HasConsistentHashMember(*IsA()); \
293 ++recurseBlocker; \
294 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
295 } \
296 return false; /* unreachable */ \
297 } /** \endcond */ \
298 \
299public: \
300 /** \return Version of this class */ static constexpr Version_t Class_Version() { return id; } \
301 /** \return TClass describing current object */ virtual_keyword TClass *IsA() const overrd \
302 { return name::Class(); } \
303 /** \cond HIDDEN_SYMBOLS */ virtual_keyword void ShowMembers(TMemberInspector &insp) const overrd \
304 { \
305 ::ROOT::Class_ShowMembers(name::Class(), this, insp); \
306 } /** \endcond */ \
307 void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
308 /** \return Name of the file containing the class declaration */ static const char *DeclFileName() { return __FILE__; }
309
310#define _ClassDefOutline_(name,id, virtual_keyword, overrd) \
311 _ClassDefBase_(name,id, virtual_keyword, overrd) \
312private: \
313 /** \cond HIDDEN_SYMBOLS \brief Pointer holding the address of the TClass describing this class */ \
314 static atomic_TClass_ptr fgIsA; /** \endcond */ \
315public: \
316 /** \cond HIDDEN_SYMBOLS \deprecated */ static int ImplFileLine(); /** \endcond */ \
317 /** \cond HIDDEN_SYMBOLS \deprecated */ static const char *ImplFileName(); /** \endcond */ \
318 /** \return Name of this class */ static const char *Class_Name(); \
319 /** \cond HIDDEN_SYMBOLS */ static TClass *Dictionary(); /** \endcond */ \
320 /** \return TClass describing this class */ static TClass *Class(); \
321 virtual_keyword void Streamer(TBuffer&) overrd;
322
323#define _ClassDefInline_(name, id, virtual_keyword, overrd) \
324 _ClassDefBase_(name, id, virtual_keyword, overrd) public : \
325 /** \cond HIDDEN_SYMBOLS \deprecated */ static int ImplFileLine() { return -1; } /** \endcond */ \
326 /** \cond HIDDEN_SYMBOLS \deprecated */ static const char *ImplFileName() { return nullptr; } /** \endcond */\
327 /** \return Name of this class */ static const char *Class_Name() \
328 { \
329 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Name(); \
330 } \
331 /** \cond HIDDEN_SYMBOLS */ static TClass *Dictionary() \
332 { \
333 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Dictionary(); \
334 } /** \endcond */ \
335 /** \return TClass describing this class */ static TClass *Class() \
336 { \
337 return ::ROOT::Internal::ClassDefGenerateInitInstanceLocalInjector<name>::Class(); \
338 } \
339 virtual_keyword void Streamer(TBuffer &R__b) overrd \
340 { \
341 ::ROOT::Internal::DefaultStreamer(R__b, name::Class(), this); \
342 }
343
344#define ClassDef(name,id) \
345 _ClassDefOutline_(name,id,virtual,) \
346 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
347
348#define ClassDefOverride(name,id) \
349 _ClassDefOutline_(name,id,,override) \
350 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
351
352#define ClassDefNV(name,id) \
353 _ClassDefOutline_(name,id,,) \
354 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
355
356#define ClassDefInline(name,id) \
357 _ClassDefInline_(name,id,virtual,) \
358 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
359
360#define ClassDefInlineOverride(name,id) \
361 _ClassDefInline_(name,id,,override) \
362 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
363
364#define ClassDefInlineNV(name,id) \
365 _ClassDefInline_(name,id,,) \
366 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
367
368//#define _ClassDefInterp_(name,id) ClassDefInline(name,id)
369
370#define R__UseDummy(name) \
371 class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }
372
373#define ClassImpUnique(name, key)
374
375/// \deprecated
376#define ClassImp(name) ClassImpUnique(name,default)
377
378/// Macro for Namespace
379#define NamespaceImpUnique(name, key)
380
381#define NamespaceImp(name) NamespaceImpUnique(name,default)
382
383//---- ClassDefT macros for templates with one template argument ---------------
384// ClassDefT corresponds to ClassDef
385// ClassDefT2 goes in the same header as ClassDefT but must be
386// outside the class scope
387// ClassImpT corresponds to ClassImp
388
389
390/// This ClassDefT is strictly redundant and is kept only for
391/// backward compatibility. \deprecated
392#define ClassDefT(name,id) \
393 _ClassDefOutline_(name,id,virtual,) \
394 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
395
396#define ClassDefTNV(name,id) \
397 _ClassDefOutline_(name,id,virtual,) \
398 /** \cond HIDDEN_SYMBOLS */ static int DeclFileLine() { return __LINE__; } /** \endcond */
399
400
401#define ClassDefT2(name,Tmpl)
402
403#define templateClassImpUnique(name, key)
404
405#define templateClassImp(name) templateClassImpUnique(name,default)
406
407#define ClassImpT(name,Tmpl) templateClassImp(name)
408
409//---- ClassDefT macros for templates with two template arguments --------------
410// ClassDef2T2 goes in the same header as ClassDefT but must be
411// outside the class scope
412// ClassImp2T corresponds to ClassImpT
413
414#define ClassDef2T2(name,Tmpl1,Tmpl2)
415#define ClassImp2T(name,Tmpl1,Tmpl2) templateClassImp(name)
416
417
418//---- ClassDefT macros for templates with three template arguments ------------
419// ClassDef3T2 goes in the same header as ClassDefT but must be
420// outside the class scope
421// ClassImp3T corresponds to ClassImpT
422
423#define ClassDef3T2(name,Tmpl1,Tmpl2,Tmpl3)
424#define ClassImp3T(name,Tmpl1,Tmpl2,Tmpl3) templateClassImp(name)
425
426
427//---- Macro to set the class version of non instrumented classes --------------
428
429#define RootClassVersion(name,VersionNumber) \
430namespace ROOT { /** \cond HIDDEN_SYMBOLS */ \
431 TGenericClassInfo *GenerateInitInstance(const name*); /** \endcond */ \
432 /** \cond HIDDEN_SYMBOLS */ \
433 static Short_t _R__UNIQUE_(R__dummyVersionNumber) = \
434 GenerateInitInstance((name*)0x0)->SetVersion(VersionNumber); \
435 /** \endcond */ \
436 R__UseDummy(_R__UNIQUE_(R__dummyVersionNumber)); \
437}
438
439#define RootStreamer(name,STREAMER) \
440namespace ROOT { \
441 /** \cond HIDDEN_SYMBOLS */ \
442 TGenericClassInfo *GenerateInitInstance(const name*); /** \endcond */ \
443 /** \cond HIDDEN_SYMBOLS */ \
444 static Short_t _R__UNIQUE_(R__dummyStreamer) = \
445 GenerateInitInstance((name*)0x0)->SetStreamer(STREAMER); \
446 /** \endcond */ \
447 R__UseDummy(_R__UNIQUE_(R__dummyStreamer)); \
448}
449
450//---- Macro to load a library into the interpreter --------------
451// Call as R__LOAD_LIBRARY(libEvent)
452// This macro intentionally does not take string as argument, to
453// prevent compilation errors with complex diagnostics due to
454// TString BAD_DO_NOT_TRY = "lib";
455// R__LOAD_LIBRARY(BAD_DO_NOT_TRY + "BAD_DO_NOT_TRY.so") // ERROR!
456#ifdef __CLING__
457# define _R_PragmaStr(x) _Pragma(#x)
458# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(cling load ( #LIBRARY ))
459# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(cling add_include_path ( #PATH ))
460# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(cling add_library_path ( #PATH ))
461#elif defined(R__WIN32)
462# define _R_PragmaStr(x) __pragma(#x)
463# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(comment(lib, #LIBRARY))
464# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
465# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
466#else
467// No way to inform linker though preprocessor :-(
468// We could even inform the user:
469/*
470# define R__LOAD_LIBRARY(LIBRARY) \
471 _R_PragmaStr(message "Compiler cannot handle linking against " #LIBRARY \
472 ". Use -L and -l instead.")
473*/
474# define R__LOAD_LIBRARY(LIBRARY)
475# define R__ADD_INCLUDE_PATH(PATH)
476# define R__ADD_LIBRARY_PATH(PATH)
477#endif
478
479// Convenience macros to disable cling pointer check.
480#ifdef __CLING__
481# define R__CLING_PTRCHECK(ONOFF) __attribute__((annotate("__cling__ptrcheck(" #ONOFF ")")))
482#else
483# define R__CLING_PTRCHECK(ONOFF)
484#endif
485
486#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:69
TClass *(* DictFuncPtr_t)()
Definition Rtypes.h:86
void(* VoidFuncPtr_t)()
Definition Rtypes.h:85
TBuffer & operator<<(TBuffer &buf, const Tmpl *obj)
Definition TBuffer.h:397
void(* MemberStreamerFunc_t)(TBuffer &, void *, Int_t)
Definition Rtypes.h:80
void(* ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient)
Definition Rtypes.h:100
EColor
Definition Rtypes.h:66
@ kP8Cyan
Definition Rtypes.h:71
@ kTeal
Definition Rtypes.h:68
@ kP8Red
Definition Rtypes.h:71
@ kGray
Definition Rtypes.h:66
@ kAsh
Definition Rtypes.h:69
@ kP6Red
Definition Rtypes.h:70
@ kP8Pink
Definition Rtypes.h:71
@ kP10Violet
Definition Rtypes.h:72
@ kP10Orange
Definition Rtypes.h:72
@ kBrown
Definition Rtypes.h:69
@ kP6Grape
Definition Rtypes.h:70
@ kPink
Definition Rtypes.h:68
@ kP8Azure
Definition Rtypes.h:71
@ kRed
Definition Rtypes.h:67
@ kGrape
Definition Rtypes.h:69
@ kP6Gray
Definition Rtypes.h:70
@ kOrange
Definition Rtypes.h:68
@ kP8Gray
Definition Rtypes.h:71
@ kP10Red
Definition Rtypes.h:72
@ kBlack
Definition Rtypes.h:66
@ kP10Brown
Definition Rtypes.h:72
@ kP10Cyan
Definition Rtypes.h:72
@ kGreen
Definition Rtypes.h:67
@ kMagenta
Definition Rtypes.h:67
@ kP10Ash
Definition Rtypes.h:72
@ kWhite
Definition Rtypes.h:66
@ kP10Green
Definition Rtypes.h:72
@ kP6Yellow
Definition Rtypes.h:70
@ kCyan
Definition Rtypes.h:67
@ kBlue
Definition Rtypes.h:67
@ kP10Gray
Definition Rtypes.h:72
@ kAzure
Definition Rtypes.h:68
@ kYellow
Definition Rtypes.h:67
@ kP8Orange
Definition Rtypes.h:71
@ kP8Green
Definition Rtypes.h:71
@ kP8Blue
Definition Rtypes.h:71
@ kViolet
Definition Rtypes.h:68
@ kP6Violet
Definition Rtypes.h:70
@ kP10Yellow
Definition Rtypes.h:72
@ kSpring
Definition Rtypes.h:68
@ kP10Blue
Definition Rtypes.h:72
@ kP6Blue
Definition Rtypes.h:70
TBuffer & operator>>(TBuffer &buf, Tmpl *&obj)
Definition TBuffer.h:381
std::atomic< TClass * > atomic_TClass_ptr
Definition Rtypes.h:202
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition Rtypes.h:78
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition Rtypes.h:79
ESysConstants
Definition Rtypes.h:59
@ kItimerResolution
Definition Rtypes.h:63
@ kMAXSIGNALS
Definition Rtypes.h:60
@ kMAXPATHLEN
Definition Rtypes.h:61
@ kBUFFERSIZE
Definition Rtypes.h:62
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
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 void * NewArray(Long_t nElements, void *p)
Definition Rtypes.h:225
::ROOT::TGenericClassInfo * GenerateInitInstanceLocal()
Definition Rtypes.h:230
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)())
void Unregister(const char *classname, TClass *cl) const override
Definition Rtypes.h:180
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:184
void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const override
Definition Rtypes.h:174
virtual void Unregister(const char *classname, TClass *cl) const =0
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
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
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:84
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:41
Basic string class.
Definition TString.h:139
Defines a common interface to inspect/change the contents of an object that represents a collection.
TLine * line
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:7574
std::string GetDemangledTypeName(const std::type_info &t)
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition Rtypes.h:120
ROOT::TClassAlt * AddClassAlternate(const char *normName, const char *alternate)
Global function called by GenerateInitInstance.
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition Rtypes.h:122
void(* DesFunc_t)(void *)
Definition Rtypes.h:119
void RemoveClass(const char *cname, TClass *cl)
Global function called by the dtor of a class's init class (see the ClassImp macro).
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:6017
void(* DelFunc_t)(void *)
Definition Rtypes.h:117
void(* BrowseFunc_t)(const void *, TBrowser *)
Definition Rtypes.h:123
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:116
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:613
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:118
void *(* NewFunc_t)(void *)
Definition Rtypes.h:115
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition Rtypes.h:121
void RemoveClassAlternate(ROOT::TClassAlt *)