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"
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 
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;
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 
344  const char *TGenericClassInfo::GetClassName() const
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;;
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) {
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 
511  const char *TGenericClassInfo::GetDeclFileName() const
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 
578  void TGenericClassInfo::SetDelete(DelFunc_t deleteFunc)
579  {
580  // Install a new wrapper around 'delete'.
581 
582  fDelete = deleteFunc;
584  }
585 
586  void TGenericClassInfo::SetDeleteArray(DelArrFunc_t deleteArrayFunc)
587  {
588  // Install a new wrapper around 'delete []'.
589 
590  fDeleteArray = deleteArrayFunc;
592  }
593 
594  void TGenericClassInfo::SetDestructor(DesFunc_t destructorFunc)
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 }
ROOT::TGenericClassInfo::TGenericClassInfo
TGenericClassInfo()
ROOT::TGenericClassInfo::SetDeleteArray
void SetDeleteArray(DelArrFunc_t deleteArrayFunc)
Definition: TGenericClassInfo.cxx:592
ROOT::TGenericClassInfo::SetDelete
void SetDelete(DelFunc_t deleteFunc)
Definition: TGenericClassInfo.cxx:584
ROOT::TSchemaRule::SetReadFunctionPointer
void SetReadFunctionPointer(ReadFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a read rule).
Definition: TSchemaRule.cxx:708
ROOT::TGenericClassInfo::SetConvStreamerFunc
void SetConvStreamerFunc(ClassConvStreamerFunc_t)
Definition: TGenericClassInfo.cxx:509
ROOT::DesFunc_t
void(* DesFunc_t)(void *)
Definition: Rtypes.h:112
ROOT::Internal::TCDGIILIBase::SetName
static void SetName(const std::string &name, std::string &nameMember)
Definition: TGenericClassInfo.cxx:80
TVirtualCollectionProxy.h
ROOT::TGenericClassInfo::Init
void Init(Int_t pragmabits)
Definition: TGenericClassInfo.cxx:202
ROOT::Detail::TCollectionProxyInfo
Definition: TCollectionProxyInfo.h:53
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
ROOT::Internal::DefineBehavior
const TInitBehavior * DefineBehavior(void *, void *)
Definition: TGenericClassInfo.cxx:56
ROOT::TGenericClassInfo::GetReadRawRules
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRawRules() const
Definition: TGenericClassInfo.cxx:379
TClassEdit::GetNormalizedName
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:831
ROOT::TGenericClassInfo::fCollectionProxy
TVirtualCollectionProxy * fCollectionProxy
Definition: TGenericClassInfo.h:67
Warning
void Warning(const char *location, const char *msgfmt,...)
ROOT::ResetAfterMergeFunc_t
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition: Rtypes.h:115
TClass::SetDirectoryAutoAdd
void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc)
Install a new wrapper around the directory auto add function.
Definition: TClass.cxx:6788
ROOT::TGenericClassInfo::fVersion
Int_t fVersion
Definition: TGenericClassInfo.h:55
ROOT::TGenericClassInfo::AdoptCollectionStreamerInfo
void AdoptCollectionStreamerInfo(Detail::TCollectionProxyInfo *)
Definition: TGenericClassInfo.cxx:439
ROOT::TGenericClassInfo::fClassName
const char * fClassName
Definition: TGenericClassInfo.h:47
ROOT::TGenericClassInfo::SetImplFile
Int_t SetImplFile(const char *file, Int_t line)
Definition: TGenericClassInfo.cxx:401
ROOT::TGenericClassInfo::GetClassName
const char * GetClassName() const
Definition: TGenericClassInfo.cxx:350
ROOT::TGenericClassInfo::fMerge
MergeFunc_t fMerge
Definition: TGenericClassInfo.h:56
TClass::SetDestructor
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition: TClass.cxx:6777
ROOT::TGenericClassInfo::fDeclFileLine
Int_t fDeclFileLine
Definition: TGenericClassInfo.h:49
ROOT::DelFunc_t
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
TString::Data
const char * Data() const
Definition: TString.h:369
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:54
ROOT::TGenericClassInfo::fIsA
TVirtualIsAProxy * fIsA
Definition: TGenericClassInfo.h:54
ROOT::TGenericClassInfo::SetVersion
Short_t SetVersion(Short_t version)
Definition: TGenericClassInfo.cxx:421
ROOT::TSchemaRule::SetTargetClass
void SetTargetClass(const TString &classname)
Set the target class of this rule (i.e. the in memory class).
Definition: TSchemaRule.cxx:474
ROOT::TGenericClassInfo::fClass
TClass * fClass
Definition: TGenericClassInfo.h:46
ROOT::TGenericClassInfo::SetDeclFile
Int_t SetDeclFile(const char *file, Int_t line)
Definition: TGenericClassInfo.cxx:411
ROOT::TGenericClassInfo::SetDestructor
void SetDestructor(DesFunc_t destructorFunc)
Definition: TGenericClassInfo.cxx:600
ROOT::TGenericClassInfo::~TGenericClassInfo
~TGenericClassInfo()
Definition: TGenericClassInfo.cxx:216
ROOT::TGenericClassInfo::fReadRules
std::vector< ROOT::Internal::TSchemaHelper > fReadRules
Definition: TGenericClassInfo.h:72
ROOT::TSchemaRule::ReadFuncPtr_t
void(* ReadFuncPtr_t)(char *, TVirtualObject *)
Definition: TSchemaRule.h:40
ROOT::RegisterClassTemplate
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....
Definition: TClassTable.cxx:862
ROOT::TGenericClassInfo::fCollectionStreamerInfo
Detail::TCollectionProxyInfo * fCollectionStreamerInfo
Definition: TGenericClassInfo.h:71
Int_t
int Int_t
Definition: RtypesCore.h:45
ROOT::TGenericClassInfo::GetDeleteArray
DelArrFunc_t GetDeleteArray() const
Definition: TGenericClassInfo.cxx:653
TObject::GetUniqueID
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition: TObject.cxx:377
TROOT::GetListOfClasses
TCollection * GetListOfClasses() const
Definition: TROOT.h:232
ROOT::NewArrFunc_t
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition: Rtypes.h:109
ROOT::TGenericClassInfo::SetStreamerFunc
void SetStreamerFunc(ClassStreamerFunc_t)
Definition: TGenericClassInfo.cxx:501
ROOT::TGenericClassInfo::IsA
TClass * IsA(const void *obj)
Definition: TGenericClassInfo.cxx:554
ROOT::TSchemaRule::SetTarget
void SetTarget(const TString &target)
Set the target member of this rule (i.e. the in memory data member).
Definition: TSchemaRule.cxx:492
TClass.h
TCollectionProxyInfo.h
ROOT::Internal::TInitBehavior
Definition: Rtypes.h:145
ROOT::TGenericClassInfo::GetClass
TClass * GetClass()
Definition: TGenericClassInfo.cxx:237
ROOT::TGenericClassInfo::GetDelete
DelFunc_t GetDelete() const
Definition: TGenericClassInfo.cxx:646
ROOT::TGenericClassInfo::GetIsA
TVirtualIsAProxy * GetIsA() const
Definition: TGenericClassInfo.cxx:561
ROOT::TGenericClassInfo::fDictionary
DictFuncPtr_t fDictionary
Definition: TGenericClassInfo.h:50
ROOT::Internal::GetDemangledTypeName
std::string GetDemangledTypeName(const std::type_info &)
Returns a string with the demangled and normalized name for the given type.
Definition: TGenericClassInfo.cxx:42
TString
Definition: TString.h:136
TClass::GetSchemaRules
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition: TClass.cxx:1881
TStreamer.h
ROOT::TGenericClassInfo::SetDirectoryAutoAdd
void SetDirectoryAutoAdd(DirAutoAdd_t dirAutoAdd)
Definition: TGenericClassInfo.cxx:608
TClass::AddImplFile
void AddImplFile(const char *filename, int line)
Definition: TClass.cxx:1901
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
ROOT::TGenericClassInfo::GetCollectionProxyInfo
Detail::TCollectionProxyInfo * GetCollectionProxyInfo() const
Definition: TGenericClassInfo.cxx:358
ROOT::TGenericClassInfo::GetCollectionStreamerInfo
Detail::TCollectionProxyInfo * GetCollectionStreamerInfo() const
Definition: TGenericClassInfo.cxx:365
TClass::SetNew
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around 'new'.
Definition: TClass.cxx:6745
ROOT::TGenericClassInfo::GetVersion
Int_t GetVersion() const
Definition: TGenericClassInfo.cxx:547
TVirtualIsAProxy.h
ROOT::TSchemaRule::kReadRawRule
@ kReadRawRule
Definition: TSchemaRule.h:36
ROOT::TSchemaRule::ReadRawFuncPtr_t
void(* ReadRawFuncPtr_t)(char *, TBuffer &)
Definition: TSchemaRule.h:41
TClass::SetMerge
void SetMerge(ROOT::MergeFunc_t mergeFunc)
Install a new wrapper around 'Merge'.
Definition: TClass.cxx:6729
ROOT::TSchemaRule::SetVersion
Bool_t SetVersion(const TString &version)
Set the version string - returns kFALSE if the format is incorrect.
Definition: TSchemaRule.cxx:381
ROOT::DirAutoAdd_t
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition: Rtypes.h:113
ROOT::TSchemaRule::SetSource
void SetSource(const TString &source)
Set the list of source members.
Definition: TSchemaRule.cxx:538
ClassStreamerFunc_t
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition: Rtypes.h:72
TROOT.h
TClassTable::kHasCustomStreamerMember
@ kHasCustomStreamerMember
Definition: TClassTable.h:65
ROOT::TSchemaRule
Definition: TSchemaRule.h:19
TClass::CopyCollectionProxy
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Copy the argument.
Definition: TClass.cxx:2427
ROOT::TGenericClassInfo::fCollectionProxyInfo
Detail::TCollectionProxyInfo * fCollectionProxyInfo
Definition: TGenericClassInfo.h:70
TClass::SetClassSize
void SetClassSize(Int_t sizof)
Definition: TClass.h:278
TClassEdit::DemangleName
char * DemangleName(const char *mangled_name, int &errorCode)
Definition: TClassEdit.h:205
ROOT::Internal::TInitBehavior::Register
virtual void Register(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits) const =0
TClass::SetCollectionProxy
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:6010
ROOT::MergeFunc_t
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition: Rtypes.h:114
ROOT::Internal::TCDGIILIBase::SetfgIsA
static void SetfgIsA(atomic_TClass_ptr &isA, TClass *(*dictfun)())
Definition: TGenericClassInfo.cxx:88
ROOT::TGenericClassInfo::GetNew
NewFunc_t GetNew() const
Definition: TGenericClassInfo.cxx:632
ROOT::DelArrFunc_t
void(* DelArrFunc_t)(void *)
Definition: Rtypes.h:111
TClass::SetResetAfterMerge
void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc)
Install a new wrapper around 'ResetAfterMerge'.
Definition: TClass.cxx:6737
TSchemaRule.h
TClass::AdoptStreamer
void AdoptStreamer(TClassStreamer *strm)
Adopt a TClassStreamer object.
Definition: TClass.cxx:6654
TClassTable.h
ROOT::TGenericClassInfo::fDeclFileName
const char * fDeclFileName
Definition: TGenericClassInfo.h:48
ROOT::TGenericClassInfo::fPragmaBits
Int_t fPragmaBits
Definition: TGenericClassInfo.h:69
ROOT::TSchemaRule::SetChecksum
Bool_t SetChecksum(const TString &checksum)
Set the checksum string - returns kFALSE if the format is incorrect.
Definition: TSchemaRule.cxx:425
ROOT::TGenericClassInfo::SetResetAfterMerge
void SetResetAfterMerge(ResetAfterMergeFunc_t)
Definition: TGenericClassInfo.cxx:624
ROOT::TGenericClassInfo::GetImplFileName
const char * GetImplFileName()
Definition: TGenericClassInfo.cxx:531
ROOT::TGenericClassInfo::AdoptCollectionProxy
Short_t AdoptCollectionProxy(TVirtualCollectionProxy *)
Definition: TGenericClassInfo.cxx:462
gInterpreterMutex
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:43
gROOTMutex
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:61
ROOT::TGenericClassInfo::GetDestructor
DesFunc_t GetDestructor() const
Definition: TGenericClassInfo.cxx:660
ROOT::TGenericClassInfo::SetReadRawRules
void SetReadRawRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
Definition: TGenericClassInfo.cxx:475
ROOT::TGenericClassInfo::fDeleteArray
DelArrFunc_t fDeleteArray
Definition: TGenericClassInfo.h:61
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
ROOT::TGenericClassInfo::fImplFileLine
Int_t fImplFileLine
Definition: TGenericClassInfo.h:53
ROOT::TGenericClassInfo::GetDeclFileName
const char * GetDeclFileName() const
Definition: TGenericClassInfo.cxx:517
TROOT::Initialized
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2813
ROOT::TSchemaRule::SetSourceClass
void SetSourceClass(const TString &classname)
Set the source class of this rule (i.e. the onfile class).
Definition: TSchemaRule.cxx:456
TNamed
Definition: TNamed.h:29
ROOT::TGenericClassInfo::fAction
const Internal::TInitBehavior * fAction
Definition: TGenericClassInfo.h:45
Fatal
void Fatal(const char *location, const char *msgfmt,...)
ROOT::Internal::TCDGIILIBase::SetInstance
static void SetInstance(::ROOT::TGenericClassInfo &R__instance, NewFunc_t, NewArrFunc_t, DelFunc_t, DelArrFunc_t, DesFunc_t)
Definition: TGenericClassInfo.cxx:67
ROOT::TGenericClassInfo::fImplFileName
const char * fImplFileName
Definition: TGenericClassInfo.h:52
ROOT::TGenericClassInfo::GetDeclFileLine
Int_t GetDeclFileLine() const
Definition: TGenericClassInfo.cxx:524
TClass::SetDelete
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around 'delete'.
Definition: TClass.cxx:6761
R__LOCKGUARD
#define R__LOCKGUARD(mutex)
Definition: TVirtualMutex.h:104
ROOT::TGenericClassInfo::fNewArray
NewArrFunc_t fNewArray
Definition: TGenericClassInfo.h:59
TClass::SetConvStreamerFunc
void SetConvStreamerFunc(ClassConvStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom conversion streamer.
Definition: TClass.cxx:6705
ROOT::Internal::gROOTLocal
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:379
Short_t
short Short_t
Definition: RtypesCore.h:39
ROOT::TGenericClassInfo::GetImplFileLine
Int_t GetImplFileLine()
Definition: TGenericClassInfo.cxx:539
Cppyy::Destruct
RPY_EXPORTED void Destruct(TCppType_t type, TCppObject_t instance)
Definition: clingwrapper.cxx:680
TClass::kHasCustomStreamerMember
@ kHasCustomStreamerMember
Definition: TClass.h:104
line
TLine * line
Definition: entrylistblock_figure1.C:235
TVirtualMutex.h
ROOT::TSchemaRule::SetAttributes
void SetAttributes(const TString &attributes)
Set the attributes code of this rule.
Definition: TSchemaRule.cxx:656
fClass
Cppyy::TCppType_t fClass
Definition: DeclareConverters.h:259
TClass::SetDeclFile
void SetDeclFile(const char *name, int line)
Definition: TClass.h:499
ROOT::TGenericClassInfo::fStreamerFunc
ClassStreamerFunc_t fStreamerFunc
Definition: TGenericClassInfo.h:65
TVirtualStreamerInfo.h
TObject::IsZombie
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition: TObject.h:134
ROOT::TSchemaRule::kReadRule
@ kReadRule
Definition: TSchemaRule.h:35
ROOT::TGenericClassInfo::fDestructor
DesFunc_t fDestructor
Definition: TGenericClassInfo.h:62
ROOT::TGenericClassInfo::SetStreamer
Short_t SetStreamer(ClassStreamerFunc_t)
Definition: TGenericClassInfo.cxx:488
ROOT::TGenericClassInfo::fConvStreamerFunc
ClassConvStreamerFunc_t fConvStreamerFunc
Definition: TGenericClassInfo.h:66
ROOT::TSchemaRule::SetCode
void SetCode(const TString &code)
Set the source code of this rule.
Definition: TSchemaRule.cxx:640
ROOT::TGenericClassInfo::GetAction
const Internal::TInitBehavior & GetAction() const
Definition: TGenericClassInfo.cxx:230
TClass::SetDeleteArray
void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
Install a new wrapper around 'delete []'.
Definition: TClass.cxx:6769
ROOT::TGenericClassInfo::SetNewArray
void SetNewArray(NewArrFunc_t newArrayFunc)
Definition: TGenericClassInfo.cxx:576
TClassEdit.h
ROOT::Detail::TSchemaRuleSet::kCheckAll
@ kCheckAll
Definition: TSchemaRuleSet.h:40
ROOT::TGenericClassInfo::fNew
NewFunc_t fNew
Definition: TGenericClassInfo.h:58
ROOT::TGenericClassInfo::fInfo
const std::type_info & fInfo
Definition: TGenericClassInfo.h:51
ROOT::TGenericClassInfo::GetInfo
const std::type_info & GetInfo() const
Definition: TGenericClassInfo.cxx:372
TInterpreter.h
TClass
Definition: TClass.h:80
file
Definition: file.py:1
TClass::SetNewArray
void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
Install a new wrapper around 'new []'.
Definition: TClass.cxx:6753
ROOT::TGenericClassInfo::fSizeof
Int_t fSizeof
Definition: TGenericClassInfo.h:68
ROOT::TGenericClassInfo::CreateRuleSet
void CreateRuleSet(std::vector< ROOT::Internal::TSchemaHelper > &vect, Bool_t ProcessReadRules)
Attach the schema evolution information to TClassObject.
Definition: TGenericClassInfo.cxx:301
ROOT::TGenericClassInfo
Definition: TGenericClassInfo.h:40
ROOT::TGenericClassInfo::fResetAfterMerge
ResetAfterMergeFunc_t fResetAfterMerge
Definition: TGenericClassInfo.h:57
ClassConvStreamerFunc_t
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition: Rtypes.h:73
ROOT::TSchemaRule::SetInclude
void SetInclude(const TString &include)
Set the comma separated list of header files to include to be able to compile this rule.
Definition: TSchemaRule.cxx:577
ROOT::Internal::TDefaultInitBehavior
Definition: Rtypes.h:163
TClassEdit::Init
void Init(TClassEdit::TInterpreterLookupHelper *helper)
Definition: TClassEdit.cxx:154
name
char name[80]
Definition: TGX11.cxx:110
TSchemaRuleSet.h
ROOT::TGenericClassInfo::SetMerge
void SetMerge(MergeFunc_t)
Definition: TGenericClassInfo.cxx:616
ROOT::NewFunc_t
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:108
ROOT::TGenericClassInfo::GetDirectoryAutoAdd
DirAutoAdd_t GetDirectoryAutoAdd() const
Definition: TGenericClassInfo.cxx:667
ROOT::TGenericClassInfo::SetReadRules
void SetReadRules(const std::vector< ROOT::Internal::TSchemaHelper > &rules)
Definition: TGenericClassInfo.cxx:482
ROOT::ResetClassVersion
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
Definition: TClassTable.cxx:805
ROOT::TGenericClassInfo::GetNewArray
NewArrFunc_t GetNewArray() const
Definition: TGenericClassInfo.cxx:639
ROOT::TGenericClassInfo::fStreamer
TClassStreamer * fStreamer
Definition: TGenericClassInfo.h:64
TClassStreamer
Definition: TClassStreamer.h:26
ROOT::TSchemaRule::SetRuleType
void SetRuleType(RuleType_t type)
Set the type of the rule.
Definition: TSchemaRule.cxx:740
DictFuncPtr_t
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:80
TVirtualIsAProxy
Definition: TVirtualIsAProxy.h:27
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
ROOT::TGenericClassInfo::SetFromTemplate
void SetFromTemplate()
Definition: TGenericClassInfo.cxx:393
free
#define free
Definition: civetweb.c:1539
ROOT::TSchemaRule::SetEmbed
void SetEmbed(Bool_t embed)
Set whether this rule should be save in the ROOT file (if true)
Definition: TSchemaRule.cxx:616
TClass::SetStreamerFunc
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition: TClass.cxx:6682
ROOT::TGenericClassInfo::GetReadRules
const std::vector< ROOT::Internal::TSchemaHelper > & GetReadRules() const
Definition: TGenericClassInfo.cxx:387
ROOT::TGenericClassInfo::AdoptStreamer
Short_t AdoptStreamer(TClassStreamer *)
Definition: TGenericClassInfo.cxx:448
ROOT::Internal::TInitBehavior::CreateClass
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
ROOT::Internal::TInitBehavior::Unregister
virtual void Unregister(const char *classname) const =0
ROOT::TGenericClassInfo::SetNew
void SetNew(NewFunc_t newFunc)
Definition: TGenericClassInfo.cxx:568
ROOT::TGenericClassInfo::fDelete
DelFunc_t fDelete
Definition: TGenericClassInfo.h:60
ROOT::TGenericClassInfo::fReadRawRules
std::vector< ROOT::Internal::TSchemaHelper > fReadRawRules
Definition: TGenericClassInfo.h:73
ROOT::Detail::TSchemaRuleSet::AddRule
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...
Definition: TSchemaRuleSet.cxx:81
ROOT
VSD Structures.
Definition: StringConv.hxx:21
ROOT::TSchemaRule::SetReadRawFunctionPointer
void SetReadRawFunctionPointer(ReadRawFuncPtr_t ptr)
Set the pointer to the function to be run for the rule (if it is a raw read rule).
Definition: TSchemaRule.cxx:724
ROOT::Detail::TSchemaRuleSet
Definition: TSchemaRuleSet.h:24
TVirtualCollectionProxy
Definition: TVirtualCollectionProxy.h:38
atomic_TClass_ptr
std::atomic< TClass * > atomic_TClass_ptr
Definition: Rtypes.h:193
gROOT
#define gROOT
Definition: TROOT.h:406
int
TError.h
ROOT::TGenericClassInfo::AdoptCollectionProxyInfo
void AdoptCollectionProxyInfo(Detail::TCollectionProxyInfo *)
Definition: TGenericClassInfo.cxx:430
ROOT::TGenericClassInfo::fDirAutoAdd
DirAutoAdd_t fDirAutoAdd
Definition: TGenericClassInfo.h:63