Logo ROOT   6.19/01
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"
15 #include "TVirtualStreamerInfo.h"
16 #include "TStreamer.h"
17 #include "TVirtualIsAProxy.h"
19 #include "TCollectionProxyInfo.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 
27 namespace ROOT {
28 namespace 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 
76  void TCDGIILIBase::SetfgIsA(atomic_TClass_ptr& isA, TClass*(*dictfun)()) {
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(0), fClassName(fullClassname),
91  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
92  fDictionary(dictionary), fInfo(info),
93  fImplFileName(0), fImplFileLine(0),
94  fIsA(isa),
95  fVersion(1),
96  fMerge(0),fResetAfterMerge(0),fNew(0),fNewArray(0),fDelete(0),fDeleteArray(0),fDestructor(0), fDirAutoAdd(0), fStreamer(0),
97  fStreamerFunc(0), fConvStreamerFunc(0), fCollectionProxy(0), fSizeof(sizof), fPragmaBits(pragmabits),
98  fCollectionProxyInfo(0), fCollectionStreamerInfo(0)
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(0), fClassName(fullClassname),
111  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
112  fDictionary(dictionary), fInfo(info),
113  fImplFileName(0), fImplFileLine(0),
114  fIsA(isa),
115  fVersion(version),
116  fMerge(0),fResetAfterMerge(0),fNew(0),fNewArray(0),fDelete(0),fDeleteArray(0),fDestructor(0), fDirAutoAdd(0), fStreamer(0),
117  fStreamerFunc(0), fConvStreamerFunc(0), fCollectionProxy(0), fSizeof(sizof), fPragmaBits(pragmabits),
118  fCollectionProxyInfo(0), fCollectionStreamerInfo(0)
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(0), fClassName(fullClassname),
133  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
134  fDictionary(dictionary), fInfo(typeid(TForNamespace)),
135  fImplFileName(0), fImplFileLine(0),
136  fIsA(0),
137  fVersion(version),
138  fMerge(0),fResetAfterMerge(0),fNew(0),fNewArray(0),fDelete(0),fDeleteArray(0),fDestructor(0), fDirAutoAdd(0), fStreamer(0),
139  fStreamerFunc(0), fConvStreamerFunc(0), fCollectionProxy(0), fSizeof(0), fPragmaBits(pragmabits),
140  fCollectionProxyInfo(0), fCollectionStreamerInfo(0)
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),
206  fDictionary,
207  pragmabits);
208  }
209 
211  {
212  // Destructor.
213 
214  delete fCollectionProxyInfo;
216  delete fStreamer;
217  if (!fClass) delete fIsA; // fIsA is adopted by the class if any.
218  fIsA = 0;
220  if (!gROOTLocal || !gROOTLocal->Initialized() || !gROOTLocal->GetListOfClasses()) return;
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(),
254  GetDeclFileName(),
255  GetImplFileName(),
256  GetDeclFileLine(),
257  GetImplFileLine());
260  }
261  fClass->SetNew(fNew);
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 );
287  CreateRuleSet( fReadRawRules, false );
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 {
334  rule->SetReadRawFunctionPointer( (TSchemaRule::ReadRawFuncPtr_t)it->fFunctionPtr );
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 
356  return fCollectionProxyInfo;
357  }
358 
360  {
361  // Return the set of info we have for the Collection Streamer, if any
362 
363  return fCollectionProxyInfo;
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 
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;;
430  fCollectionProxyInfo = info;
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 = 0;
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 
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 = 0;
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 
548  TClass *TGenericClassInfo::IsA(const void *obj)
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;
615  if (fClass) fClass->SetMerge(fMerge);
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 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
void SetStreamerFunc(ClassStreamerFunc_t)
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:375
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...
const std::type_info & GetInfo() const
const char * GetClassName() const
void(* ReadRawFuncPtr_t)(char *, TBuffer &)
Definition: TSchemaRule.h:43
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition: Rtypes.h:70
Detail::TCollectionProxyInfo * fCollectionProxyInfo
void SetReadRawFunctionPointer(ReadRawFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a raw read rule).
VSD Structures.
Definition: StringConv.hxx:21
void SetDelete(DelFunc_t deleteFunc)
TCollection * GetListOfClasses() const
Definition: TROOT.h:241
TLine * line
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:113
void Fatal(const char *location, const char *msgfmt,...)
void SetDeclFile(const char *name, int line)
Definition: TClass.h:513
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:116
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around &#39;delete&#39;.
Definition: TClass.cxx:6742
void SetConvStreamerFunc(ClassConvStreamerFunc_t)
const std::type_info & fInfo
void SetConvStreamerFunc(ClassConvStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom conversion streamer.
Definition: TClass.cxx:6686
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:40
void CreateRuleSet(std::vector< ROOT::Internal::TSchemaHelper > &vect, Bool_t ProcessReadRules)
Attach the schema evolution information to TClassObject.
void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
Install a new wrapper around &#39;delete []&#39;.
Definition: TClass.cxx:6750
#define gROOT
Definition: TROOT.h:415
Basic string class.
Definition: TString.h:131
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:59
TVirtualIsAProxy * GetIsA() const
Short_t AdoptCollectionProxy(TVirtualCollectionProxy *)
Short_t SetVersion(Short_t version)
Bool_t SetVersion(const TString &version)
Set the version string - returns kFALSE if the format is incorrect.
ClassConvStreamerFunc_t fConvStreamerFunc
void AdoptStreamer(TClassStreamer *strm)
Adopt a TClassStreamer object.
Definition: TClass.cxx:6635
const TInitBehavior * DefineBehavior(void *, void *)
void SetClassSize(Int_t sizof)
Definition: TClass.h:273
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
void SetTargetClass(const TString &classname)
Set the target class of this rule (i.e. the in memory class).
void SetAttributes(const TString &attributes)
Set the attributes code of this rule.
ResetAfterMergeFunc_t fResetAfterMerge
DirAutoAdd_t GetDirectoryAutoAdd() const
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
char * DemangleName(const char *mangled_name, int &errorCode)
Definition: TClassEdit.h:205
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2866
const char * GetDeclFileName() const
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition: TClass.cxx:6663
void SetReadRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
void SetDirectoryAutoAdd(DirAutoAdd_t dirAutoAdd)
TClass * IsA(const void *obj)
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:110
Short_t SetStreamer(ClassStreamerFunc_t)
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:78
Int_t SetDeclFile(const char *file, Int_t line)
void SetSource(const TString &source)
Set the list of source members.
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition: Rtypes.h:71
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition: TObject.h:134
void SetSourceClass(const TString &classname)
Set the source class of this rule (i.e. the onfile class).
Short_t AdoptStreamer(TClassStreamer *)
void SetInclude(const TString &include)
Set the comma separated list of header files to include to be able to compile this rule...
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:117
std::vector< ROOT::Internal::TSchemaHelper > fReadRawRules
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:388
const Internal::TInitBehavior * fAction
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around &#39;new&#39;.
Definition: TClass.cxx:6726
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition: Rtypes.h:111
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRawRules() const
static void SetfgIsA(atomic_TClass_ptr &isA, TClass *(*dictfun)())
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:832
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition: TClass.cxx:6758
Int_t SetImplFile(const char *file, Int_t line)
void SetTarget(const TString &target)
Set the target member of this rule (i.e. the in memory data member).
TClassStreamer * fStreamer
void AdoptCollectionStreamerInfo(Detail::TCollectionProxyInfo *)
void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc)
Install a new wrapper around the directory auto add function.
Definition: TClass.cxx:6769
NewArrFunc_t GetNewArray() const
const Internal::TInitBehavior & GetAction() const
void SetCode(const TString &code)
Set the source code of this rule.
Detail::TCollectionProxyInfo * fCollectionStreamerInfo
ClassStreamerFunc_t fStreamerFunc
short Short_t
Definition: RtypesCore.h:35
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75
std::atomic< TClass * > atomic_TClass_ptr
Definition: Rtypes.h:195
Bool_t SetChecksum(const TString &checksum)
Set the checksum string - returns kFALSE if the format is incorrect.
static void SetInstance(::ROOT::TGenericClassInfo &R__instance, NewFunc_t, NewArrFunc_t, DelFunc_t, DelArrFunc_t, DesFunc_t)
void Warning(const char *location, const char *msgfmt,...)
TVirtualIsAProxy * fIsA
void SetDestructor(DesFunc_t destructorFunc)
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:5991
virtual void Unregister(const char *classname) const =0
std::vector< ROOT::Internal::TSchemaHelper > fReadRules
void(* ReadFuncPtr_t)(char *, TVirtualObject *)
Definition: TSchemaRule.h:42
void SetReadFunctionPointer(ReadFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a read rule).
TVirtualCollectionProxy * fCollectionProxy
#define free
Definition: civetweb.c:1539
#define R__LOCKGUARD(mutex)
void SetDeleteArray(DelArrFunc_t deleteArrayFunc)
void SetEmbed(Bool_t embed)
Set whether this rule should be save in the ROOT file (if true)
Detail::TCollectionProxyInfo * GetCollectionStreamerInfo() const
void Init(Int_t pragmabits)
void SetNew(NewFunc_t newFunc)
void(* DelFunc_t)(void *)
Definition: Rtypes.h:112
void SetNewArray(NewArrFunc_t newArrayFunc)
Detail::TCollectionProxyInfo * GetCollectionProxyInfo() const
void AddImplFile(const char *filename, int line)
Definition: TClass.cxx:1882
void SetResetAfterMerge(ResetAfterMergeFunc_t)
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:115
Definition: file.py:1
DesFunc_t GetDestructor() const
void SetMerge(ROOT::MergeFunc_t mergeFunc)
Install a new wrapper around &#39;Merge&#39;.
Definition: TClass.cxx:6710
virtual void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const =0
void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc)
Install a new wrapper around &#39;ResetAfterMerge&#39;.
Definition: TClass.cxx:6718
void Destruct(TCppType_t type, TCppObject_t instance)
Definition: Cppyy.cxx:292
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition: TClass.cxx:1862
std::string GetDemangledTypeName(const std::type_info &)
Returns a string with the demangled and normalized name for the given type.
static void SetName(const std::string &name, std::string &nameMember)
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.e.
void SetRuleType(RuleType_t type)
Set the type of the rule.
void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
Install a new wrapper around &#39;new []&#39;.
Definition: TClass.cxx:6734
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
const Bool_t kTRUE
Definition: RtypesCore.h:87
void AdoptCollectionProxyInfo(Detail::TCollectionProxyInfo *)
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Copy the argument.
Definition: TClass.cxx:2408
char name[80]
Definition: TGX11.cxx:109
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRules() const
void SetReadRawRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
DelArrFunc_t GetDeleteArray() const
void(* DesFunc_t)(void *)
Definition: Rtypes.h:114
const char * Data() const
Definition: TString.h:364