Logo ROOT  
Reference Guide
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
56 NewFunc_t New, NewArrFunc_t NewArray,
57 DelFunc_t Delete, DelArrFunc_t DeleteArray,
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
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;
204 fVersion,
205 fInfo, // typeid(RootClass),
207 pragmabits);
208 }
209
211 {
212 // Destructor.
213
216 delete fStreamer;
217 if (!fClass) delete fIsA; // fIsA is adopted by the class if any.
218 fIsA = nullptr;
222 }
223
225 {
226 // Return the creator action.
227
228 return *fAction;
229 }
230
232 {
233 // Generate and return the TClass object.
234
235 // First make sure that TROOT is initialized, do this before checking
236 // for fClass. If the request is for the TClass of TObject and TROOT
237 // is not initialized, the TROOT creation (because of the ROOT pcm files)
238 // will lead to its own request of the TClass for TObject and thus
239 // upon returning, the TClass for TObject will have already been created
240 // and fClass will have been set.
241 if (!gROOT)
242 ::Fatal("TClass::TClass", "ROOT system not initialized");
243
244 if (!fClass && fAction) {
246 // Check again, while we waited for the lock, something else might
247 // have set fClass.
248 if (fClass) return fClass;
249
251 GetVersion(),
252 GetInfo(),
253 GetIsA(),
260 }
272 // If IsZombie is true, something went wrong and we will not be
273 // able to properly copy the collection proxy
274 if (!fClass->IsZombie()) {
276 else if (fCollectionProxyInfo) {
278 }
279 }
281
282 //---------------------------------------------------------------------
283 // Attach the schema evolution information
284 ///////////////////////////////////////////////////////////////////////
285
286 CreateRuleSet( fReadRules, true );
288 }
289 return fClass;
290 }
291
292 /////////////////////////////////////////////////////////////////////////////
293 /// Attach the schema evolution information to TClassObject
294
295 void TGenericClassInfo::CreateRuleSet( std::vector<Internal::TSchemaHelper>& vect,
296 Bool_t ProcessReadRules )
297 {
298 if ( vect.empty() ) {
299 return;
300 }
301
302 //------------------------------------------------------------------------
303 // Get the rules set
304 //////////////////////////////////////////////////////////////////////////
305
307
308 //------------------------------------------------------------------------
309 // Process the rules
310 //////////////////////////////////////////////////////////////////////////
311
312 TSchemaRule* rule;
313 TString errmsg;
314 std::vector<Internal::TSchemaHelper>::iterator it;
315 for( it = vect.begin(); it != vect.end(); ++it ) {
316 rule = new TSchemaRule();
317 rule->SetTarget( it->fTarget );
318 rule->SetTargetClass( fClass->GetName() );
319 rule->SetSourceClass( it->fSourceClass );
320 rule->SetSource( it->fSource );
321 rule->SetCode( it->fCode );
322 rule->SetVersion( it->fVersion );
323 rule->SetChecksum( it->fChecksum );
324 rule->SetEmbed( it->fEmbed );
325 rule->SetInclude( it->fInclude );
326 rule->SetAttributes( it->fAttributes );
327
328 if( ProcessReadRules ) {
330 rule->SetReadFunctionPointer( (TSchemaRule::ReadFuncPtr_t)it->fFunctionPtr );
331 }
332 else {
335 }
336 if( !rset->AddRule( rule, TSchemaRuleSet::kCheckAll, &errmsg ) ) {
337 ::Warning( "TGenericClassInfo", "The rule for class: \"%s\": version, \"%s\" and data members: \"%s\" has been skipped because %s.",
338 GetClassName(), it->fVersion.c_str(), it->fTarget.c_str(), errmsg.Data() );
339 delete rule;
340 }
341 }
342 }
343
345 {
346 // Return the class name
347
348 return fClassName;
349 }
350
351
353 {
354 // Return the set of info we have for the CollectionProxy, if any
355
357 }
358
360 {
361 // Return the set of info we have for the Collection Streamer, if any
362
364 }
365
366 const std::type_info &TGenericClassInfo::GetInfo() const
367 {
368 // Return the typeinfo value
369
370 return fInfo;
371 }
372
373 const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRawRules() const
374 {
375 // Return the list of rule give raw access to the TBuffer.
376
377 return fReadRawRules;
378 }
379
380
381 const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRules() const
382 {
383 // Return the list of Data Model Evolution regular read rules.
384 return fReadRules;
385 }
386
388 {
389 // Import the information from the class template.
390
391 TNamed *info = ROOT::RegisterClassTemplate(GetClassName(), nullptr, 0);
392 if (info) SetImplFile(info->GetTitle(), info->GetUniqueID());
393 }
394
396 {
397 // Set the name of the implementation file.
398
402 return 0;
403 }
404
406 {
407 // Set the name of the declaration file.
408
412 return 0;
413 }
414
416 {
417 // Set a class version number.
418
420 fVersion = version;
421 return version;
422 }
423
425 {
426 // Set the info for the CollectionProxy and take ownership of the object
427 // being passed
428
429 delete fCollectionProxyInfo;;
431 }
432
434 {
435 // Set the info for the Collection Streamer and take ownership of the object
436 // being passed
437
440 }
441
443 {
444 // Set a Streamer object. The streamer object is now 'owned'
445 // by the TGenericClassInfo.
446
447 delete fStreamer; fStreamer = nullptr;
448 if (fClass) {
449 fClass->AdoptStreamer(streamer);
450 } else {
451 fStreamer = streamer;
452 }
453 return 0;
454 }
455
457 {
458 // Set the CollectProxy object. The CollectionProxy object is now 'owned'
459 // by the TGenericClassInfo.
460
461 delete fCollectionProxy; fCollectionProxy = nullptr;
462 fCollectionProxy = collProxy;
463 if (fClass && fCollectionProxy && !fClass->IsZombie()) {
465 }
466 return 0;
467 }
468
469 void TGenericClassInfo::SetReadRawRules( const std::vector<Internal::TSchemaHelper>& rules )
470 {
471 // Set the list of Data Model Evolution read rules giving direct access to the TBuffer.
472 fReadRawRules = rules;
473 }
474
475
476 void TGenericClassInfo::SetReadRules( const std::vector<Internal::TSchemaHelper>& rules )
477 {
478 // Set the list of Data Model Evolution regular read rules.
479 fReadRules = rules;
480 }
481
483 {
484 // Set a External Streamer function.
485
486 delete fStreamer; fStreamer = nullptr;
487 if (fClass) {
488 fClass->AdoptStreamer(new TClassStreamer(streamer));
489 } else {
490 fStreamer = new TClassStreamer(streamer);
491 }
492 return 0;
493 }
494
496 {
497 // Set a wrapper around the Streamer member function.
498
499 fStreamerFunc = streamer;
500 if (fClass) fClass->SetStreamerFunc(streamer);
501 }
502
504 {
505 // Set a wrapper around the Streamer member function.
506
507 fConvStreamerFunc = streamer;
508 if (fClass) fClass->SetConvStreamerFunc(streamer);
509 }
510
512 {
513 // Get the name of the declaring header file.
514
515 return fDeclFileName;
516 }
517
519 {
520 // Get the declaring line number.
521
522 return fDeclFileLine;
523 }
524
526 {
527 // Get the implementation filename.
528
530 return fImplFileName;
531 }
532
534 {
535 // Get the ClassImp line number.
536
538 return fImplFileLine;
539 }
540
542 {
543 // Return the class version number.
544
545 return fVersion;
546 }
547
549 {
550 // Return the actual type of the object.
551
552 return (*GetIsA())(obj);
553 }
554
556 {
557 // Return the IsA proxy.
558
559 return fIsA;
560 }
561
563 {
564 // Install a new wrapper around 'new'.
565
566 fNew = newFunc;
567 if (fClass) fClass->SetNew(fNew);
568 }
569
571 {
572 // Install a new wrapper around 'new []'.
573
574 fNewArray = newArrayFunc;
576 }
577
579 {
580 // Install a new wrapper around 'delete'.
581
582 fDelete = deleteFunc;
584 }
585
587 {
588 // Install a new wrapper around 'delete []'.
589
590 fDeleteArray = deleteArrayFunc;
592 }
593
595 {
596 // Install a new wrapper around the destructor.
597
598 fDestructor = destructorFunc;
600 }
601
603 {
604 // Install a new wrapper around SetDirectoryAutoAdd.
605
606 fDirAutoAdd = func;
608 }
609
611 {
612 // Install a new wrapper around the Merge function.
613
614 fMerge = func;
616 }
617
619 {
620 // Install a new wrapper around the Merge function.
621
622 fResetAfterMerge = func;
624 }
625
627 {
628 // Get the wrapper around 'new'.
629
630 return fNew;
631 }
632
634 {
635 // Get the wrapper around 'new []'.
636
637 return fNewArray;
638 }
639
641 {
642 // Get the wrapper around 'delete'.
643
644 return fDelete;
645 }
646
648 {
649 // Get the wrapper around 'delete []'.
650
651 return fDeleteArray;
652 }
653
655 {
656 // Get the wrapper around the destructor.
657
658 return fDestructor;
659 }
660
662 {
663 // Get the wrapper around the directory-auto-add function .
664
665 return fDirAutoAdd;
666 }
667
668}
Cppyy::TCppType_t fClass
int Int_t
Definition: RtypesCore.h:45
bool Bool_t
Definition: RtypesCore.h:63
short Short_t
Definition: RtypesCore.h:39
const Bool_t kTRUE
Definition: RtypesCore.h:100
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:80
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
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition: TError.cxx:231
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:245
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:44
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:61
#define gROOT
Definition: TROOT.h:404
#define R__LOCKGUARD(mutex)
#define free
Definition: civetweb.c:1539
Bool_t AddRule(TSchemaRule *rule, EConsistencyCheck checkConsistency=kCheckAll, TString *errmsg=0)
The consistency check always fails if the TClass object was not set! if checkConsistency is: kNoCheck...
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)())
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
DesFunc_t GetDestructor() const
const Internal::TInitBehavior * fAction
TVirtualIsAProxy * GetIsA() const
DelArrFunc_t GetDeleteArray() const
Short_t AdoptCollectionProxy(TVirtualCollectionProxy *)
const char * GetClassName() const
void SetDelete(DelFunc_t deleteFunc)
void SetDirectoryAutoAdd(DirAutoAdd_t dirAutoAdd)
void SetDeleteArray(DelArrFunc_t deleteArrayFunc)
TVirtualCollectionProxy * fCollectionProxy
void SetResetAfterMerge(ResetAfterMergeFunc_t)
std::vector< ROOT::Internal::TSchemaHelper > fReadRules
void CreateRuleSet(std::vector< ROOT::Internal::TSchemaHelper > &vect, Bool_t ProcessReadRules)
Attach the schema evolution information to TClassObject.
TClass * IsA(const void *obj)
Short_t SetVersion(Short_t version)
void SetConvStreamerFunc(ClassConvStreamerFunc_t)
Detail::TCollectionProxyInfo * fCollectionProxyInfo
TVirtualIsAProxy * fIsA
Detail::TCollectionProxyInfo * fCollectionStreamerInfo
void SetNewArray(NewArrFunc_t newArrayFunc)
std::vector< ROOT::Internal::TSchemaHelper > fReadRawRules
Int_t SetImplFile(const char *file, Int_t line)
const std::type_info & fInfo
NewArrFunc_t GetNewArray() const
const Internal::TInitBehavior & GetAction() const
ClassStreamerFunc_t fStreamerFunc
Detail::TCollectionProxyInfo * GetCollectionStreamerInfo() const
void SetReadRawRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
DirAutoAdd_t GetDirectoryAutoAdd() const
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRawRules() const
TClassStreamer * fStreamer
void SetReadRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
ClassConvStreamerFunc_t fConvStreamerFunc
const std::type_info & GetInfo() const
Detail::TCollectionProxyInfo * GetCollectionProxyInfo() const
void Init(Int_t pragmabits)
ResetAfterMergeFunc_t fResetAfterMerge
const char * GetDeclFileName() const
void SetDestructor(DesFunc_t destructorFunc)
void AdoptCollectionProxyInfo(Detail::TCollectionProxyInfo *)
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRules() const
Int_t SetDeclFile(const char *file, Int_t line)
Short_t SetStreamer(ClassStreamerFunc_t)
Short_t AdoptStreamer(TClassStreamer *)
void AdoptCollectionStreamerInfo(Detail::TCollectionProxyInfo *)
void SetNew(NewFunc_t newFunc)
void SetStreamerFunc(ClassStreamerFunc_t)
void SetRuleType(RuleType_t type)
Set the type of the rule.
void SetCode(const TString &code)
Set the source code of this rule.
void SetTarget(const TString &target)
Set the target member of this rule (i.e. the in memory data member).
void SetReadRawFunctionPointer(ReadRawFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a raw read rule).
void SetInclude(const TString &include)
Set the comma separated list of header files to include to be able to compile this rule.
void SetReadFunctionPointer(ReadFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a read rule).
void(* ReadFuncPtr_t)(char *, TVirtualObject *)
Definition: TSchemaRule.h:40
void SetEmbed(Bool_t embed)
Set whether this rule should be save in the ROOT file (if true)
void SetTargetClass(const TString &classname)
Set the target class of this rule (i.e. the in memory class).
void(* ReadRawFuncPtr_t)(char *, TBuffer &)
Definition: TSchemaRule.h:41
Bool_t SetVersion(const TString &version)
Set the version string - returns kFALSE if the format is incorrect.
void SetSource(const TString &source)
Set the list of source members.
void SetAttributes(const TString &attributes)
Set the attributes code of this rule.
void SetSourceClass(const TString &classname)
Set the source class of this rule (i.e. the onfile class).
Bool_t SetChecksum(const TString &checksum)
Set the checksum string - returns kFALSE if the format is incorrect.
@ kHasCustomStreamerMember
Definition: TClassTable.h:65
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc)
Install a new wrapper around the directory auto add function.
Definition: TClass.cxx:6980
void SetMerge(ROOT::MergeFunc_t mergeFunc)
Install a new wrapper around 'Merge'.
Definition: TClass.cxx:6921
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Copy the argument.
Definition: TClass.cxx:2457
void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
Install a new wrapper around 'new []'.
Definition: TClass.cxx:6945
void SetCollectionProxy(const ROOT::Detail::TCollectionProxyInfo &)
Create the collection proxy object (and the streamer object) from using the information in the TColle...
Definition: TClass.cxx:6196
void AddImplFile(const char *filename, int line)
Definition: TClass.cxx:1939
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around 'delete'.
Definition: TClass.cxx:6953
void SetDeclFile(const char *name, int line)
Definition: TClass.h:550
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition: TClass.cxx:6969
void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc)
Install a new wrapper around 'ResetAfterMerge'.
Definition: TClass.cxx:6929
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition: TClass.cxx:6874
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition: TClass.cxx:1919
void AdoptStreamer(TClassStreamer *strm)
Adopt a TClassStreamer object.
Definition: TClass.cxx:6846
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around 'new'.
Definition: TClass.cxx:6937
void SetClassSize(Int_t sizof)
Definition: TClass.h:305
void SetConvStreamerFunc(ClassConvStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom conversion streamer.
Definition: TClass.cxx:6897
void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
Install a new wrapper around 'delete []'.
Definition: TClass.cxx:6961
@ kHasCustomStreamerMember
Definition: TClass.h:105
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:377
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition: TObject.h:149
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TCollection * GetListOfClasses() const
Definition: TROOT.h:231
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2818
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
TLine * line
RPY_EXPORTED void Destruct(TCppType_t type, TCppObject_t instance)
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:377
const TInitBehavior * DefineBehavior(void *, void *)
std::string GetDemangledTypeName(const std::type_info &)
Returns a string with the demangled and normalized name for the given type.
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:113
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:115
void(* DesFunc_t)(void *)
Definition: Rtypes.h:112
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
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 ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
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
char * DemangleName(const char *mangled_name, int &errorCode)
Definition: TClassEdit.h:218
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:837
Definition: file.py:1