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;
599
603
606
607 return fProperty;
608}
609
610
611////////////////////////////////////////////////////////////////////////////////
612/// Build TOptionListItems from the member comment `*OPTION={`
613
615{
616 if (fOptions)
617 return;
618
619 const char *optTitle = strstr(GetTitle(), "*OPTION={");
620 if (!optTitle)
621 return;
622
623 // If option string exist in comment - we'll parse it and create
624 // list of options
625
626 // Option-list string has a form:
627 // *OPTION={GetMethod="GetXXX";SetMethod="SetXXX";
628 // Items=(0="NULL ITEM","one"="First Item",kRed="Red Item")}
629 //
630 // As one can see it is possible to specify value as either numerical
631 // value , string or enum.
632 // One can also specify implicitly names of Getter/Setter methods.
633
634 char cmt[2048];
635 char opt[2048];
636 const char *ptr1 = nullptr;
637 char *ptr2 = nullptr;
638 char *ptr3 = nullptr;
639 Int_t cnt = 0;
640 Int_t token_cnt;
641 Int_t i;
642
643 strlcpy(cmt,GetTitle(),2048);
644
645 char *opt_ptr = strstr(cmt, "*OPTION={");
646
647 // If we found it - parsing...
648
649 //let's cut the part lying between {}
650 char *rest;
651 ptr1 = R__STRTOK_R(opt_ptr, "{}", &rest); // starts tokenizing:extracts "*OPTION={"
652 if (ptr1 == nullptr) {
653 Fatal("TDataMember","Internal error, found \"*OPTION={\" but not \"{}\" in %s.",GetTitle());
654 return;
655 }
656 ptr1 = R__STRTOK_R(nullptr, "{}", &rest); // And now we have what we need in ptr1!!!
657 if (ptr1 == nullptr) {
658 Fatal("TDataMember","Internal error, found \"*OPTION={\" but not \"{}\" in %s.",GetTitle());
659 return;
660 }
661
662 //and save it:
663 strlcpy(opt,ptr1,2048);
664
665 // Let's extract sub-tokens extracted by ';' sign.
666 // We'll put'em in an array for convenience;
667 // You have to do it in this manner because you cannot use nested tokenizing
668
669 std::vector<std::string> tokens; // a storage for these sub-tokens.
670 token_cnt = 0;
671 cnt = 0;
672
673 do { //tokenizing loop
674 ptr1 = R__STRTOK_R((char *)(cnt++ ? nullptr : opt), ";", &rest);
675 if (ptr1) {
676 tokens.emplace_back(ptr1);
677 token_cnt++;
678 }
679 } while (ptr1);
680
681 // OK! Now let's check whether we have Get/Set methods encode in any string
682 for (i=0;i<token_cnt;i++) {
683 if (strstr(tokens[i].c_str(),"GetMethod")) {
684 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "\"", &rest); // tokenizing-strip text "GetMethod"
685 if (ptr1 == nullptr) {
686 Fatal("TDataMember","Internal error, found \"GetMethod\" but not \"\\\"\" in %s.",GetTitle());
687 return;
688 }
689 ptr1 = R__STRTOK_R(nullptr, "\"", &rest); // tokenizing - name is in ptr1!
690 if (ptr1 == nullptr) {
691 Fatal("TDataMember","Internal error, found \"GetMethod\" but not \"\\\"\" in %s.",GetTitle());
692 return;
693 }
694
695 if (GetClass()->GetMethod(ptr1,"")) // check whether such method exists
696 // FIXME: wrong in case called derives via multiple inheritance from this class
698
699 continue; //next item!
700 }
701
702 if (strstr(tokens[i].c_str(),"SetMethod")) {
703 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "\"", &rest);
704 if (ptr1 == nullptr) {
705 Fatal("TDataMember","Internal error, found \"SetMethod\" but not \"\\\"\" in %s.",GetTitle());
706 return;
707 }
708 ptr1 = R__STRTOK_R(nullptr, "\"", &rest); // name of Setter in ptr1
709 if (ptr1 == nullptr) {
710 Fatal("TDataMember","Internal error, found \"SetMethod\" but not \"\\\"\" in %s.",GetTitle());
711 return;
712 }
713 if (GetClass()->GetMethod(ptr1,"1"))
714 // FIXME: wrong in case called derives via multiple inheritance from this class
716 }
717 }
718
719 //Now let's parse option strings...
720
721 Int_t opt_cnt = 0;
722 std::unique_ptr<TList> optionlist{new TList()}; //storage for options strings
723
724 for (i=0;i<token_cnt;i++) {
725 if (strstr(tokens[i].c_str(),"Items")) {
726 ptr1 = R__STRTOK_R(const_cast<char *>(tokens[i].c_str()), "()", &rest);
727 if (ptr1 == nullptr) {
728 Fatal("TDataMember","Internal error, found \"Items\" but not \"()\" in %s.",GetTitle());
729 return;
730 }
731 ptr1 = R__STRTOK_R(nullptr, "()", &rest);
732 if (ptr1 == nullptr) {
733 Fatal("TDataMember","Internal error, found \"Items\" but not \"()\" in %s.",GetTitle());
734 return;
735 }
736
737 char opts[2048]; //and save it!
738 strlcpy(opts,ptr1,2048);
739
740 //now parse it...
741 //firstly we just store strings like: xxx="Label Name"
742 //We'll store it in TOptionListItem objects, because they're derived
743 //from TObject and thus can be stored in TList.
744 //It's not elegant but works.
745 do {
746 ptr1 = R__STRTOK_R(opt_cnt++ ? nullptr : opts, ",", &rest); // options extraction
747 if (ptr1) {
748 TOptionListItem *it = new TOptionListItem(this,1,0,0,ptr1,"");
749 optionlist->Add(it);
750 }
751 } while(ptr1);
752
753 }
754 }
755
756 //having all options extracted and put into list, we finally can parse
757 //them to create a list of options...
758
759 fOptions = new TList(); //create the list
760
761 TIter next(optionlist.get()); //we'll iterate through all
762 //strings containing options
763 TOptionListItem *it = nullptr;
764 TOptionListItem *it1 = nullptr;
765 while ((it=(TOptionListItem*)next())) {
766
767 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.
768 Bool_t islabel = (ptr1[0]=='\"'); // value is label or numerical?
769 ptr2 = R__STRTOK_R((char *)ptr1, "=\"", &rest); // extract LeftHandeSide
770 ptr3 = R__STRTOK_R(nullptr, "=\"", &rest); // extract RightHandedSize
771
772 if (islabel) {
773 it1=new TOptionListItem(this,-9999,0,0,ptr3,ptr2);
774 fOptions->Add(it1);
775 } else {
776
777 char *strtolResult;
778 Long_t l = std::strtol(ptr1, &strtolResult, 10);
779 bool isnumber = (strtolResult != ptr1);
780
781 if (!isnumber) {
782 TGlobal *enumval = gROOT->GetGlobal(ptr1, kTRUE);
783 if (enumval) {
784 Int_t *value = (Int_t *)(enumval->GetAddress());
785 // We'll try to find global enum existing in ROOT...
786 l = (Long_t)(*value);
787 } else if (IsEnum()) {
789 if (obj)
790 l = ((TEnumConstant *)obj)->GetValue();
791 else
792 l = gInterpreter->Calc(Form("%s;", ptr1));
793 } else {
794 Fatal("TDataMember", "Internal error, couldn't recognize enum/global value %s.", ptr1);
795 }
796 }
797
798 it1 = new TOptionListItem(this,l,0,0,ptr3,ptr1);
799 fOptions->Add(it1);
800 }
801
802 optionlist->Remove(it); //delete this option string from list
803 delete it; // and dispose of it.
804
805 }
806
807}
808
809
810////////////////////////////////////////////////////////////////////////////////
811/// Returns list of options - list of TOptionListItems
812
814{
815 if (!fOptions)
817 return fOptions;
818}
819
820////////////////////////////////////////////////////////////////////////////////
821/// Return a TMethodCall method responsible for getting the value
822/// of data member. The cl argument specifies the class of the object
823/// which will be used to call this method (in case of multiple
824/// inheritance TMethodCall needs to know this to calculate the proper
825/// offset).
826
828{
829 if (!fValueGetter || cl) {
830
832
833 if (!cl) cl = fClass;
834
835 if (fValueGetter) {
836 TString methodname = fValueGetter->GetMethodName();
837 delete fValueGetter;
838 fValueGetter = new TMethodCall(cl, methodname.Data(), "");
839
840 } else {
841 // try to guess Getter function:
842 // we strip the fist character of name of data field ('f') and then
843 // try to find the name of Getter by applying "Get", "Is" or "Has"
844 // as a prefix
845
846 const char *dataname = GetName();
847
848 TString gettername;
849 gettername.Form( "Get%s", dataname+1);
850 if (GetClass()->GetMethod(gettername, ""))
851 return fValueGetter = new TMethodCall(cl, gettername, "");
852 gettername.Form( "Is%s", dataname+1);
853 if (GetClass()->GetMethod(gettername, ""))
854 return fValueGetter = new TMethodCall(cl, gettername, "");
855 gettername.Form( "Has%s", dataname+1);
856 if (GetClass()->GetMethod(gettername, ""))
857 return fValueGetter = new TMethodCall(cl, gettername, "");
858 }
859 }
860
861 return fValueGetter;
862}
863
864////////////////////////////////////////////////////////////////////////////////
865/// Return a TMethodCall method responsible for setting the value
866/// of data member. The cl argument specifies the class of the object
867/// which will be used to call this method (in case of multiple
868/// inheritance TMethodCall needs to know this to calculate the proper
869/// offset).
870
872{
873 if (!fValueSetter || cl) {
874
876
877 if (!cl) cl = fClass;
878
879 if (fValueSetter) {
880
881 TString methodname = fValueSetter->GetMethodName();
882 TString params = fValueSetter->GetParams();
883 delete fValueSetter;
884 fValueSetter = new TMethodCall(cl, methodname.Data(), params.Data());
885
886 } else {
887
888 // try to guess Setter function:
889 // we strip the fist character of name of data field ('f') and then
890 // try to find the name of Setter by applying "Set" as a prefix
891
892 const char *dataname = GetName();
893
894 TString settername;
895 settername.Form( "Set%s", dataname+1);
896 if (strstr(settername, "Is")) settername.Form( "Set%s", dataname+3);
897 if (GetClass()->GetMethod(settername, "0"))
898 fValueSetter = new TMethodCall(cl, settername, "0");
899 if (!fValueSetter)
900 if (GetClass()->GetMethod(settername, "true"))
901 fValueSetter = new TMethodCall(cl, settername, "true");
902 }
903 }
904
905 return fValueSetter;
906}
907
908////////////////////////////////////////////////////////////////////////////////
909/// Update the TFunction to reflect the new info.
910///
911/// This can be used to implement unloading (info == 0) and then reloading
912/// (info being the 'new' decl address).
913
914Bool_t TDataMember::Update(DataMemberInfo_t *info)
915{
917
921 if (fOptions) {
922 fOptions->Delete();
924 }
925
926 if (info == nullptr) {
927 fOffset = -1;
928 fProperty = -1;
929 fSTLCont = -1;
930 fArrayDim = -1;
931 delete [] fArrayMaxIndex;
932 fArrayMaxIndex=nullptr;
934
935 fInfo = nullptr;
936 return kTRUE;
937 } else {
938 fInfo = info;
939 Init(false);
940 return kTRUE;
941 }
942}
943
944
945////////////////////////////////////////////////////////////////////////////////
946/// Stream an object of TDataMember. Forces calculation of all cached
947/// (and persistent) values.
948
950 if (b.IsReading()) {
951 b.ReadClassBuffer(Class(), this);
952 Init(true /*reading*/);
953 } else {
954 // Writing.
955 if (fProperty & kIsStatic) {
956 // We have a static member and in this case fOffset contains the
957 // actual address in memory of the data, it will be different everytime,
958 // let's not record it.
959 fOffset = -1;
960 } else {
961 GetOffset();
962 }
964 GetArrayDim();
966 Property(); // also calculates fTypeName and friends
967 b.WriteClassBuffer(Class(), this);
968 }
969}
970
971////////////////////////////////////////////////////////////////////////////////
972/// Constructor.
973
975 Long_t tglmask,const char *name, const char *label)
976{
977 fDataMember = d;
978 fValue = val;
979 fValueMaskBit = valmask;
980 fToggleMaskBit = tglmask;
981 if (name) {
982 fOptName = name;
983 }
984
985 if (label) {
986 fOptLabel = label;
987 }
988}
Cppyy::TCppType_t fClass
#define SafeDelete(p)
Definition RConfig.hxx:550
#define d(i)
Definition RSha256.hxx:102
#define b(i)
Definition RSha256.hxx:100
long Longptr_t
Definition RtypesCore.h:82
char Char_t
Definition RtypesCore.h:37
long Long_t
Definition RtypesCore.h:54
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
#define ClassImp(name)
Definition Rtypes.h:377
@ kIsPointer
Definition TDictionary.h:78
@ kIsEnum
Definition TDictionary.h:68
@ kIsFundamental
Definition TDictionary.h:70
@ kIsStatic
Definition TDictionary.h:80
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:2467
#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:427
TList * GetListOfRealData() const
Definition TClass.h:451
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
ClassInfo_t * GetClassInfo() const
Definition TClass.h:431
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:578
void Add(TObject *obj) override
Definition TList.h:81
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:470
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:962
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:1004
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:419
void Clear()
Clear string without changing its capacity.
Definition TString.cxx:1221
const char * Data() const
Definition TString.h:378
TString & Append(const char *cs)
Definition TString.h:574
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2334
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