Logo ROOT   6.10/09
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  std::string TTypeNameExtractionBase::GetImpl(const char* derived_funcname) {
30  constexpr static const char tag[] = "TypeNameExtraction<";
31  const char* start = strstr(derived_funcname, tag);
32  if (!start)
33  return "";
34  start += sizeof(tag) - 1;
35  const char* end = strstr(start, ">::Get(");
36  if (!end)
37  return "";
38  std::string ret;
39  TClassEdit::GetNormalizedName(ret, std::string_view(start, end - start));
40  return ret;
41  }
42 
43  const TInitBehavior *DefineBehavior(void * /*parent_type*/,
44  void * /*actual_type*/)
45  {
46 
47  // This function loads the default behavior for the
48  // loading of classes.
49 
50  static TDefaultInitBehavior theDefault;
51  return &theDefault;
52  }
53 
55  NewFunc_t New, NewArrFunc_t NewArray,
56  DelFunc_t Delete, DelArrFunc_t DeleteArray,
59  R__instance.SetNew(New);
60  R__instance.SetNewArray(NewArray);
61  R__instance.SetDelete(Delete);
62  R__instance.SetDeleteArray(DeleteArray);
63  R__instance.SetDestructor(Destruct);
64  }
65 
66  void TCDGIILIBase::SetName(const std::string& name,
67  std::string& nameMember) {
69  if (nameMember.empty()) {
70  TClassEdit::GetNormalizedName(nameMember, name);
71  }
72  }
73 
74  void TCDGIILIBase::SetfgIsA(atomic_TClass_ptr& isA, TClass*(*dictfun)()) {
75  if (!isA.load()) {
77  dictfun();
78  }
79  }
80 } // Internal
81 
82 
83  TGenericClassInfo::TGenericClassInfo(const char *fullClassname,
84  const char *declFileName, Int_t declFileLine,
85  const std::type_info &info, const Internal::TInitBehavior *action,
86  DictFuncPtr_t dictionary,
87  TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof)
88  : fAction(action), fClass(0), fClassName(fullClassname),
89  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
90  fDictionary(dictionary), fInfo(info),
91  fImplFileName(0), fImplFileLine(0),
92  fIsA(isa),
93  fVersion(1),
94  fMerge(0),fResetAfterMerge(0),fNew(0),fNewArray(0),fDelete(0),fDeleteArray(0),fDestructor(0), fDirAutoAdd(0), fStreamer(0),
95  fStreamerFunc(0), fConvStreamerFunc(0), fCollectionProxy(0), fSizeof(sizof), fPragmaBits(pragmabits),
96  fCollectionProxyInfo(0), fCollectionStreamerInfo(0)
97  {
98  // Constructor.
99 
100  Init(pragmabits);
101  }
102 
103  TGenericClassInfo::TGenericClassInfo(const char *fullClassname, Int_t version,
104  const char *declFileName, Int_t declFileLine,
105  const std::type_info &info, const Internal::TInitBehavior *action,
106  DictFuncPtr_t dictionary,
107  TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof)
108  : fAction(action), fClass(0), fClassName(fullClassname),
109  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
110  fDictionary(dictionary), fInfo(info),
112  fIsA(isa),
113  fVersion(version),
115  fStreamerFunc(0), fConvStreamerFunc(0), fCollectionProxy(0), fSizeof(sizof), fPragmaBits(pragmabits),
117 
118  {
119  // Constructor with version number and no showmembers.
120 
121  Init(pragmabits);
122  }
123 
124  class TForNamespace {}; // Dummy class to give a typeid to namespace (See also TClassTable.cc)
125 
126  TGenericClassInfo::TGenericClassInfo(const char *fullClassname, Int_t version,
127  const char *declFileName, Int_t declFileLine,
128  const Internal::TInitBehavior *action,
129  DictFuncPtr_t dictionary, Int_t pragmabits)
130  : fAction(action), fClass(0), fClassName(fullClassname),
131  fDeclFileName(declFileName), fDeclFileLine(declFileLine),
132  fDictionary(dictionary), fInfo(typeid(TForNamespace)),
134  fIsA(0),
135  fVersion(version),
139 
140  {
141  // Constructor for namespace
142 
143  Init(pragmabits);
144  }
145 
146  /* TGenericClassInfo::TGenericClassInfo(const TGenericClassInfo& gci) :
147  fAction(gci.fAction),
148  fClass(gci.fClass),
149  fClassName(gci.fClassName),
150  fDeclFileName(gci.fDeclFileName),
151  fDeclFileLine(gci.fDeclFileLine),
152  fDictionary(gci.fDictionary),
153  fInfo(gci.fInfo),
154  fImplFileName(gci.fImplFileName),
155  fImplFileLine(gci.fImplFileLine),
156  fIsA(gci.fIsA),
157  fVersion(gci.fVersion),
158  fNew(gci.fNew),
159  fNewArray(gci.fNewArray),
160  fDelete(gci.fDelete),
161  fDeleteArray(gci.fDeleteArray),
162  fDestructor(gci.fDestructor),
163  fStreamer(gci.fStreamer),
164  fCollectionProxy(gci.fCollectionProxy),
165  fSizeof(gci.fSizeof)
166  { }
167 
168  TGenericClassInfo& TGenericClassInfo::operator=(const TGenericClassInfo& gci)
169  {
170  if(this!=&gci) {
171  fAction=gci.fAction;
172  fClass=gci.fClass;
173  fClassName=gci.fClassName;
174  fDeclFileName=gci.fDeclFileName;
175  fDeclFileLine=gci.fDeclFileLine;
176  fDictionary=gci.fDictionary;
177  fInfo=gci.fInfo;
178  fImplFileName=gci.fImplFileName;
179  fImplFileLine=gci.fImplFileLine;
180  fIsA=gci.fIsA;
181  fVersion=gci.fVersion;
182  fNew=gci.fNew;
183  fNewArray=gci.fNewArray;
184  fDelete=gci.fDelete;
185  fDeleteArray=gci.fDeleteArray;
186  fDestructor=gci.fDestructor;
187  fStreamer=gci.fStreamer;
188  fCollectionProxy=gci.fCollectionProxy;
189  fSizeof=gci.fSizeof;
190  } return *this;
191  }
192  */
193 
195  {
196  // Initilization routine.
197 
198  //TVirtualStreamerInfo::Class_Version MUST be the same as TStreamerInfo::Class_Version
199  if (fVersion==-2) fVersion = TVirtualStreamerInfo::Class_Version();
200  if (!fAction) return;
202  fVersion,
203  fInfo, // typeid(RootClass),
204  fDictionary,
205  pragmabits);
206  }
207 
209  {
210  // Destructor.
211 
212  delete fCollectionProxyInfo;
214  delete fStreamer;
215  if (!fClass) delete fIsA; // fIsA is adopted by the class if any.
216  fIsA = 0;
218  if (!gROOTLocal || !gROOTLocal->Initialized() || !gROOTLocal->GetListOfClasses()) return;
220  }
221 
223  {
224  // Return the creator action.
225 
226  return *fAction;
227  }
228 
230  {
231  // Generate and return the TClass object.
232 
233  // First make sure that TROOT is initialized, do this before checking
234  // for fClass. If the request is for the TClass of TObject and TROOT
235  // is not initialized, the TROOT creation (because of the ROOT pcm files)
236  // will lead to its own request of the TClass for TObject and thus
237  // upon returning, the TClass for TObject will have already been created
238  // and fClass will have been set.
239  if (!gROOT)
240  ::Fatal("TClass::TClass", "ROOT system not initialized");
241 
242  if (!fClass && fAction) {
244  // Check again, while we waited for the lock, something else might
245  // have set fClass.
246  if (fClass) return fClass;
247 
249  GetVersion(),
250  GetInfo(),
251  GetIsA(),
252  GetDeclFileName(),
253  GetImplFileName(),
254  GetDeclFileLine(),
255  GetImplFileLine());
258  }
259  fClass->SetNew(fNew);
270  // If IsZombie is true, something went wrong and we will not be
271  // able to properly copy the collection proxy
272  if (!fClass->IsZombie()) {
274  else if (fCollectionProxyInfo) {
276  }
277  }
279 
280  //---------------------------------------------------------------------
281  // Attach the schema evolution information
282  ///////////////////////////////////////////////////////////////////////
283 
284  CreateRuleSet( fReadRules, true );
285  CreateRuleSet( fReadRawRules, false );
286  }
287  return fClass;
288  }
289 
290  /////////////////////////////////////////////////////////////////////////////
291  /// Attach the schema evolution information to TClassObject
292 
293  void TGenericClassInfo::CreateRuleSet( std::vector<Internal::TSchemaHelper>& vect,
294  Bool_t ProcessReadRules )
295  {
296  if ( vect.empty() ) {
297  return;
298  }
299 
300  //------------------------------------------------------------------------
301  // Get the rules set
302  //////////////////////////////////////////////////////////////////////////
303 
305 
306  //------------------------------------------------------------------------
307  // Process the rules
308  //////////////////////////////////////////////////////////////////////////
309 
310  TSchemaRule* rule;
311  TString errmsg;
312  std::vector<Internal::TSchemaHelper>::iterator it;
313  for( it = vect.begin(); it != vect.end(); ++it ) {
314  rule = new TSchemaRule();
315  rule->SetTarget( it->fTarget );
316  rule->SetTargetClass( fClass->GetName() );
317  rule->SetSourceClass( it->fSourceClass );
318  rule->SetSource( it->fSource );
319  rule->SetCode( it->fCode );
320  rule->SetVersion( it->fVersion );
321  rule->SetChecksum( it->fChecksum );
322  rule->SetEmbed( it->fEmbed );
323  rule->SetInclude( it->fInclude );
324  rule->SetAttributes( it->fAttributes );
325 
326  if( ProcessReadRules ) {
328  rule->SetReadFunctionPointer( (TSchemaRule::ReadFuncPtr_t)it->fFunctionPtr );
329  }
330  else {
332  rule->SetReadRawFunctionPointer( (TSchemaRule::ReadRawFuncPtr_t)it->fFunctionPtr );
333  }
334  if( !rset->AddRule( rule, TSchemaRuleSet::kCheckAll, &errmsg ) ) {
335  ::Warning( "TGenericClassInfo", "The rule for class: \"%s\": version, \"%s\" and data members: \"%s\" has been skipped because %s.",
336  GetClassName(), it->fVersion.c_str(), it->fTarget.c_str(), errmsg.Data() );
337  delete rule;
338  }
339  }
340  }
341 
343  {
344  // Return the class name
345 
346  return fClassName;
347  }
348 
349 
351  {
352  // Return the set of info we have for the CollectionProxy, if any
353 
354  return fCollectionProxyInfo;
355  }
356 
358  {
359  // Return the set of info we have for the Collection Streamer, if any
360 
361  return fCollectionProxyInfo;
362  }
363 
364  const std::type_info &TGenericClassInfo::GetInfo() const
365  {
366  // Return the typeinfo value
367 
368  return fInfo;
369  }
370 
371  const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRawRules() const
372  {
373  // Return the list of rule give raw access to the TBuffer.
374 
375  return fReadRawRules;
376  }
377 
378 
379  const std::vector<Internal::TSchemaHelper>& TGenericClassInfo::GetReadRules() const
380  {
381  // Return the list of Data Model Evolution regular read rules.
382  return fReadRules;
383  }
384 
386  {
387  // Import the information from the class template.
388 
390  if (info) SetImplFile(info->GetTitle(), info->GetUniqueID());
391  }
392 
394  {
395  // Set the name of the implementation file.
396 
397  fImplFileName = file;
399  if (fClass) fClass->AddImplFile(file,line);
400  return 0;
401  }
402 
404  {
405  // Set the name of the declaration file.
406 
407  fDeclFileName = file;
409  if (fClass) fClass->SetDeclFile(file,line);
410  return 0;
411  }
412 
414  {
415  // Set a class version number.
416 
418  fVersion = version;
419  return version;
420  }
421 
423  {
424  // Set the info for the CollectionProxy and take ownership of the object
425  // being passed
426 
427  delete fCollectionProxyInfo;;
428  fCollectionProxyInfo = info;
429  }
430 
432  {
433  // Set the info for the Collection Streamer and take ownership of the object
434  // being passed
435 
438  }
439 
441  {
442  // Set a Streamer object. The streamer object is now 'owned'
443  // by the TGenericClassInfo.
444 
445  delete fStreamer; fStreamer = 0;
446  if (fClass) {
447  fClass->AdoptStreamer(streamer);
448  } else {
449  fStreamer = streamer;
450  }
451  return 0;
452  }
453 
455  {
456  // Set the CollectProxy object. The CollectionProxy object is now 'owned'
457  // by the TGenericClassInfo.
458 
460  fCollectionProxy = collProxy;
461  if (fClass && fCollectionProxy && !fClass->IsZombie()) {
463  }
464  return 0;
465  }
466 
467  void TGenericClassInfo::SetReadRawRules( const std::vector<Internal::TSchemaHelper>& rules )
468  {
469  // Set the list of Data Model Evolution read rules giving direct access to the TBuffer.
470  fReadRawRules = rules;
471  }
472 
473 
474  void TGenericClassInfo::SetReadRules( const std::vector<Internal::TSchemaHelper>& rules )
475  {
476  // Set the list of Data Model Evolution regular read rules.
477  fReadRules = rules;
478  }
479 
481  {
482  // Set a External Streamer function.
483 
484  delete fStreamer; fStreamer = 0;
485  if (fClass) {
486  fClass->AdoptStreamer(new TClassStreamer(streamer));
487  } else {
488  fStreamer = new TClassStreamer(streamer);
489  }
490  return 0;
491  }
492 
494  {
495  // Set a wrapper around the Streamer member function.
496 
497  fStreamerFunc = streamer;
498  if (fClass) fClass->SetStreamerFunc(streamer);
499  }
500 
502  {
503  // Set a wrapper around the Streamer member function.
504 
505  fConvStreamerFunc = streamer;
506  if (fClass) fClass->SetConvStreamerFunc(streamer);
507  }
508 
510  {
511  // Get the name of the declaring header file.
512 
513  return fDeclFileName;
514  }
515 
517  {
518  // Get the declaring line number.
519 
520  return fDeclFileLine;
521  }
522 
524  {
525  // Get the implementation filename.
526 
528  return fImplFileName;
529  }
530 
532  {
533  // Get the ClassImp line number.
534 
536  return fImplFileLine;
537  }
538 
540  {
541  // Return the class version number.
542 
543  return fVersion;
544  }
545 
546  TClass *TGenericClassInfo::IsA(const void *obj)
547  {
548  // Return the actual type of the object.
549 
550  return (*GetIsA())(obj);
551  }
552 
554  {
555  // Return the IsA proxy.
556 
557  return fIsA;
558  }
559 
561  {
562  // Install a new wrapper around 'new'.
563 
564  fNew = newFunc;
565  if (fClass) fClass->SetNew(fNew);
566  }
567 
569  {
570  // Install a new wrapper around 'new []'.
571 
572  fNewArray = newArrayFunc;
574  }
575 
577  {
578  // Install a new wrapper around 'delete'.
579 
580  fDelete = deleteFunc;
582  }
583 
585  {
586  // Install a new wrapper around 'delete []'.
587 
588  fDeleteArray = deleteArrayFunc;
590  }
591 
593  {
594  // Install a new wrapper around the destructor.
595 
596  fDestructor = destructorFunc;
598  }
599 
601  {
602  // Install a new wrapper around SetDirectoryAutoAdd.
603 
604  fDirAutoAdd = func;
606  }
607 
609  {
610  // Install a new wrapper around the Merge function.
611 
612  fMerge = func;
613  if (fClass) fClass->SetMerge(fMerge);
614  }
615 
617  {
618  // Install a new wrapper around the Merge function.
619 
622  }
623 
625  {
626  // Get the wrapper around 'new'.
627 
628  return fNew;
629  }
630 
632  {
633  // Get the wrapper around 'new []'.
634 
635  return fNewArray;
636  }
637 
639  {
640  // Get the wrapper around 'delete'.
641 
642  return fDelete;
643  }
644 
646  {
647  // Get the wrapper around 'delete []'.
648 
649  return fDeleteArray;
650  }
651 
653  {
654  // Get the wrapper around the destructor.
655 
656  return fDestructor;
657  }
658 
660  {
661  // Get the wrapper around the directory-auto-add function .
662 
663  return fDirAutoAdd;
664  }
665 
666 }
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:382
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:62
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).
Namespace for new ROOT classes and functions.
Definition: StringConv.hxx:21
void SetDelete(DelFunc_t deleteFunc)
TCollection * GetListOfClasses() const
Definition: TROOT.h:235
TLine * line
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:105
void Fatal(const char *location, const char *msgfmt,...)
void SetDeclFile(const char *name, int line)
Definition: TClass.h:482
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:108
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around &#39;delete&#39;.
Definition: TClass.cxx:6554
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:6498
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:6562
#define gROOT
Definition: TROOT.h:375
Basic string class.
Definition: TString.h:129
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:57
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:6447
const TInitBehavior * DefineBehavior(void *, void *)
void SetClassSize(Int_t sizof)
Definition: TClass.h:258
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:687
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
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2640
const char * GetDeclFileName() const
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition: TClass.cxx:6475
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:102
Short_t SetStreamer(ClassStreamerFunc_t)
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:70
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:63
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:109
std::vector< ROOT::Internal::TSchemaHelper > fReadRawRules
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:372
const Internal::TInitBehavior * fAction
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around &#39;new&#39;.
Definition: TClass.cxx:6538
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:103
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRawRules() const
static void SetfgIsA(atomic_TClass_ptr &isA, TClass *(*dictfun)())
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition: TClass.cxx:6570
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:6581
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
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:71
std::atomic< TClass * > atomic_TClass_ptr
Definition: Rtypes.h:187
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:5806
#define R__LOCKGUARD2(mutex)
virtual void Unregister(const char *classname) const =0
std::vector< ROOT::Internal::TSchemaHelper > fReadRules
void(* ReadFuncPtr_t)(char *, TVirtualObject *)
Definition: TSchemaRule.h:42
Bool_t IsZombie() const
Definition: TObject.h:122
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
static std::string GetImpl(const char *derived_funcname)
double func(double *x, double *p)
Definition: stressTF1.cxx:213
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:104
void SetNewArray(NewArrFunc_t newArrayFunc)
Detail::TCollectionProxyInfo * GetCollectionProxyInfo() const
void AddImplFile(const char *filename, int line)
Definition: TClass.cxx:1864
void SetResetAfterMerge(ResetAfterMergeFunc_t)
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:107
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:6522
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:6530
void Destruct(TCppType_t type, TCppObject_t instance)
Definition: Cppyy.cxx:271
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition: TClass.cxx:1844
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:6546
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:91
void AdoptCollectionProxyInfo(Detail::TCollectionProxyInfo *)
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Copy the argument.
Definition: TClass.cxx:2390
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:106
const char * Data() const
Definition: TString.h:347