Logo ROOT   6.14/05
Reference Guide
TProtoClass.cxx
Go to the documentation of this file.
1 // @(#)root/meta:$
2 // Author: Axel Naumann 2014-05-02
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2014, Rene Brun and Fons Rademakers. *
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 /** \class TProtoClass
13 Persistent version of a TClass.
14 */
15 
16 #include "TProtoClass.h"
17 
18 #include "TBaseClass.h"
19 #include "TClass.h"
20 #include "TClassEdit.h"
21 #include "TDataMember.h"
22 #include "TEnum.h"
23 #include "TInterpreter.h"
24 #include "TList.h"
25 #include "TListOfDataMembers.h"
26 #include "TListOfEnums.h"
27 #include "TRealData.h"
28 #include "TError.h"
29 
30 #include <cassert>
31 
32 ////////////////////////////////////////////////////////////////////////////////
33 /// Initialize a TProtoClass from a TClass.
34 
36  TNamed(*cl), fBase(cl->GetListOfBases()),
37  fEnums(cl->GetListOfEnums()), fSizeof(cl->Size()), fCheckSum(cl->fCheckSum),
38  fCanSplit(cl->fCanSplit), fStreamerType(cl->fStreamerType), fProperty(cl->fProperty),
39  fClassProperty(cl->fClassProperty)
40 {
41  if (cl->Property() & kIsNamespace){
42  //fData=new TListOfDataMembers();
43  fEnums=nullptr;
44  //fPRealData=nullptr;
46  return;
47  }
48  TListOfEnums *enums = dynamic_cast<TListOfEnums*>(fEnums);
49  if (enums && !enums->fIsLoaded) {
50  // Make sure all the enum information is loaded
51  enums->Load();
52  }
53  // initialize list of data members (fData)
54  TList * dataMembers = cl->GetListOfDataMembers();
55  if (dataMembers && dataMembers->GetSize() > 0) {
56  fData.reserve(dataMembers->GetSize() );
57  for (auto * obj : *dataMembers) {
58  TDataMember * dm = dynamic_cast<TDataMember*>(obj);
59  fData.push_back(dm);
60  }
61  }
62 
63  fPRealData.reserve(100);
64 
65  if (!cl->GetCollectionProxy()) {
66  // Build the list of RealData before we access it:
67  cl->BuildRealData(0, true /*isTransient*/);
68  // The data members are ordered as follows:
69  // - this class's data members,
70  // - foreach base: base class's data members.
71  // fPRealData encodes all TProtoRealData objects with a
72  // TObjString to signal a new class.
73  TClass* clCurrent = cl;
74  fDepClasses.push_back(cl->GetName() );
75  TRealData* precRd = nullptr;
76  for (auto realDataObj: *cl->GetListOfRealData()) {
77  TRealData *rd = (TRealData*)realDataObj;
78  if (!precRd) precRd = rd;
79  TClass* clRD = rd->GetDataMember()->GetClass();
80  TProtoRealData protoRealData(rd);
81  if (clRD != clCurrent) {
82  // here I have a new class
83  fDepClasses.push_back(clRD->GetName() );
84  clCurrent = clRD;
85  protoRealData.fClassIndex = fDepClasses.size()-1;
86  //protoRealData.fClass = clRD->GetName();
87  //TObjString *clstr = new TObjString(clRD->GetName());
88  if (rd->TestBit(TRealData::kTransient)) {
89  //clstr->SetBit(TRealData::kTransient);
90  protoRealData.SetFlag(TProtoRealData::kIsTransient,true);
91  }
92  else
93  protoRealData.SetFlag(TProtoRealData::kIsTransient,false);
94 
95  // fPRealData->AddLast(clstr);
96  precRd = rd;
97  }
98  //fPRealData->AddLast(new TProtoRealData(rd));
99  fPRealData.push_back(protoRealData);
100  }
101 
102  // if (gDebug > 2) {
103  // for (const auto &data : fPRealData) {
104  // const auto classType = dataPtr->IsA();
105  // const auto dataName = data.fName;
106  // const auto dataClass = data.fClass;
107  // Info("TProtoClass","Data is a protorealdata: %s - class %s - transient %d", dataName.Data(),dataClass.Data(),data.fIsTransient);
108  //if (!dataClass.IsNull()
109  // if (classType == TProtoRealData::Class())
110  // Info("TProtoClass","Data is a protorealdata: %s", dataPtrName);
111  // if (classType == TObjString::Class())
112  // Info("TProtoClass","Data is a objectstring: %s", dataPtrName);
113  // if (dataPtr->TestBit(TRealData::kTransient))
114  // Info("TProtoClass","And is transient");
115  // }
116  // }
117  }
118 
119  // this crashes
122 }
123 
124 // // conversion of a new TProtoClass from an old TProtoClass
125 // //______________________________________________________________________________
126 // TProtoClass::TProtoClass(TProtoClassOld * pc):
127 // TNamed(pc->GetName(),pc->GetTitle()), fBase(pc->fBase),
128 // fEnums(pc->fEnums), fSizeof(pc->fSizeof), fCanSplit(pc->fCanSplit),
129 // fStreamerType(pc->fStreamerType), fProperty(pc->fProperty),
130 // fClassProperty(pc->fClassProperty), fOffsetStreamer( pc->fOffsetStreamer)
131 // {
132 
133 // fBase = (pc->fBase) ? (TList*) pc->fBase->Clone() : 0;
134 // //fData = (pc->fData) ? (TList*) pc->fData->Clone() : 0;
135 // fEnums = (pc->fEnums) ? (TList*) pc->fEnums->Clone() : 0;
136 
137 // // initialize list of data members (fData)
138 // TList * dataMembers = pc->fData;
139 // if (dataMembers && dataMembers->GetSize() > 0) {
140 // fData.reserve(dataMembers->GetSize() );
141 // for (auto * obj : *dataMembers) {
142 // TDataMember * dm = dynamic_cast<TDataMember*>(obj);
143 // if (dm) {
144 // TDataMember * dm2 = (TDataMember *) dm->Clone();
145 // if (dm2) fData.push_back(dm2);
146 // }
147 // }
148 // }
149 
150 // fPRealData.reserve(100);
151 
152 // TString className;
153 // for (auto dataPtr : *(pc->fPRealData) ) {
154 
155 // const auto classType = dataPtr->IsA();
156 // if (classType == TObjString::Class()) {
157 // className = dataPtr->GetName();
158 // }
159 // else if (classType == TProtoClass::TProtoRealData::Class()) {
160 // TProtoRealData protoRealData;
161 // TProtoClass::TProtoRealData * oldData= ( TProtoClass::TProtoRealData * )dataPtr;
162 // TClass * cl = TClass::GetClass(className);
163 // //protoRealData.fName = dataPtr->GetName();
164 // //TObject * obj = cl->GetListOfDataMembers()->FindObject( );
165 // protoRealData.fDMIndex = DataMemberIndex(cl, dataPtr->GetName() );
166 // // protoRealData.fTitle = dataPtr->GetTitle();
167 // //protoRealData.fClass = className;
168 // className.Clear();
169 // protoRealData.fIsTransient = dataPtr->TestBit(TRealData::kTransient);
170 // protoRealData.fOffset = oldData->GetOffset();
171 // protoRealData.fIsObject = dataPtr->TestBit(BIT(15));
172 // fPRealData.push_back(protoRealData);
173 // }
174 // }
175 // }
176 
177 ////////////////////////////////////////////////////////////////////////////////
178 /// Destructor.
179 
181 {
182  Delete();
183 }
184 
185 ////////////////////////////////////////////////////////////////////////////////
186 /// Delete the containers that are usually owned by their TClass.
187 /// if (fPRealData) fPRealData->Delete(opt);
188 /// delete fPRealData; fPRealData = 0;
189 
190 void TProtoClass::Delete(Option_t* opt /*= ""*/) {
191  if (fBase) fBase->Delete(opt);
192  delete fBase; fBase = 0;
193 
194  for (auto dm: fData) {
195  delete dm;
196  }
197 
198  if (fEnums) fEnums->Delete(opt);
199  delete fEnums; fEnums = 0;
200 
201  if (gErrorIgnoreLevel==-2) printf("Delete the protoClass %s \n",GetName());
202 }
203 
204 ////////////////////////////////////////////////////////////////////////////////
205 /// Move data from this TProtoClass into cl.
206 /// Returns 'false' if nothing was done. This can happen in the case where
207 /// there is more than one dictionary for the same entity. Note having
208 /// duplicate dictionary is acceptable for namespace or STL collections.
209 
211  if (cl->fRealData || cl->fBase.load() || cl->fData || cl->fEnums.load() || cl->fSizeof != -1 || cl->fCanSplit >= 0 ||
212  cl->fProperty != (-1)) {
213 
214  if (cl->GetCollectionType() != ROOT::kNotSTL) {
215  // We are in the case of collection, duplicate dictionary are allowed
216  // (and even somewhat excepted since they can be auto asked for).
217  // They do not always have a TProtoClass for them. In particular
218  // the one that are pre-generated in the ROOT build (in what was once
219  // called the cintdlls) do not have a pcms, neither does vector<string>
220  // which is part of libCore proper.
221  if (gDebug > 0)
222  Info("FillTClass", "Returning w/o doing anything. %s is a STL collection.",cl->GetName());
223  return kFALSE;
224  }
225  if (cl->Property() & kIsNamespace) {
226  if (gDebug > 0)
227  Info("FillTClass", "Returning w/o doing anything. %s is a namespace.",cl->GetName());
228  return kFALSE;
229  }
230  Error("FillTClass", "TClass %s already initialized!", cl->GetName());
231  return kFALSE;
232  }
233  if (gDebug > 1) Info("FillTClass","Loading TProtoClass for %s - %s",cl->GetName(),GetName());
234 
235  if (fPRealData.size() > 0) {
236 
237  // A first loop to retrieve the mother classes before starting to
238  // fill this TClass instance. This is done in order to avoid recursions
239  // for example in presence of daughter and mother class present in two
240  // dictionaries compiled in two different libraries which are not linked
241  // one with each other.
242  for (auto element: fPRealData) {
243  //if (element->IsA() == TObjString::Class()) {
244  if (element.IsAClass() ) {
245  if (gDebug > 1) Info("","Treating beforehand mother class %s",GetClassName(element.fClassIndex));
246  //int autoloadingOldval=gInterpreter->SetClassAutoloading(false);
248 
249  TClass::GetClass(GetClassName(element.fClassIndex));
250 
251  //gInterpreter->SetClassAutoloading(autoloadingOldval);
252  }
253  }
254  }
255 
256 
257  //this->Dump();
258 
259  // Copy only the TClass bits.
260  // not bit 13 and below and not bit 24 and above, just Bits 14 - 23
261  UInt_t newbits = TestBits(0x00ffc000);
262  cl->ResetBit(0x00ffc000);
263  cl->SetBit(newbits);
264 
265  cl->fName = this->fName;
266  cl->fTitle = this->fTitle;
267  cl->fBase = fBase;
268 
269  // fill list of data members in TClass
270  //if (cl->fData) { cl->fData->Delete(); delete cl->fData; }
271  cl->fData = new TListOfDataMembers(fData);
272  // for (auto * dataMember : fData) {
273  // //printf("add data member for class %s - member %s \n",GetName(), dataMember->GetName() );
274  // cl->fData->Add(dataMember);
275  // }
276  // // set loaded bit to true to avoid re-loading the data members
277  // cl->fData->SetIsLoaded();*
278 
279  //cl->fData = (TListOfDataMembers*)fData;
280 
281  // The TDataMember were passed along.
282  fData.clear();
283 
284  // We need to fill enums one by one to initialise the internal map which is
285  // transient
286  {
287  auto temp = new TListOfEnums();
288  if (fEnums) {
289  for (TObject* enumAsTObj : *fEnums){
290  temp->Add((TEnum*) enumAsTObj);
291  }
292  // We did not transfer the container itself, let remove it from memory without deleting its content.
293  fEnums->Clear();
294  delete fEnums;
295  fEnums = nullptr;
296  }
297  cl->fEnums = temp;
298  }
299 
300  cl->fSizeof = fSizeof;
301  cl->fCheckSum = fCheckSum;
302  cl->fCanSplit = fCanSplit;
303  cl->fProperty = fProperty;
306 
307  // Update pointers to TClass
308  if (cl->fBase.load()) {
309  for (auto base: *cl->fBase) {
310  ((TBaseClass*)base)->SetClass(cl);
311  }
312  }
313  if (cl->fData) {
314  for (auto dm: *cl->fData) {
315  ((TDataMember*)dm)->SetClass(cl);
316  }
317  ((TListOfDataMembers*)cl->fData)->SetClass(cl);
318  }
319  if (cl->fEnums.load()) {
320  for (auto en: *cl->fEnums) {
321  ((TEnum*)en)->SetClass(cl);
322  }
323  ((TListOfEnums*)cl->fEnums)->SetClass(cl);
324  }
325 
326 
327  TClass* currentRDClass = cl;
328  TRealData * prevRealData = 0;
329  int prevLevel = 0;
330  bool first = true;
331  if (fPRealData.size() > 0) {
332  for (auto element: fPRealData) {
333  //if (element->IsA() == TObjString::Class()) {
334  if (element.IsAClass() ) {
335  // We now check for the TClass entry, w/o loading. Indeed we did that above.
336  // If the class is not found, it means that really it was not selected and we
337  // replace it with an empty placeholder with the status of kForwardDeclared.
338  // Interactivity will be of course possible but if IO is attempted, a warning
339  // will be issued.
341 
342  // Disable autoparsing which might be triggered by the use of ResolvedTypedef
343  // and the fallback new TClass() below.
344  currentRDClass = TClass::GetClass(GetClassName(element.fClassIndex), false /* Load */ );
345  //printf("element is a class - name %s - index %d %s \n ",currentRDClass->GetName(), element.fClassIndex, GetClassName(element.fClassIndex) );
346  if (!currentRDClass && !element.TestFlag(TProtoRealData::kIsTransient)) {
347  if (gDebug>1)
348  Info("FillTClass()",
349  "Cannot find TClass for %s; Creating an empty one in the kForwardDeclared state.",
350  GetClassName(element.fClassIndex));
351  currentRDClass = new TClass(GetClassName(element.fClassIndex),1,TClass::kForwardDeclared, true /*silent*/);
352  }
353  }
354  //else {
355  if (!currentRDClass) continue;
356  //TProtoRealData* prd = (TProtoRealData*)element;
357  // pass a previous real data only if depth
358 
359  if (TRealData* rd = element.CreateRealData(currentRDClass, cl,prevRealData, prevLevel)) {
360  if (first) {
361  //LM: need to do here because somehow fRealData is destroyed when calling TClass::GetListOfDataMembers()
362  if (cl->fRealData) {
363  Info("FillTClass","Real data for class %s is not empty - make a new one",cl->GetName() );
364  delete cl->fRealData;
365  }
366  cl->fRealData = new TList(); // FIXME: this should really become a THashList!
367  first = false;
368  }
369 
370  cl->fRealData->AddLast(rd);
371  prevRealData = rd;
372  prevLevel = element.fLevel;
373 
374  }
375  //}
376  }
377  }
378  else {
379  if (cl->fRealData) {
380  Info("FillTClas","Real data for class %s is not empty - make a new one. Class has no Proto-realdata",cl->GetName() );
381  delete cl->fRealData;
382  }
383  cl->fRealData = new TList(); // FIXME: this should really become a THashList!
384  }
385 
386  cl->SetStreamerImpl();
387 
388  // set to zero in order not to delete when protoclass is deleted
389  fBase = 0;
390  //fData = 0;
391  fEnums = 0;
392 
393  fPRealData.clear();
394  fPRealData.shrink_to_fit(); // to reset the underlying allocate space
395 
396  // if (fPRealData) fPRealData->Delete();
397  // delete fPRealData;
398  // fPRealData = 0;
399 
400  return kTRUE;
401 }
402 
403 ////////////////////////////////////////////////////////////////////////////////
404 
406  //TNamed(rd->GetDataMember()->GetName(), rd->GetName()),
407  //TNamed(),
408  //fName(rd->GetDataMember()->GetName()),
409  //fTitle(rd->GetName()),
410  fOffset(rd->GetThisOffset()),
411  fDMIndex(-1),
412  fLevel(0),
413  fClassIndex(-1),
414  fStatusFlag(0)
415 {
416  TDataMember * dm = rd->GetDataMember();
417  TClass * cl = dm->GetClass();
418  assert(cl != NULL);
419  fDMIndex = DataMemberIndex(cl,dm->GetName());
420  //printf("Index of data member %s for class %s is %d \n",dm->GetName(), cl->GetName() , fDMIndex);
421  TString fullDataMemberName = rd->GetName(); // full data member name (e.g. fXaxis.fNbins)
422  fLevel = fullDataMemberName.CountChar('.');
423 
424  if (fullDataMemberName.Contains("*") ) SetFlag(kIsPointer);
425 
426  // Initialize this from a TRealData object.
427  SetFlag(kIsObject, rd->IsObject());
429 }
430 
431 ////////////////////////////////////////////////////////////////////////////////
432 /// Destructor to pin vtable.
433 ///if (gErrorIgnoreLevel==-2) printf("destroy real data %s - ",GetName());
434 
436 {
437 }
438 
439 ////////////////////////////////////////////////////////////////////////////////
440 /// Create a TRealData from this, with its data member coming from dmClass.
441 /// find data member from protoclass
442 
444  TClass* parent, TRealData *prevData, int prevLevel) const
445 {
446 
447  //TDataMember* dm = (TDataMember*)dmClass->GetListOfDataMembers()->FindObject(fName);
449 
450  if (!dm && dmClass->GetState()!=TClass::kForwardDeclared) {
451  ::Error("CreateRealData",
452  "Cannot find data member # %d of class %s for parent %s!", fDMIndex, dmClass->GetName(),
453  parent->GetName());
454  return nullptr;
455  }
456 
457  // here I need to re-construct the realdata full name (e.g. fAxis.fNbins)
458 
459  TString realMemberName;
460  // keep an empty name if data member is not found
461  if (dm) realMemberName = dm->GetName();
462  if (TestFlag(kIsPointer) )
463  realMemberName = TString("*")+realMemberName;
464  else if (dm){
465  if (dm->GetArrayDim() > 0) {
466  // in case of array (like fMatrix[2][2] we need to add max index )
467  // this only in case of it os not a pointer
468  for (int idim = 0; idim < dm->GetArrayDim(); ++idim)
469  realMemberName += TString::Format("[%d]",dm->GetMaxIndex(idim) );
470  } else if (TClassEdit::IsStdArray(dm->GetTypeName())) {
471  std::string typeNameBuf;
472  Int_t ndim = dm->GetArrayDim();
473  std::array<Int_t, 5> maxIndices; // 5 is the maximum supported in TStreamerElement::SetMaxIndex
475  typeNameBuf,
476  maxIndices,
477  ndim);
478  for (Int_t idim = 0; idim < ndim; ++idim) {
479  realMemberName += TString::Format("[%d]",maxIndices[idim] );
480  }
481  }
482  }
483 
484  if (prevData && fLevel > 0 ) {
485  if (fLevel-prevLevel == 1) // I am going down 1 level
486  realMemberName = TString::Format("%s.%s",prevData->GetName(), realMemberName.Data() );
487  else if (fLevel <= prevLevel) { // I am at the same level
488  // need to strip out prev name
489  std::string prevName = prevData->GetName();
490  // we strip the prev data member name from the full name
491  std::string parentName;
492  for (int i = 0; i < prevLevel-fLevel+1; ++i) {
493  parentName = prevName.substr(0, prevName.find_last_of(".") );
494  prevName = parentName;
495  }
496 
497  // now we need to add the current name
498  realMemberName = TString::Format("%s.%s",parentName.c_str(), realMemberName.Data() );
499  }
500  }
501 
502  //printf("adding new realdata for class %s : %s - %s %d %d \n",dmClass->GetName(), realMemberName.Data(), dm->GetName(),fLevel, fDMIndex );
503 
504  TRealData* rd = new TRealData(realMemberName, fOffset, dm);
505  if (TestFlag(kIsTransient)) {
506  rd->SetBit(TRealData::kTransient);
507  }
508  rd->SetIsObject(TestFlag(kIsObject) );
509  return rd;
510 }
511 
512 ////////////////////////////////////////////////////////////////////////////////
513 
515 {
516  TList * dmList = cl->GetListOfDataMembers();
517 
518  // we cannot use IndexOf because order is guaranteed only for non-static data member
519  Int_t index = 0;
520  for ( auto * obj : *dmList) {
521  TDataMember * dm = (TDataMember *) obj;
522  if (!dm ) continue;
523  if (dm->Property() & kIsStatic) continue;
524  if ( TString(dm->GetName()) == TString(name) )
525  return index;
526  index++;
527  }
528  ::Error("TProtoClass::DataMemberIndex","data member %s is not found in class %s",name, cl->GetName());
529  dmList->ls();
530  return -1;
531 }
532 ////////////////////////////////////////////////////////////////////////////////
533 
535 {
536  TList * dmList = cl->GetListOfDataMembers(false);
537 
538  // we cannot use IndexOf because order is guaranteed only for non-static data member
539  Int_t i = 0;
540  for ( auto * obj : *dmList) {
541  TDataMember * dm = (TDataMember *) obj;
542  if (!dm ) continue;
543  if (dm->Property() & kIsStatic) continue;
544  if (i == index)
545  return dm;
546  i++;
547  }
549  ::Error("TProtoClass::FindDataMember","data member with index %d is not found in class %s",index,cl->GetName());
550  return nullptr;
551 }
TString fTitle
Definition: TNamed.h:33
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
The TEnum class implements the enum type.
Definition: TEnum.h:31
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:467
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:854
Long_t fProperty
Definition: TProtoClass.h:79
Bool_t fIsLoaded
Holder of TEnum for unloaded Enums.
Definition: TListOfEnums.h:44
R__EXTERN Int_t gErrorIgnoreLevel
Definition: TError.h:105
const char Option_t
Definition: RtypesCore.h:62
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
const char * Size
Definition: TXMLSetup.cxx:55
const char * GetClassName(Int_t index) const
Definition: TProtoClass.h:86
std::atomic< TListOfEnums * > fEnums
Definition: TClass.h:179
const char * GetTypeName() const
Get type of data member, e,g.: "class TDirectory*" -> "TDirectory".
UInt_t fCheckSum
Definition: TProtoClass.h:76
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
Definition: TClass.cxx:3617
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
Int_t TestBits(UInt_t f) const
Definition: TObject.h:173
Basic string class.
Definition: TString.h:131
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition: TClass.cxx:2816
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
#define gInterpreter
Definition: TInterpreter.h:527
Int_t fStreamerType
saved info to call Streamer
Definition: TClass.h:241
TList * fEnums
Definition: TProtoClass.h:71
Int_t fStreamerType
Definition: TProtoClass.h:78
Bool_t TestFlag(UInt_t f) const
Definition: TProtoClass.h:58
virtual void AddLast(TObject *obj)
Add object at the end of the list.
Definition: TList.cxx:149
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
void Delete(Option_t *opt="")
Delete the containers that are usually owned by their TClass.
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
Definition: TString.cxx:2286
Bool_t FillTClass(TClass *pcl)
Move data from this TProtoClass into cl.
std::atomic< TList * > fBase
Definition: TClass.h:176
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
std::vector< TDataMember * > fData
Definition: TProtoClass.h:73
virtual ~TProtoRealData()
Destructor to pin vtable.
Long_t Property() const
Get property description word. For meaning of bits see EProperty.
EState GetState() const
Definition: TClass.h:453
bool IsStdArray(std::string_view name)
Definition: TClassEdit.h:183
Int_t fCanSplit
Definition: TProtoClass.h:77
TList * fRealData
Definition: TClass.h:175
Int_t GetMaxIndex(Int_t dim) const
Return maximum index for array dimension "dim".
A doubly linked list.
Definition: TList.h:44
void BuildRealData(void *pointer=0, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition: TClass.cxx:1942
Int_t fCanSplit
Definition: TClass.h:219
virtual ~TProtoClass()
Destructor.
Int_t fSizeof
Definition: TProtoClass.h:75
TDataMember * GetDataMember() const
Definition: TRealData.h:53
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
The TRealData class manages the effective list of all data members for a given class.
Definition: TRealData.h:30
Int_t GetArrayDim() const
Return number of array dimensions.
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:75
ROOT::ESTLType GetCollectionType() const
Return the &#39;type&#39; of the STL the TClass is representing.
Definition: TClass.cxx:2805
Long_t Property() const
Set TObject::fBits and fStreamerType to cache information about the class.
Definition: TClass.cxx:5768
TString fName
Definition: TNamed.h:32
Each class (see TClass) has a linked list of its base class(es).
Definition: TBaseClass.h:33
const Bool_t kFALSE
Definition: RtypesCore.h:88
Int_t fSizeof
Definition: TClass.h:217
Long_t fClassProperty
Definition: TProtoClass.h:80
void SetFlag(UInt_t f, Bool_t on=kTRUE)
Definition: TProtoClass.h:59
Long_t fOffsetStreamer
Properties that can only be evaluated at run-time.
Definition: TClass.h:240
TList * GetListOfRealData() const
Definition: TClass.h:418
void SetStreamerImpl()
Internal routine to set fStreamerImpl based on the value of fStreamerType.
Definition: TClass.cxx:5897
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2887
std::atomic< Long_t > fProperty
Indicates whether this class can be split or not.
Definition: TClass.h:220
void Load()
Load all the DataMembers known to the interpreter for the scope &#39;fClass&#39; into this collection...
TList * fBase
Definition: TProtoClass.h:70
Long_t fClassProperty
Property.
Definition: TClass.h:221
Mother of all ROOT objects.
Definition: TObject.h:37
std::atomic< UInt_t > fCheckSum
Definition: TClass.h:193
TListOfDataMembers * fData
Definition: TClass.h:177
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
Definition: TListOfEnums.h:32
std::vector< TString > fDepClasses
Definition: TProtoClass.h:74
Long_t fOffsetStreamer
Definition: TProtoClass.h:81
R__EXTERN Int_t gDebug
Definition: Rtypes.h:86
void ResetBit(UInt_t f)
Definition: TObject.h:171
Definition: first.py:1
static TDataMember * FindDataMember(TClass *cl, Int_t index)
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
virtual const char * GetName() const
Returns name of object.
Definition: TRealData.h:52
TClass * GetClass() const
Definition: TDataMember.h:73
const Bool_t kTRUE
Definition: RtypesCore.h:87
bool GetStdArrayProperties(const char *typeName, std::string &typeNameBuf, std::array< int, 5 > &maxIndices, int &ndim)
Bool_t IsObject() const
Definition: TRealData.h:56
char name[80]
Definition: TGX11.cxx:109
static Int_t DataMemberIndex(TClass *cl, const char *name)
void CalculateStreamerOffset() const
Calculate the offset between an object of this class to its base class TObject.
Definition: TClass.cxx:2094
TRealData * CreateRealData(TClass *currentClass, TClass *parent, TRealData *parentData, int prevLevel) const
Create a TRealData from this, with its data member coming from dmClass.
const char * Data() const
Definition: TString.h:364
std::vector< TProtoRealData > fPRealData
Definition: TProtoClass.h:72