Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TGenericClassInfo.cxx
Go to the documentation of this file.
1// @(#)root/meta:$Id$
2// Author: Philippe Canal 08/05/2002
3
4/*************************************************************************
5 * Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and al. *
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#include "TROOT.h"
13#include "TClass.h"
14#include "TClassEdit.h"
16#include "TStreamer.h"
17#include "TVirtualIsAProxy.h"
20#include "TSchemaRule.h"
21#include "TSchemaRuleSet.h"
22#include "TError.h"
23#include "TVirtualMutex.h"
24#include "TInterpreter.h"
25#include "TClassTable.h"
26
27namespace ROOT {
28namespace Internal {
29
30 std::string GetDemangledTypeName(const std::type_info &t)
31 {
32 int status = 0;
33 char *name = TClassEdit::DemangleName(t.name(), status);
34
35 if (!name || status != 0)
36 return "";
37
38 std::string ret;
40 free(name);
41 return ret;
42 }
43
44 const TInitBehavior *DefineBehavior(void * /*parent_type*/,
45 void * /*actual_type*/)
46 {
47
48 // This function loads the default behavior for the
49 // loading of classes.
50
51 static TDefaultInitBehavior theDefault;
52 return &theDefault;
53 }
54
55 void TCDGIILIBase::SetInstance(::ROOT::TGenericClassInfo& R__instance,
56 NewFunc_t New, NewArrFunc_t NewArray,
57 DelFunc_t Delete, DelArrFunc_t DeleteArray,
58 DesFunc_t Destruct) {
60 R__instance.SetNew(New);
61 R__instance.SetNewArray(NewArray);
62 R__instance.SetDelete(Delete);
63 R__instance.SetDeleteArray(DeleteArray);
64 R__instance.SetDestructor(Destruct);
65 R__instance.SetImplFile("", -1);
66 }
67
68 void TCDGIILIBase::SetName(const std::string& name,
69 std::string& nameMember) {
71 if (nameMember.empty()) {
73 }
74 }
75
77 if (!isA.load()) {
79 dictfun();
80 }
81 }
82} // Internal
83
84
85 TGenericClassInfo::TGenericClassInfo(const char *fullClassname,
86 const char *declFileName, Int_t declFileLine,
87 const std::type_info &info, const Internal::TInitBehavior *action,
88 DictFuncPtr_t dictionary,
89 TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof)
90 : fAction(action), fClass(nullptr), fClassName(fullClassname),
91 fDeclFileName(declFileName), fDeclFileLine(declFileLine),
92 fDictionary(dictionary), fInfo(info),
93 fImplFileName(nullptr), fImplFileLine(0),
94 fIsA(isa),
95 fVersion(1),
96 fMerge(nullptr),fResetAfterMerge(nullptr),fNew(nullptr),fNewArray(nullptr),fDelete(nullptr),fDeleteArray(nullptr),fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamer(nullptr),
97 fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fCollectionProxy(nullptr), fSizeof(sizof), fPragmaBits(pragmabits),
98 fCollectionProxyInfo(nullptr), fCollectionStreamerInfo(nullptr)
99 {
100 // Constructor.
101
102 Init(pragmabits);
103 }
104
105 TGenericClassInfo::TGenericClassInfo(const char *fullClassname, Int_t version,
106 const char *declFileName, Int_t declFileLine,
107 const std::type_info &info, const Internal::TInitBehavior *action,
108 DictFuncPtr_t dictionary,
109 TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof)
110 : fAction(action), fClass(nullptr), fClassName(fullClassname),
111 fDeclFileName(declFileName), fDeclFileLine(declFileLine),
112 fDictionary(dictionary), fInfo(info),
113 fImplFileName(nullptr), fImplFileLine(0),
114 fIsA(isa),
115 fVersion(version),
116 fMerge(nullptr),fResetAfterMerge(nullptr),fNew(nullptr),fNewArray(nullptr),fDelete(nullptr),fDeleteArray(nullptr),fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamer(nullptr),
117 fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fCollectionProxy(nullptr), fSizeof(sizof), fPragmaBits(pragmabits),
118 fCollectionProxyInfo(nullptr), fCollectionStreamerInfo(nullptr)
119
120 {
121 // Constructor with version number and no showmembers.
122
123 Init(pragmabits);
124 }
125
126 class TForNamespace {}; // Dummy class to give a typeid to namespace (See also TClassTable.cc)
127
128 TGenericClassInfo::TGenericClassInfo(const char *fullClassname, Int_t version,
129 const char *declFileName, Int_t declFileLine,
130 const Internal::TInitBehavior *action,
131 DictFuncPtr_t dictionary, Int_t pragmabits)
132 : fAction(action), fClass(nullptr), fClassName(fullClassname),
133 fDeclFileName(declFileName), fDeclFileLine(declFileLine),
134 fDictionary(dictionary), fInfo(typeid(TForNamespace)),
135 fImplFileName(nullptr), fImplFileLine(0),
136 fIsA(nullptr),
137 fVersion(version),
138 fMerge(nullptr),fResetAfterMerge(nullptr),fNew(nullptr),fNewArray(nullptr),fDelete(nullptr),fDeleteArray(nullptr),fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamer(nullptr),
139 fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fCollectionProxy(nullptr), fSizeof(0), fPragmaBits(pragmabits),
140 fCollectionProxyInfo(nullptr), fCollectionStreamerInfo(nullptr)
141
142 {
143 // Constructor for namespace
144
145 Init(pragmabits);
146 }
147
148 /* TGenericClassInfo::TGenericClassInfo(const TGenericClassInfo& gci) :
149 fAction(gci.fAction),
150 fClass(gci.fClass),
151 fClassName(gci.fClassName),
152 fDeclFileName(gci.fDeclFileName),
153 fDeclFileLine(gci.fDeclFileLine),
154 fDictionary(gci.fDictionary),
155 fInfo(gci.fInfo),
156 fImplFileName(gci.fImplFileName),
157 fImplFileLine(gci.fImplFileLine),
158 fIsA(gci.fIsA),
159 fVersion(gci.fVersion),
160 fNew(gci.fNew),
161 fNewArray(gci.fNewArray),
162 fDelete(gci.fDelete),
163 fDeleteArray(gci.fDeleteArray),
164 fDestructor(gci.fDestructor),
165 fStreamer(gci.fStreamer),
166 fCollectionProxy(gci.fCollectionProxy),
167 fSizeof(gci.fSizeof)
168 { }
169
170 TGenericClassInfo& TGenericClassInfo::operator=(const TGenericClassInfo& gci)
171 {
172 if(this!=&gci) {
173 fAction=gci.fAction;
174 fClass=gci.fClass;
175 fClassName=gci.fClassName;
176 fDeclFileName=gci.fDeclFileName;
177 fDeclFileLine=gci.fDeclFileLine;
178 fDictionary=gci.fDictionary;
179 fInfo=gci.fInfo;
180 fImplFileName=gci.fImplFileName;
181 fImplFileLine=gci.fImplFileLine;
182 fIsA=gci.fIsA;
183 fVersion=gci.fVersion;
184 fNew=gci.fNew;
185 fNewArray=gci.fNewArray;
186 fDelete=gci.fDelete;
187 fDeleteArray=gci.fDeleteArray;
188 fDestructor=gci.fDestructor;
189 fStreamer=gci.fStreamer;
190 fCollectionProxy=gci.fCollectionProxy;
191 fSizeof=gci.fSizeof;
192 } return *this;
193 }
194 */
195
196 void TGenericClassInfo::Init(Int_t pragmabits)
197 {
198 // Initilization routine.
199
200 //TVirtualStreamerInfo::Class_Version MUST be the same as TStreamerInfo::Class_Version
201 if (fVersion==-2) fVersion = TVirtualStreamerInfo::Class_Version();
202 if (!fAction) return;
203 GetAction().Register(fClassName,
204 fVersion,
205 fInfo, // typeid(RootClass),
206 fDictionary,
207 pragmabits);
208 }
209
210 TGenericClassInfo::~TGenericClassInfo()
211 {
212 // Destructor.
213
214 delete fCollectionProxyInfo;
215 delete fCollectionStreamerInfo;
216 delete fStreamer;
217 if (!fClass)
218 delete fIsA; // fIsA is adopted by the class if any.
219 fIsA = nullptr;
222 return;
223 for(auto alt : fAlternate)
225 if (fAction)
226 GetAction().Unregister(GetClassName(), fClass);
227 }
228
229 const Internal::TInitBehavior &TGenericClassInfo::GetAction() const
230 {
231 // Return the creator action.
232
233 return *fAction;
234 }
235
236 TClass *TGenericClassInfo::GetClass()
237 {
238 // Generate and return the TClass object.
239
240 // First make sure that TROOT is initialized, do this before checking
241 // for fClass. If the request is for the TClass of TObject and TROOT
242 // is not initialized, the TROOT creation (because of the ROOT pcm files)
243 // will lead to its own request of the TClass for TObject and thus
244 // upon returning, the TClass for TObject will have already been created
245 // and fClass will have been set.
246 if (!gROOT)
247 ::Fatal("TClass::TClass", "ROOT system not initialized");
248
249 if (!fClass && fAction) {
251 // Check again, while we waited for the lock, something else might
252 // have set fClass.
253 if (fClass) return fClass;
254
255 fClass = GetAction().CreateClass(GetClassName(),
256 GetVersion(),
257 GetInfo(),
258 GetIsA(),
259 GetDeclFileName(),
260 GetImplFileName(),
261 GetDeclFileLine(),
262 GetImplFileLine());
263 if (fPragmaBits & TClassTable::kHasCustomStreamerMember) {
265 }
266 fClass->SetNew(fNew);
267 fClass->SetNewArray(fNewArray);
268 fClass->SetDelete(fDelete);
269 fClass->SetDeleteArray(fDeleteArray);
270 fClass->SetDestructor(fDestructor);
271 fClass->SetDirectoryAutoAdd(fDirAutoAdd);
272 fClass->SetStreamerFunc(fStreamerFunc);
273 fClass->SetConvStreamerFunc(fConvStreamerFunc);
274 fClass->SetMerge(fMerge);
275 fClass->SetResetAfterMerge(fResetAfterMerge);
276 fClass->AdoptStreamer(fStreamer); fStreamer = nullptr;
277 // If IsZombie is true, something went wrong and we will not be
278 // able to properly copy the collection proxy
279 if (!fClass->IsZombie()) {
280 if (fCollectionProxy) fClass->CopyCollectionProxy(*fCollectionProxy);
281 else if (fCollectionProxyInfo) {
282 fClass->SetCollectionProxy(*fCollectionProxyInfo);
283 }
284 }
285 fClass->SetClassSize(fSizeof);
286
287 //---------------------------------------------------------------------
288 // Attach the schema evolution information
289 ///////////////////////////////////////////////////////////////////////
290
291 CreateRuleSet( fReadRules, true );
292 CreateRuleSet( fReadRawRules, false );
293 }
294 return fClass;
295 }
296
297 /////////////////////////////////////////////////////////////////////////////
298 /// Attach the schema evolution information to TClassObject
299
300 void TGenericClassInfo::CreateRuleSet( std::vector<Internal::TSchemaHelper>& vect,
301 Bool_t ProcessReadRules )
302 {
303 if ( vect.empty() ) {
304 return;
305 }
306
307 //------------------------------------------------------------------------
308 // Get the rules set
309 //////////////////////////////////////////////////////////////////////////
310
311 TSchemaRuleSet* rset = fClass->GetSchemaRules( kTRUE );
312
313 //------------------------------------------------------------------------
314 // Process the rules
315 //////////////////////////////////////////////////////////////////////////
316
317 TSchemaRule* rule;
318 TString errmsg;
319 std::vector<Internal::TSchemaHelper>::iterator it;
320 for( it = vect.begin(); it != vect.end(); ++it ) {
321 rule = new TSchemaRule();
322 rule->SetTarget( it->fTarget );
323 rule->SetTargetClass( fClass->GetName() );
324 rule->SetSourceClass( it->fSourceClass );
325 rule->SetSource( it->fSource );
326 rule->SetCode( it->fCode );
327 rule->SetVersion( it->fVersion );
328 rule->SetChecksum( it->fChecksum );
329 rule->SetEmbed( it->fEmbed );
330 rule->SetInclude( it->fInclude );
331 rule->SetAttributes( it->fAttributes );
332
333 if( ProcessReadRules ) {
334 rule->SetRuleType( TSchemaRule::kReadRule );
335 rule->SetReadFunctionPointer( (TSchemaRule::ReadFuncPtr_t)it->fFunctionPtr );
336 }
337 else {
338 rule->SetRuleType( TSchemaRule::kReadRawRule );
339 rule->SetReadRawFunctionPointer( (TSchemaRule::ReadRawFuncPtr_t)it->fFunctionPtr );
340 }
341 if( !rset->AddRule( rule, TSchemaRuleSet::kCheckAll, &errmsg ) ) {
342 ::Warning( "TGenericClassInfo", "The rule for class: \"%s\": version, \"%s\" and data members: \"%s\" has been skipped because %s.",
343 GetClassName(), it->fVersion.c_str(), it->fTarget.c_str(), errmsg.Data() );
344 delete rule;
345 }
346 }
347 }
348
349 const char *TGenericClassInfo::GetClassName() const
350 {
351 // Return the class name
352
353 return fClassName;
354 }
355
356
357 Detail::TCollectionProxyInfo *TGenericClassInfo::GetCollectionProxyInfo() const
358 {
359 // Return the set of info we have for the CollectionProxy, if any
360
361 return fCollectionProxyInfo;
362 }
363
364 Detail::TCollectionProxyInfo *TGenericClassInfo::GetCollectionStreamerInfo() const
365 {
366 // Return the set of info we have for the Collection Streamer, if any
367
368 return fCollectionProxyInfo;
369 }
370
371 const std::type_info &TGenericClassInfo::GetInfo() const
372 {
373 // Return the typeinfo value
374
375 return fInfo;
376 }
377
378 const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRawRules() const
379 {
380 // Return the list of rule give raw access to the TBuffer.
381
382 return fReadRawRules;
383 }
384
385
386 const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRules() const
387 {
388 // Return the list of Data Model Evolution regular read rules.
389 return fReadRules;
390 }
391
392 void TGenericClassInfo::SetFromTemplate()
393 {
394 // Import the information from the class template.
395
396 TNamed *info = ROOT::RegisterClassTemplate(GetClassName(), nullptr, 0);
397 if (info) SetImplFile(info->GetTitle(), info->GetUniqueID());
398 }
399
400 Int_t TGenericClassInfo::SetImplFile(const char *file, Int_t line)
401 {
402 // Set the name of the implementation file.
403
404 fImplFileName = file;
405 fImplFileLine = line;
406 if (fClass) fClass->AddImplFile(file,line);
407 return 0;
408 }
409
410 Int_t TGenericClassInfo::SetDeclFile(const char *file, Int_t line)
411 {
412 // Set the name of the declaration file.
413
414 fDeclFileName = file;
415 fDeclFileLine = line;
416 if (fClass) fClass->SetDeclFile(file,line);
417 return 0;
418 }
419
420 Short_t TGenericClassInfo::SetVersion(Short_t version)
421 {
422 // Set a class version number.
423
424 ROOT::ResetClassVersion(fClass, GetClassName(),version);
425 fVersion = version;
426 return version;
427 }
428
429 void TGenericClassInfo::AdoptAlternate(ROOT::TClassAlt *alt)
430 {
431 fAlternate.push_back(alt);
432 }
433
434 void TGenericClassInfo::AdoptCollectionProxyInfo(TCollectionProxyInfo *info)
435 {
436 // Set the info for the CollectionProxy and take ownership of the object
437 // being passed
438
439 delete fCollectionProxyInfo;;
440 fCollectionProxyInfo = info;
441 }
442
443 void TGenericClassInfo::AdoptCollectionStreamerInfo(TCollectionProxyInfo *info)
444 {
445 // Set the info for the Collection Streamer and take ownership of the object
446 // being passed
447
448 delete fCollectionStreamerInfo;
449 fCollectionStreamerInfo = info;
450 }
451
452 Short_t TGenericClassInfo::AdoptStreamer(TClassStreamer *streamer)
453 {
454 // Set a Streamer object. The streamer object is now 'owned'
455 // by the TGenericClassInfo.
456
457 delete fStreamer; fStreamer = nullptr;
458 if (fClass) {
459 fClass->AdoptStreamer(streamer);
460 } else {
461 fStreamer = streamer;
462 }
463 return 0;
464 }
465
466 Short_t TGenericClassInfo::AdoptCollectionProxy(TVirtualCollectionProxy *collProxy)
467 {
468 // Set the CollectProxy object. The CollectionProxy object is now 'owned'
469 // by the TGenericClassInfo.
470
471 delete fCollectionProxy; fCollectionProxy = nullptr;
472 fCollectionProxy = collProxy;
473 if (fClass && fCollectionProxy && !fClass->IsZombie()) {
474 fClass->CopyCollectionProxy(*fCollectionProxy);
475 }
476 return 0;
477 }
478
479 void TGenericClassInfo::SetReadRawRules( const std::vector<Internal::TSchemaHelper>& rules )
480 {
481 // Set the list of Data Model Evolution read rules giving direct access to the TBuffer.
482 fReadRawRules = rules;
483 }
484
485
486 void TGenericClassInfo::SetReadRules( const std::vector<Internal::TSchemaHelper>& rules )
487 {
488 // Set the list of Data Model Evolution regular read rules.
489 fReadRules = rules;
490 }
491
492 Short_t TGenericClassInfo::SetStreamer(ClassStreamerFunc_t streamer)
493 {
494 // Set a External Streamer function.
495
496 delete fStreamer; fStreamer = nullptr;
497 if (fClass) {
498 fClass->AdoptStreamer(new TClassStreamer(streamer));
499 } else {
500 fStreamer = new TClassStreamer(streamer);
501 }
502 return 0;
503 }
504
505 void TGenericClassInfo::SetStreamerFunc(ClassStreamerFunc_t streamer)
506 {
507 // Set a wrapper around the Streamer member function.
508
509 fStreamerFunc = streamer;
510 if (fClass) fClass->SetStreamerFunc(streamer);
511 }
512
513 void TGenericClassInfo::SetConvStreamerFunc(ClassConvStreamerFunc_t streamer)
514 {
515 // Set a wrapper around the Streamer member function.
516
517 fConvStreamerFunc = streamer;
518 if (fClass) fClass->SetConvStreamerFunc(streamer);
519 }
520
521 const char *TGenericClassInfo::GetDeclFileName() const
522 {
523 // Get the name of the declaring header file.
524
525 return fDeclFileName;
526 }
527
528 Int_t TGenericClassInfo::GetDeclFileLine() const
529 {
530 // Get the declaring line number.
531
532 return fDeclFileLine;
533 }
534
535 const char *TGenericClassInfo::GetImplFileName()
536 {
537 // Get the implementation filename.
538
539 if (!fImplFileName) SetFromTemplate();
540 return fImplFileName;
541 }
542
543 Int_t TGenericClassInfo::GetImplFileLine()
544 {
545 // Get the ClassImp line number.
546
547 if (!fImplFileLine) SetFromTemplate();
548 return fImplFileLine;
549 }
550
551 Int_t TGenericClassInfo::GetVersion() const
552 {
553 // Return the class version number.
554
555 return fVersion;
556 }
557
558 TClass *TGenericClassInfo::IsA(const void *obj)
559 {
560 // Return the actual type of the object.
561
562 return (*GetIsA())(obj);
563 }
564
565 TVirtualIsAProxy* TGenericClassInfo::GetIsA() const
566 {
567 // Return the IsA proxy.
568
569 return fIsA;
570 }
571
572 void TGenericClassInfo::SetNew(NewFunc_t newFunc)
573 {
574 // Install a new wrapper around 'new'.
575
576 fNew = newFunc;
577 if (fClass) fClass->SetNew(fNew);
578 }
579
580 void TGenericClassInfo::SetNewArray(NewArrFunc_t newArrayFunc)
581 {
582 // Install a new wrapper around 'new []'.
583
584 fNewArray = newArrayFunc;
585 if (fClass) fClass->SetNewArray(fNewArray);
586 }
587
588 void TGenericClassInfo::SetDelete(DelFunc_t deleteFunc)
589 {
590 // Install a new wrapper around 'delete'.
591
592 fDelete = deleteFunc;
593 if (fClass) fClass->SetDelete(fDelete);
594 }
595
596 void TGenericClassInfo::SetDeleteArray(DelArrFunc_t deleteArrayFunc)
597 {
598 // Install a new wrapper around 'delete []'.
599
600 fDeleteArray = deleteArrayFunc;
601 if (fClass) fClass->SetDeleteArray(fDeleteArray);
602 }
603
604 void TGenericClassInfo::SetDestructor(DesFunc_t destructorFunc)
605 {
606 // Install a new wrapper around the destructor.
607
608 fDestructor = destructorFunc;
609 if (fClass) fClass->SetDestructor(fDestructor);
610 }
611
612 void TGenericClassInfo::SetDirectoryAutoAdd(DirAutoAdd_t func)
613 {
614 // Install a new wrapper around SetDirectoryAutoAdd.
615
616 fDirAutoAdd = func;
617 if (fClass) fClass->SetDirectoryAutoAdd(fDirAutoAdd);
618 }
619
620 void TGenericClassInfo::SetMerge(MergeFunc_t func)
621 {
622 // Install a new wrapper around the Merge function.
623
624 fMerge = func;
625 if (fClass) fClass->SetMerge(fMerge);
626 }
627
628 void TGenericClassInfo::SetResetAfterMerge(ResetAfterMergeFunc_t func)
629 {
630 // Install a new wrapper around the Merge function.
631
632 fResetAfterMerge = func;
633 if (fClass) fClass->SetResetAfterMerge(fResetAfterMerge);
634 }
635
636 NewFunc_t TGenericClassInfo::GetNew() const
637 {
638 // Get the wrapper around 'new'.
639
640 return fNew;
641 }
642
643 NewArrFunc_t TGenericClassInfo::GetNewArray() const
644 {
645 // Get the wrapper around 'new []'.
646
647 return fNewArray;
648 }
649
650 DelFunc_t TGenericClassInfo::GetDelete() const
651 {
652 // Get the wrapper around 'delete'.
653
654 return fDelete;
655 }
656
657 DelArrFunc_t TGenericClassInfo::GetDeleteArray() const
658 {
659 // Get the wrapper around 'delete []'.
660
661 return fDeleteArray;
662 }
663
664 DesFunc_t TGenericClassInfo::GetDestructor() const
665 {
666 // Get the wrapper around the destructor.
667
668 return fDestructor;
669 }
670
671 DirAutoAdd_t TGenericClassInfo::GetDirectoryAutoAdd() const
672 {
673 // Get the wrapper around the directory-auto-add function .
674
675 return fDirAutoAdd;
676 }
677
678}
Cppyy::TCppType_t fClass
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
short Short_t
Definition RtypesCore.h:39
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
TClass *(* DictFuncPtr_t)()
Definition Rtypes.h:80
std::atomic< TClass * > atomic_TClass_ptr
Definition Rtypes.h:195
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition Rtypes.h:72
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition Rtypes.h:73
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
Definition TError.cxx:244
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:406
#define R__LOCKGUARD(mutex)
#define free
Definition civetweb.c:1539
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(* ReadFuncPtr_t)(char *, TVirtualObject *)
Definition TSchemaRule.h:40
void(* ReadRawFuncPtr_t)(char *, TBuffer &)
Definition TSchemaRule.h:41
@ kHasCustomStreamerMember
Definition TClassTable.h:66
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
@ kHasCustomStreamerMember
Definition TClass.h:106
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition TObject.cxx:457
TCollection * GetListOfClasses() const
Definition TROOT.h:231
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition TROOT.cxx:2859
Basic string class.
Definition TString.h:139
const char * Data() const
Definition TString.h:376
Defines a common interface to inspect/change the contents of an object that represents a collection.
static constexpr Version_t Class_Version()
TLine * line
R__EXTERN TROOT * gROOTLocal
Definition TROOT.h:379
const TInitBehavior * DefineBehavior(void *, void *)
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:114
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition Rtypes.h:116
void(* DesFunc_t)(void *)
Definition Rtypes.h:113
void(* DelFunc_t)(void *)
Definition Rtypes.h:111
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:110
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
void(* DelArrFunc_t)(void *)
Definition Rtypes.h:112
void *(* NewFunc_t)(void *)
Definition Rtypes.h:109
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition Rtypes.h:115
void RemoveClassAlternate(ROOT::TClassAlt *)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
char * DemangleName(const char *mangled_name, int &errorCode)
Definition TClassEdit.h:208
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.