Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TDataMember.cxx
Go to the documentation of this file.
1// @(#)root/meta:$Id$
2// Author: Fons Rademakers 04/02/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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 TDataMember
13
14All ROOT classes may have RTTI (run time type identification) support
15added. The data is stored in so called DICTIONARY (look at TDictionary).
16Information about a class is stored in TClass.
17This information may be obtained via the cling api - see class TCling.
18TClass has a list of TDataMember objects providing information about all
19data members of described class.
20
21\image html base_classinfo.png
22
23TDataMember provides information about name of data member, its type,
24and comment field string. It also tries to find the TMethodCall objects
25responsible for getting/setting a value of it, and gives you pointers
26to these methods. This gives you a unique possibility to access
27protected and private (!) data members if only methods for doing that
28are defined.
29
30These methods could either be specified in a comment field, or found
31out automatically by ROOT: here's an example:
32suppose you have a class definition:
33~~~ {.cpp}
34 class MyClass{
35 private:
36 Float_t fX1;
37 ...
38 public:
39 void SetX1(Float_t x) {fX1 = x;};
40 Float_t GetX1() {return fX1;};
41 ...
42 }
43~~~
44Look at the data member name and method names: a data member name has
45a prefix letter (f) and has a base name X1 . The methods for getting and
46setting this value have names which consist of string Get/Set and the
47same base name. This convention of naming data fields and methods which
48access them allows TDataMember find this methods by itself completely
49automatically. To make this description complete, one should know,
50that names that are automatically recognized may be also:
51for data fields: either fXXX or fIsXXX; and for getter function
52GetXXX() or IsXXX() [where XXX is base name].
53
54As an example of using it let's analyse a few lines which get and set
55a fEditable field in TCanvas:
56~~~ {.cpp}
57 TCanvas *c = new TCanvas("c"); // create a canvas
58 TClass *cl = c->IsA(); // get its class description object.
59
60 TDataMember *dm = cl->GetDataMember("fEditable"); //This is our data member
61
62 TMethodCall *getter = dm->GetterMethod(c); //find a method that gets value!
63 Long_t l; // declare a storage for this value;
64
65 getter->Execute(c,"",l); // Get this Value !!!! It will appear in l !!!
66
67
68 TMethodCall *setter = dm->SetterMethod(c);
69 setter->Execute(c,"0",); // Set Value 0 !!!
70~~~
71
72This trick is widely used in ROOT TContextMenu and dialogs for obtaining
73current values and put them as initial values in dialog fields.
74
75If you don't want to follow the convention of naming used by ROOT
76you still could benefit from Getter/Setter method support: the solution
77is to instruct ROOT what the names of these routines are.
78The way to do it is putting this information in a comment string to a data
79field in your class declaration:
80
81~~~ {.cpp}
82 class MyClass{
83 Int_t mydata; // *OPTIONS={GetMethod="Get";SetMethod="Set"}
84 ...
85 Int_t Get() const { return mydata;};
86 void Set(Int_t i) {mydata=i;};
87 }
88~~~
89
90However, this getting/setting functions are not the only feature of
91this class. The next point is providing lists of possible settings
92for the concerned data member. The idea is to have a list of possible
93options for this data member, with strings identifying them. This
94is used in dialogs with parameters to set - for details see
95TMethodArg, TRootContextMenu, TContextMenu. This list not only specifies
96the allowed value, but also provides strings naming the options.
97Options are managed via TList of TOptionListItem objects. This list
98is also created automatically: if a data type is an enum type,
99the list will have items describing every enum value, and named
100according to enum name. If type is Bool_t, two options "On" and "Off"
101with values 0 and 1 are created. For other types you need to instruct
102ROOT about possible options. The way to do it is the same as in case of
103specifying getter/setter method: a comment string to a data field in
104Your header file with class definition.
105The most general format of this string is:
106~~~ {.cpp}
107*OPTIONS={GetMethod="getter";SetMethod="setter";Items=(it1="title1",it2="title2", ... ) }
108~~~
109
110While parsing this string ROOT firstly looks for command-tokens:
111GetMethod, SetMethod, Items; They must be preceded by string
112*OPTIONS= , enclosed by {} and separated by semicolons ";".
113All command token should have a form TOKEN=VALUE.
114All tokens are optional.
115The names of getter and setter method must be enclosed by double-quote
116marks (") .
117Specifications of Items is slightly more complicated: you need to
118put token ITEMS= and then enclose all options in curly brackets "()".
119You separate options by comas ",".
120Each option item may have one of the following forms:
121~~~ {.cpp}
122 IntegerValue = "Text Label"
123
124 EnumValue = "Text Label"
125
126 "TextValue" = Text Label"
127
128~~~ {.cpp}
129
130One can specify values as Integers or Enums - when data field is an
131Integer, Float or Enum type; as texts - for char (more precisely:
132Option_t).
133
134As mentioned above - this information are mainly used by contextmenu,
135but also in Dump() and Inspect() methods and by the THtml class.
136*/
137
138#include "TDataMember.h"
139
140#include "Strlen.h"
141#include "strtok.h"
142#include "strlcpy.h"
143#include "TBuffer.h"
144#include "TClass.h"
145#include "TClassEdit.h"
146#include "TDataType.h"
147#include "TEnum.h"
148#include "TEnumConstant.h"
149#include "TGlobal.h"
150#include "TInterpreter.h"
151#include "TIterator.h"
152#include "TList.h"
153#include "TListOfDataMembers.h"
154#include "TMethod.h"
155#include "TMethodCall.h"
156#include "TRealData.h"
157#include "TROOT.h"
158#include "TVirtualMutex.h"
159
160#include <cassert>
161#include <cctype>
162#include <cstdlib>
163
164
166
167////////////////////////////////////////////////////////////////////////////////
168/// Default TDataMember ctor. TDataMembers are constructed in TClass
169/// via a call to TCling::CreateListOfDataMembers(). It parses the comment
170/// string, initializes optionlist and getter/setter methods.
171
172TDataMember::TDataMember(DataMemberInfo_t *info, TClass *cl) : TDictionary()
173{
174 fInfo = info;
175 fClass = cl;
176 fDataType = nullptr;
177 fOptions = nullptr;
178 fValueSetter = nullptr;
179 fValueGetter = nullptr;
180 fOffset = -1;
181 fProperty = -1;
182 fSTLCont = -1;
183 fArrayDim = -1;
184 fArrayMaxIndex=nullptr;
185 if (!fInfo && !fClass) return; // default ctor is called
186
187 Init(false);
188}
189
190////////////////////////////////////////////////////////////////////////////////
191/// Routines called by the constructor and Update to reset the member's
192/// information.
193/// afterReading is set when initializing after reading through Streamer().
194
195void TDataMember::Init(bool afterReading)
196{
197 if (!afterReading) {
198 // Initialize from fInfo
199 if (!fInfo || !gInterpreter->DataMemberInfo_IsValid(fInfo))
200 return;
201 // Also sets names.
202 Property();
203 }
204 const char *t = GetTitle();
205 if (t && t[0] != '!')
207 fDataType = nullptr;
208 if (IsBasic() || IsEnum()) {
209 if (IsBasic()) {
210 const char *name = GetFullTypeName();
211 if (strcmp(name, "unsigned char") != 0 &&
212 strncmp(name, "unsigned short", sizeof ("unsigned short")) != 0 &&
213 strcmp(name, "unsigned int") != 0 &&
214 strncmp(name, "unsigned long", sizeof ("unsigned long")) != 0)
215 // strncmp() also covers "unsigned long long"
216 name = GetTypeName();
218
219 if (fDataType==nullptr) {
220 // humm we did not find it ... maybe it's a typedef that has not been loaded yet.
221 // (this can happen if the executable does not have a TApplication object).
223 }
224 } else {
225 fDataType = gROOT->GetType("Int_t", kTRUE); // In rare instance we are called before Int_t has been added to the list of types in TROOT, the kTRUE insures it is there.
226 }
227 // if (!fDataType)
228 // Error("TDataMember", "basic data type %s not found in list of basic types",
229 // GetTypeName());
230 }
231
232
233 if (afterReading) {
234 // Options are streamed; can't build TMethodCall for getters and setters
235 // because we deserialize a TDataMember when we do not have interpreter
236 // data. Thus do an early return.
237 return;
238 }
239
240 if (strstr(GetTitle(), "*OPTION={")) {
241 // Delay setting fOptions until it's used: the enum constants might
242 // not have been added as members yet.
243
244 // if option string does not exist but it's an Enum - parse it!!!!
245 } else if (IsEnum()) {
246 fOptions = new TList();
247 if (TEnum* enumDict = TEnum::GetEnum(GetTypeName()) ){
248 TIter iEnumConst(enumDict->GetConstants());
249 while (TEnumConstant* enumConst = (TEnumConstant*)iEnumConst()) {
251 = new TOptionListItem(this, enumConst->GetValue(),0,0,
252 enumConst->GetName(),enumConst->GetName());
253 fOptions->Add(it);
254 }
255 }
256
257 // and the case od Bool_t : we add items "ON" and "Off"
258 } else if (!strncmp(GetFullTypeName(),"Bool_t",6)){
259
260 fOptions = new TList();
261 TOptionListItem *it = new TOptionListItem(this,1,0,0,"ON",nullptr);
262 fOptions->Add(it);
263 it = new TOptionListItem(this,0,0,0,"Off",nullptr);
264 fOptions->Add(it);
265
266 } else fOptions = nullptr;
267
268}
269
270////////////////////////////////////////////////////////////////////////////////
271/// copy constructor
272
274 TDictionary(dm),
275 fInfo(gCling->DataMemberInfo_FactoryCopy(dm.fInfo)),
276 fClass(dm.fClass),
277 fDataType(dm.fDataType),
278 fOffset(dm.fOffset),
279 fSTLCont(dm.fSTLCont),
280 fProperty(dm.fProperty),
281 fArrayDim(dm.fArrayDim),
282 fArrayMaxIndex( dm.fArrayDim ? new Int_t[dm.fArrayDim] : nullptr),
283 fArrayIndex(dm.fArrayIndex),
285 fFullTypeName(dm.fFullTypeName),
286 fTrueTypeName(dm.fTrueTypeName),
287 fValueGetter(nullptr),
288 fValueSetter(nullptr),
289 fOptions(dm.fOptions ? (TList*)dm.fOptions->Clone() : nullptr)
290{
291 for(Int_t d = 0; d < fArrayDim; ++d)
293}
294
295////////////////////////////////////////////////////////////////////////////////
296/// assignment operator
297
299{
300 if(this!=&dm) {
302 delete fValueSetter; fValueSetter = nullptr;
303 delete fValueGetter; fValueGetter = nullptr;
304 if (fOptions) {
305 fOptions->Delete();
306 delete fOptions;
307 fOptions = nullptr;
308 }
309
312 fClass=dm.fClass;
314 fOffset=dm.fOffset;
317 fArrayDim = dm.fArrayDim;
318 delete [] fArrayMaxIndex;
319 fArrayMaxIndex = dm.fArrayDim ? new Int_t[dm.fArrayDim] : nullptr;
320 for(Int_t d = 0; d < fArrayDim; ++d)
326 fOptions = dm.fOptions ? (TList*)dm.fOptions->Clone() : nullptr;
327 }
328 return *this;
329}
330
331////////////////////////////////////////////////////////////////////////////////
332/// TDataMember dtor deletes adopted CINT DataMemberInfo object.
333
335{
336 delete [] fArrayMaxIndex;
338 delete fValueSetter;
339 delete fValueGetter;
340 if (fOptions) {
341 fOptions->Delete();
342 delete fOptions;
343 }
344}
345
346////////////////////////////////////////////////////////////////////////////////
347/// Return number of array dimensions.
348
350{
351 if (fArrayDim<0 && fInfo) {
353 TDataMember *dm = const_cast<TDataMember*>(this);
355 // fArrayMaxIndex should be zero
356 if (dm->fArrayDim) {
357 dm->fArrayMaxIndex = new Int_t[fArrayDim];
358 for(Int_t dim = 0; dim < dm->fArrayDim; ++dim) {
360 }
361 }
362 }
363 return fArrayDim;
364}
365
366////////////////////////////////////////////////////////////////////////////////
367/// If the data member is pointer and has a valid array size in its comments
368/// GetArrayIndex returns a string pointing to it;
369/// otherwise it returns an empty string.
370
371const char *TDataMember::GetArrayIndex() const
372{
373 if (!IsaPointer()) return "";
374 if (fArrayIndex.Length()==0 && fInfo) {
376 TDataMember *dm = const_cast<TDataMember*>(this);
377 const char* val = gCling->DataMemberInfo_ValidArrayIndex(fInfo);
378 if (val) dm->fArrayIndex = val;
379 else dm->fArrayIndex.Append((Char_t)0); // Make length non-zero but string still empty.
380 }
381 return fArrayIndex;
382}
383
384////////////////////////////////////////////////////////////////////////////////
385
387{
388 if (fInfo) return gInterpreter->GetDeclId(fInfo);
389 else return nullptr;
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// Return maximum index for array dimension "dim".
394
396{
397 if (fArrayDim<0 && fInfo) {
399 } else {
400 if (dim < 0 || dim >= fArrayDim) return -1;
401 return fArrayMaxIndex[dim];
402 }
403}
404
405////////////////////////////////////////////////////////////////////////////////
406/// Get the decayed type name of this data member, removing `const` and `volatile` qualifiers, and pointers `*` and
407/// references `&`. This function resolves typedefs in the type name. E.g., let `Foo_t` be a typedef to `class
408/// TDirectory`; assuming `this` is a member of type `const Foo_t*`, this function will return `TDirectory`.
409
410const char *TDataMember::GetTypeName() const
411{
412 if (fProperty==(-1)) Property();
413 return fTypeName.Data();
414}
415
416////////////////////////////////////////////////////////////////////////////////
417/// Get the concrete type name of this data member, including `const` and `volatile` qualifiers. This function does not
418/// resolve any typedef in the type name. E.g., let `Foo_t` be a typedef to `class TDirectory`; assuming `this` is a
419/// member of type `const Foo_t*`, this function will return `const Foo_t*`.
420///
421/// For the desugared type name, see TDataMember::GetTrueTypeName().
422
424{
425 if (fProperty==(-1)) Property();
426
427 return fFullTypeName.Data();
428}
429
430////////////////////////////////////////////////////////////////////////////////
431/// Get the desugared type name of this data member, including `const` and `volatile` qualifiers. This function
432/// resolves typedefs in the type name. E.g., let `Foo_t` be a typedef to `class TDirectory`; assuming `this` is a
433/// member of type `const Foo_t*`, this function will return `const TDirectory*`.
434
436{
437 return fTrueTypeName.Data();
438}
439
440////////////////////////////////////////////////////////////////////////////////
441/// Get offset from "this".
442
444{
445 if (fOffset>=0) return fOffset;
446
448 //case of an interpreted or emulated class
449 if (fClass->GetDeclFileLine() < 0) {
450 ((TDataMember*)this)->fOffset = gCling->DataMemberInfo_Offset(fInfo);
451 return fOffset;
452 }
453 //case of a compiled class
454 //Note that the offset cannot be computed in case of an abstract class
455 //for which the list of real data has not yet been computed via
456 //a real daughter class.
457 TString dmbracket;
458 dmbracket.Form("%s[",GetName());
461 TRealData *rdm;
462 Int_t offset = 0;
463 while ((rdm = (TRealData*)next())) {
464 char *rdmc = (char*)rdm->GetName();
465 //next statement required in case a class and one of its parent class
466 //have data members with the same name
467 if (this->IsaPointer() && rdmc[0] == '*') rdmc++;
468
469 if (rdm->GetDataMember() != this) continue;
470 if (strcmp(rdmc,GetName()) == 0) {
471 offset = rdm->GetThisOffset();
472 break;
473 }
474 if (strcmp(rdm->GetName(),GetName()) == 0) {
475 if (rdm->IsObject()) {
476 offset = rdm->GetThisOffset();
477 break;
478 }
479 }
480 if (strstr(rdm->GetName(),dmbracket.Data())) {
481 offset = rdm->GetThisOffset();
482 break;
483 }
484 }
485 ((TDataMember*)this)->fOffset = offset;
486 return fOffset;
487}
488
489////////////////////////////////////////////////////////////////////////////////
490/// Get offset from "this" using the information in CINT only.
491
493{
494 if (fOffset>=0) return fOffset;
495
497 TDataMember *dm = const_cast<TDataMember*>(this);
498
499 if (dm->IsValid()) return gCling->DataMemberInfo_Offset(dm->fInfo);
500 else return -1;
501}
502
503////////////////////////////////////////////////////////////////////////////////
504/// Get the sizeof the underlying type of the data member
505/// (i.e. if the member is an array sizeof(member)/length)
506
508{
509 if (IsaPointer()) return sizeof(void*);
510 if (IsEnum() ) return sizeof(Int_t);
511 if (IsBasic() ) return GetDataType()->Size();
512
514 if (!cl) cl = TClass::GetClass(GetTrueTypeName());
515 if ( cl) return cl->Size();
516
517 Warning("GetUnitSize","Can not determine sizeof(%s)",GetTypeName());
518 return 0;
519}
520
521////////////////////////////////////////////////////////////////////////////////
522/// Return true if data member is a basic type, e.g. char, int, long...
523
525{
526 if (fProperty == -1) Property();
527 return (fProperty & kIsFundamental) ? kTRUE : kFALSE;
528}
529
530////////////////////////////////////////////////////////////////////////////////
531/// Return true if data member is an enum.
532
534{
535 if (fProperty == -1) Property();
536 return (fProperty & kIsEnum) ? kTRUE : kFALSE;
537}
538
539////////////////////////////////////////////////////////////////////////////////
540/// Return true if data member is a pointer.
541
543{
544 if (fProperty == -1) Property();
545 return (fProperty & kIsPointer) ? kTRUE : kFALSE;
546}
547
548////////////////////////////////////////////////////////////////////////////////
549/// The return type is defined in TDictionary (kVector, kList, etc.)
550
552{
553 if (fSTLCont != -1) return fSTLCont;
556 return fSTLCont;
557}
558
559////////////////////////////////////////////////////////////////////////////////
560/// Return true if this data member object is pointing to a currently
561/// loaded data member. If a function is unloaded after the TDataMember
562/// is created, the TDataMember will be set to be invalid.
563
565{
566 if (fOffset >= 0) return kTRUE;
567
568 // Register the transaction when checking the validity of the object.
570 DeclId_t newId = gInterpreter->GetDataMember(fClass->GetClassInfo(), fName);
571 if (newId) {
572 DataMemberInfo_t *info
573 = gInterpreter->DataMemberInfo_Factory(newId, fClass->GetClassInfo());
574 Update(info);
575 // We need to make sure that the list of data member is properly
576 // informed and updated.
578 lst->Update(this);
579 }
580 return newId != nullptr;
581 }
582 return fInfo != nullptr;
583}
584
585////////////////////////////////////////////////////////////////////////////////
586/// Get property description word. For meaning of bits see EProperty.
587
589{
590 if (fProperty!=(-1)) return fProperty;
591
593 TDataMember *t = (TDataMember*)this;
594
595 if (!fInfo || !gCling->DataMemberInfo_IsValid(fInfo)) return 0;
598 t->fProperty = (prop | propt) & ~(kIsPublic | kIsProtected | kIsPrivate);
599 // Set to the strictest access of the member and the type
600 if ((prop | propt) & kIsPrivate)
601 t->fProperty |= kIsPrivate;
602 else if ((prop | propt) & kIsProtected)
604 else
605 t->fProperty |= kIsPublic;
606
610
613
614 return fProperty;
615}
616
617
618////////////////////////////////////////////////////////////////////////////////
619/// Build TOptionListItems from the member comment `*OPTION={`
620
622{
623 if (fOptions)
624 return;
625
626 const char *optTitle = strstr(GetTitle(), "*OPTION={");
627 if (!optTitle)
628 return;
629
630 // If option string exist in comment - we'll parse it and create
631 // list of options
632
633 // Option-list string has a form:
634 // *OPTION={GetMethod="GetXXX";SetMethod="SetXXX";
635 // Items=(0="NULL ITEM","one"="First Item",kRed="Red Item")}
636 //
637 // As one can see it is possible to specify value as either numerical
638 // value , string or enum.
639 // One can also specify implicitly names of Getter/Setter methods.
640
641 char cmt[2048];
642 char opt[2048];
643 const char *ptr1 = nullptr;
644 char *ptr2 = nullptr;
645 char *ptr3 = nullptr;
646 Int_t cnt = 0;
647 Int_t token_cnt;
648 Int_t i;
649
650 strlcpy(cmt,GetTitle(),2048);
651
652 char *opt_ptr = strstr(cmt, "*OPTION={");
653
654 // If we found it - parsing...
655
656 //let's cut the part lying between {}
657 char *rest;
658 ptr1 = R__STRTOK_R(opt_ptr, "{}", &rest); // starts tokenizing:extracts "*OPTION={"
659 if (ptr1 == nullptr) {
660 Fatal("TDataMember","Internal error, found \"*OPTION={\" but not \"{}\" in %s.",GetTitle());
661 return;
662 }
663 ptr1 = R__STRTOK_R(nullptr, "{}", &rest); // And now we have what we need in ptr1!!!
664 if (ptr1 == nullptr) {
665 Fatal("TDataMember","Internal error, found \"*OPTION={\" but not \"{}\" in %s.",GetTitle());
666 return;
667 }
668
669 //and save it:
670 strlcpy(opt,ptr1,2048);
671
672 // Let's extract sub-tokens extracted by ';' sign.
673 // We'll put'em in an array for convenience;
674 // You have to do it in this manner because you cannot use nested tokenizing
675
676 std::vector<std::string> tokens; // a storage for these sub-tokens.
677 token_cnt = 0;
678 cnt = 0;
679
680 do { //tokenizing loop
681 ptr1 = R__STRTOK_R((char *)(cnt++ ? nullptr : opt), ";", &rest);
682 if (ptr1) {
683 tokens.emplace_back(ptr1);
684 token_cnt++;
685 }
686 } while (ptr1);
687
688 // OK! Now let's check whether we have Get/Set methods encode in any string
689 for (i=0;i<token_cnt;i++) {
690 if (strstr(tokens[i].c_str(),"GetMethod")) {
691 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "\"", &rest); // tokenizing-strip text "GetMethod"
692 if (ptr1 == nullptr) {
693 Fatal("TDataMember","Internal error, found \"GetMethod\" but not \"\\\"\" in %s.",GetTitle());
694 return;
695 }
696 ptr1 = R__STRTOK_R(nullptr, "\"", &rest); // tokenizing - name is in ptr1!
697 if (ptr1 == nullptr) {
698 Fatal("TDataMember","Internal error, found \"GetMethod\" but not \"\\\"\" in %s.",GetTitle());
699 return;
700 }
701
702 if (GetClass()->GetMethod(ptr1,"")) // check whether such method exists
703 // FIXME: wrong in case called derives via multiple inheritance from this class
705
706 continue; //next item!
707 }
708
709 if (strstr(tokens[i].c_str(),"SetMethod")) {
710 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "\"", &rest);
711 if (ptr1 == nullptr) {
712 Fatal("TDataMember","Internal error, found \"SetMethod\" but not \"\\\"\" in %s.",GetTitle());
713 return;
714 }
715 ptr1 = R__STRTOK_R(nullptr, "\"", &rest); // name of Setter in ptr1
716 if (ptr1 == nullptr) {
717 Fatal("TDataMember","Internal error, found \"SetMethod\" but not \"\\\"\" in %s.",GetTitle());
718 return;
719 }
720 if (GetClass()->GetMethod(ptr1,"1"))
721 // FIXME: wrong in case called derives via multiple inheritance from this class
723 }
724 }
725
726 //Now let's parse option strings...
727
728 Int_t opt_cnt = 0;
729 std::unique_ptr<TList> optionlist{new TList()}; //storage for options strings
730
731 for (i=0;i<token_cnt;i++) {
732 if (strstr(tokens[i].c_str(),"Items")) {
733 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "()", &rest);
734 if (ptr1 == nullptr) {
735 Fatal("TDataMember","Internal error, found \"Items\" but not \"()\" in %s.",GetTitle());
736 return;
737 }
738 ptr1 = R__STRTOK_R(nullptr, "()", &rest);
739 if (ptr1 == nullptr) {
740 Fatal("TDataMember","Internal error, found \"Items\" but not \"()\" in %s.",GetTitle());
741 return;
742 }
743
744 char opts[2048]; //and save it!
745 strlcpy(opts,ptr1,2048);
746
747 //now parse it...
748 //firstly we just store strings like: xxx="Label Name"
749 //We'll store it in TOptionListItem objects, because they're derived
750 //from TObject and thus can be stored in TList.
751 //It's not elegant but works.
752 do {
753 ptr1 = R__STRTOK_R(opt_cnt++ ? nullptr : opts, ",", &rest); // options extraction
754 if (ptr1) {
755 TOptionListItem *it = new TOptionListItem(this,1,0,0,ptr1,"");
756 optionlist->Add(it);
757 }
758 } while(ptr1);
759
760 }
761 }
762
763 //having all options extracted and put into list, we finally can parse
764 //them to create a list of options...
765
766 fOptions = new TList(); //create the list
767
768 TIter next(optionlist.get()); //we'll iterate through all
769 //strings containing options
770 TOptionListItem *it = nullptr;
771 TOptionListItem *it1 = nullptr;
772 while ((it=(TOptionListItem*)next())) {
773
774 ptr1 = it->fOptName; // We will change the value of OptName ... but it is fine since we delete the object at the end of the loop.
775 Bool_t islabel = (ptr1[0]=='\"'); // value is label or numerical?
776 ptr2 = R__STRTOK_R((char *)ptr1, "=\"", &rest); // extract LeftHandeSide
777 ptr3 = R__STRTOK_R(nullptr, "=\"", &rest); // extract RightHandedSize
778
779 if (islabel) {
780 it1=new TOptionListItem(this,-9999,0,0,ptr3,ptr2);
781 fOptions->Add(it1);
782 } else {
783
784 char *strtolResult;
785 Long_t l = std::strtol(ptr1, &strtolResult, 10);
786 bool isnumber = (strtolResult != ptr1);
787
788 if (!isnumber) {
789 TGlobal *enumval = gROOT->GetGlobal(ptr1, kTRUE);
790 if (enumval) {
791 Int_t *value = (Int_t *)(enumval->GetAddress());
792 // We'll try to find global enum existing in ROOT...
793 l = (Long_t)(*value);
794 } else if (IsEnum()) {
796 if (obj)
797 l = ((TEnumConstant *)obj)->GetValue();
798 else
799 l = gInterpreter->Calc(Form("%s;", ptr1));
800 } else {
801 Fatal("TDataMember", "Internal error, couldn't recognize enum/global value %s.", ptr1);
802 }
803 }
804
805 it1 = new TOptionListItem(this,l,0,0,ptr3,ptr1);
806 fOptions->Add(it1);
807 }
808
809 optionlist->Remove(it); //delete this option string from list
810 delete it; // and dispose of it.
811
812 }
813
814}
815
816
817////////////////////////////////////////////////////////////////////////////////
818/// Returns list of options - list of TOptionListItems
819
821{
822 if (!fOptions)
824 return fOptions;
825}
826
827////////////////////////////////////////////////////////////////////////////////
828/// Return a TMethodCall method responsible for getting the value
829/// of data member. The cl argument specifies the class of the object
830/// which will be used to call this method (in case of multiple
831/// inheritance TMethodCall needs to know this to calculate the proper
832/// offset).
833
835{
836 if (!fValueGetter || cl) {
837
839
840 if (!cl) cl = fClass;
841
842 if (fValueGetter) {
843 TString methodname = fValueGetter->GetMethodName();
844 delete fValueGetter;
845 fValueGetter = new TMethodCall(cl, methodname.Data(), "");
846
847 } else {
848 // try to guess Getter function:
849 // we strip the fist character of name of data field ('f') and then
850 // try to find the name of Getter by applying "Get", "Is" or "Has"
851 // as a prefix
852
853 const char *dataname = GetName();
854
855 TString gettername;
856 gettername.Form( "Get%s", dataname+1);
857 if (GetClass()->GetMethod(gettername, ""))
858 return fValueGetter = new TMethodCall(cl, gettername, "");
859 gettername.Form( "Is%s", dataname+1);
860 if (GetClass()->GetMethod(gettername, ""))
861 return fValueGetter = new TMethodCall(cl, gettername, "");
862 gettername.Form( "Has%s", dataname+1);
863 if (GetClass()->GetMethod(gettername, ""))
864 return fValueGetter = new TMethodCall(cl, gettername, "");
865 }
866 }
867
868 return fValueGetter;
869}
870
871////////////////////////////////////////////////////////////////////////////////
872/// Return a TMethodCall method responsible for setting the value
873/// of data member. The cl argument specifies the class of the object
874/// which will be used to call this method (in case of multiple
875/// inheritance TMethodCall needs to know this to calculate the proper
876/// offset).
877
879{
880 if (!fValueSetter || cl) {
881
883
884 if (!cl) cl = fClass;
885
886 if (fValueSetter) {
887
888 TString methodname = fValueSetter->GetMethodName();
889 TString params = fValueSetter->GetParams();
890 delete fValueSetter;
891 fValueSetter = new TMethodCall(cl, methodname.Data(), params.Data());
892
893 } else {
894
895 // try to guess Setter function:
896 // we strip the fist character of name of data field ('f') and then
897 // try to find the name of Setter by applying "Set" as a prefix
898
899 const char *dataname = GetName();
900
901 TString settername;
902 settername.Form( "Set%s", dataname+1);
903 if (strstr(settername, "Is")) settername.Form( "Set%s", dataname+3);
904 if (GetClass()->GetMethod(settername, "0"))
905 fValueSetter = new TMethodCall(cl, settername, "0");
906 if (!fValueSetter)
907 if (GetClass()->GetMethod(settername, "true"))
908 fValueSetter = new TMethodCall(cl, settername, "true");
909 }
910 }
911
912 return fValueSetter;
913}
914
915////////////////////////////////////////////////////////////////////////////////
916/// Update the TFunction to reflect the new info.
917///
918/// This can be used to implement unloading (info == 0) and then reloading
919/// (info being the 'new' decl address).
920
921Bool_t TDataMember::Update(DataMemberInfo_t *info)
922{
924
928 if (fOptions) {
929 fOptions->Delete();
931 }
932
933 if (info == nullptr) {
934 fOffset = -1;
935 fProperty = -1;
936 fSTLCont = -1;
937 fArrayDim = -1;
938 delete [] fArrayMaxIndex;
939 fArrayMaxIndex=nullptr;
941
942 fInfo = nullptr;
943 return kTRUE;
944 } else {
945 fInfo = info;
946 Init(false);
947 return kTRUE;
948 }
949}
950
951
952////////////////////////////////////////////////////////////////////////////////
953/// Stream an object of TDataMember. Forces calculation of all cached
954/// (and persistent) values.
955
957 if (b.IsReading()) {
958 b.ReadClassBuffer(Class(), this);
959 Init(true /*reading*/);
960 } else {
961 // Writing.
962 if (fProperty & kIsStatic) {
963 // We have a static member and in this case fOffset contains the
964 // actual address in memory of the data, it will be different everytime,
965 // let's not record it.
966 fOffset = -1;
967 } else {
968 GetOffset();
969 }
971 GetArrayDim();
973 Property(); // also calculates fTypeName and friends
974 b.WriteClassBuffer(Class(), this);
975 }
976}
977
978////////////////////////////////////////////////////////////////////////////////
979/// Constructor.
980
982 Long_t tglmask,const char *name, const char *label)
983{
984 fDataMember = d;
985 fValue = val;
986 fValueMaskBit = valmask;
987 fToggleMaskBit = tglmask;
988 if (name) {
989 fOptName = name;
990 }
991
992 if (label) {
993 fOptLabel = label;
994 }
995}
Cppyy::TCppType_t fClass
#define SafeDelete(p)
Definition RConfig.hxx:525
#define d(i)
Definition RSha256.hxx:102
#define b(i)
Definition RSha256.hxx:100
long Longptr_t
Definition RtypesCore.h:75
char Char_t
Definition RtypesCore.h:37
long Long_t
Definition RtypesCore.h:54
constexpr Bool_t kFALSE
Definition RtypesCore.h:94
constexpr Bool_t kTRUE
Definition RtypesCore.h:93
#define ClassImp(name)
Definition Rtypes.h:377
@ kIsPublic
Definition TDictionary.h:75
@ kIsPointer
Definition TDictionary.h:78
@ kIsEnum
Definition TDictionary.h:68
@ kIsPrivate
Definition TDictionary.h:77
@ kIsFundamental
Definition TDictionary.h:70
@ kIsStatic
Definition TDictionary.h:80
@ kIsProtected
Definition TDictionary.h:76
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h prop
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
R__EXTERN TInterpreter * gCling
#define gInterpreter
#define gROOT
Definition TROOT.h:406
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
#define R__LOCKGUARD(mutex)
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
void BuildRealData(void *pointer=nullptr, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition TClass.cxx:2031
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
Definition TClass.cxx:3770
Short_t GetDeclFileLine() const
Definition TClass.h:429
TList * GetListOfRealData() const
Definition TClass.h:453
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
ClassInfo_t * GetClassInfo() const
Definition TClass.h:433
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:2968
TObject * Clone(const char *newname="") const override
Make a clone of an collection using the Streamer facility.
All ROOT classes may have RTTI (run time type identification) support added.
Definition TDataMember.h:31
virtual ~TDataMember()
TDataMember dtor deletes adopted CINT DataMemberInfo object.
Int_t GetMaxIndex(Int_t dim) const
Return maximum index for array dimension "dim".
TDataMember(const TDataMember &)
copy constructor
Long_t fProperty
Definition TDataMember.h:44
TString fFullTypeName
Definition TDataMember.h:50
TString fTypeName
Definition TDataMember.h:49
void Streamer(TBuffer &) override
Stream an object of TDataMember.
TMethodCall * SetterMethod(TClass *cl)
Return a TMethodCall method responsible for setting the value of data member.
virtual bool Update(DataMemberInfo_t *info)
Update the TFunction to reflect the new info.
TDataMember & operator=(const TDataMember &)
assignment operator
const char * GetTrueTypeName() const
Get the desugared type name of this data member, including const and volatile qualifiers.
Longptr_t GetOffsetCint() const
Get offset from "this" using the information in CINT only.
DataMemberInfo_t * fInfo
Definition TDataMember.h:38
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
Int_t * fArrayMaxIndex
Definition TDataMember.h:46
TString fTrueTypeName
Definition TDataMember.h:51
TMethodCall * fValueGetter
Definition TDataMember.h:56
Int_t GetArrayDim() const
Return number of array dimensions.
Longptr_t fOffset
pointer to data basic type descriptor
Definition TDataMember.h:42
Bool_t IsEnum() const
Return true if data member is an enum.
TList * GetOptions()
Returns list of options - list of TOptionListItems.
void Init(bool afterReading)
Routines called by the constructor and Update to reset the member's information.
Int_t GetUnitSize() const
Get the sizeof the underlying type of the data member (i.e.
Bool_t IsBasic() const
Return true if data member is a basic type, e.g. char, int, long...
Int_t IsSTLContainer()
The return type is defined in TDictionary (kVector, kList, etc.)
Bool_t IsaPointer() const
Return true if data member is a pointer.
Bool_t IsValid()
Return true if this data member object is pointing to a currently loaded data member.
TMethodCall * GetterMethod(TClass *cl=nullptr)
Return a TMethodCall method responsible for getting the value of data member.
TClass * fClass
pointer to CINT data member info
Definition TDataMember.h:39
void ExtractOptionsFromComment()
Build TOptionListItems from the member comment *OPTION={
TDataType * GetDataType() const
Definition TDataMember.h:76
Longptr_t GetOffset() const
Get offset from "this".
const char * GetTypeName() const
Get the decayed type name of this data member, removing const and volatile qualifiers,...
DeclId_t GetDeclId() const
TMethodCall * fValueSetter
method that returns a value;
Definition TDataMember.h:57
TList * fOptions
method which sets value;
Definition TDataMember.h:58
const char * GetArrayIndex() const
If the data member is pointer and has a valid array size in its comments GetArrayIndex returns a stri...
Int_t fSTLCont
Definition TDataMember.h:43
TDataType * fDataType
pointer to the class
Definition TDataMember.h:40
const char * GetFullTypeName() const
Get the concrete type name of this data member, including const and volatile qualifiers.
TString fArrayIndex
Definition TDataMember.h:47
TClass * GetClass() const
Definition TDataMember.h:75
Int_t fArrayDim
Definition TDataMember.h:45
static TClass * Class()
Int_t GetType() const
Definition TDataType.h:68
Int_t Size() const
Get size of basic typedef'ed type.
This class defines an abstract interface that must be implemented by all classes that contain diction...
Bool_t UpdateInterpreterStateMarker()
the Cling ID of the transaction that last updated the object
TDictionary & operator=(const TDictionary &other)
const void * DeclId_t
The TEnumConstant class implements the constants of the enum type.
The TEnum class implements the enum type.
Definition TEnum.h:33
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
Definition TEnum.cxx:175
Global variables class (global variables are obtained from CINT).
Definition TGlobal.h:28
virtual void * GetAddress() const
Return address of global.
Definition TGlobal.cxx:81
virtual DataMemberInfo_t * DataMemberInfo_FactoryCopy(DataMemberInfo_t *) const
virtual const char * DataMemberInfo_Name(DataMemberInfo_t *) const
virtual const char * DataMemberInfo_TypeName(DataMemberInfo_t *) const
virtual const char * DataMemberInfo_ValidArrayIndex(DataMemberInfo_t *) const
virtual Longptr_t DataMemberInfo_Offset(DataMemberInfo_t *) const
virtual Bool_t DataMemberInfo_IsValid(DataMemberInfo_t *) const
virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *) const
virtual Long_t DataMemberInfo_Property(DataMemberInfo_t *) const
virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t *) const
virtual void DataMemberInfo_Delete(DataMemberInfo_t *) const
virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t *, Int_t) const
virtual const char * DataMemberInfo_Title(DataMemberInfo_t *) const
virtual const char * DataMemberInfo_TypeTrueName(DataMemberInfo_t *) const
virtual const char * TypeName(const char *s)=0
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
void Update(TDictionary *member)
Move the member or data member to the expect set of list.
A doubly linked list.
Definition TList.h:38
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition TList.cxx:576
void Add(TObject *obj) override
Definition TList.h:83
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:468
Method or function calling interface.
Definition TMethodCall.h:37
const char * GetMethodName() const
Definition TMethodCall.h:90
const char * GetParams() const
Definition TMethodCall.h:91
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
TString fTitle
Definition TNamed.h:33
TString fName
Definition TNamed.h:32
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:973
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:1015
Long_t fToggleMaskBit
TDataMember * fDataMember
Long_t fValue
Data member to which this option belongs.
The TRealData class manages the effective list of all data members for a given class.
Definition TRealData.h:30
const char * GetName() const override
Returns name of object.
Definition TRealData.h:52
TDataMember * GetDataMember() const
Definition TRealData.h:53
Bool_t IsObject() const
Definition TRealData.h:56
Long_t GetThisOffset() const
Definition TRealData.h:55
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
void Clear()
Clear string without changing its capacity.
Definition TString.cxx:1235
const char * Data() const
Definition TString.h:376
TString & Append(const char *cs)
Definition TString.h:572
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2356
struct void * fTypeName
Definition cppyy.h:9
std::string GetLong64_Name(const char *original)
Replace 'long long' and 'unsigned long long' by 'Long64_t' and 'ULong64_t'.
ROOT::ESTLType UnderlyingIsSTLCont(std::string_view type)
Return the type of STL collection, if any, that is the underlying type of the given type.
TLine l
Definition textangle.C:4
static byte * ptr1
Definition gifdecode.c:16
static byte * ptr2
Definition gifdecode.c:17