Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TSchemaRuleSet.cxx
Go to the documentation of this file.
1// @(#)root/core:$Id$
2// author: Lukasz Janyst <ljanyst@cern.ch>
3
4#include "TSchemaRuleSet.h"
5#include "TSchemaRule.h"
6#include "TObjArray.h"
7#include "TObjString.h"
8#include "TClass.h"
9#include "TROOT.h"
10#include "TBuffer.h"
11#include <iostream>
12
15#include "TVirtualMutex.h"
16#include "TInterpreter.h" // For gInterpreterMutex
17#include "TStreamerElement.h"
18#include "TClassEdit.h"
19
21
22using namespace ROOT;
23using namespace ROOT::Detail;
24
25////////////////////////////////////////////////////////////////////////////////
26/// Default constructor.
27
28TSchemaRuleSet::TSchemaRuleSet(): fPersistentRules( nullptr ), fRemainingRules( nullptr ),
29 fAllRules( nullptr ), fVersion(-3), fCheckSum( 0 )
30{
33 fAllRules = new TObjArray();
35}
36
37////////////////////////////////////////////////////////////////////////////////
38/// Destructor.
39
41{
42 delete fPersistentRules;
43 delete fRemainingRules;
44 delete fAllRules;
45}
46
47////////////////////////////////////////////////////////////////////////////////
48/// The ls function lists the contents of a class on stdout. Ls output
49/// is typically much less verbose then Dump().
50
52{
54 std::cout << "TSchemaRuleSet for " << fClassName << ":\n";
56 TObject *object = nullptr;
58 while ((object = next())) {
59 object->ls(fClassName);
60 }
62}
63
64////////////////////////////////////////////////////////////////////////////////
65
66Bool_t TSchemaRuleSet::AddRules( TSchemaRuleSet* /* rules */, EConsistencyCheck /* checkConsistency */, TString * /* errmsg */ )
67{
68 return kFALSE;
69}
70
71////////////////////////////////////////////////////////////////////////////////
72/// The consistency check always fails if the TClass object was not set!
73/// if checkConsistency is:
74/// kNoCheck: no check is done, register the rule as is
75/// kCheckConflict: check only for conflicting rules
76/// kCheckAll: check for conflict and check for rule about members that are not in the current class layout.
77/// return kTRUE if the layout is accepted, in which case we take ownership of
78/// the rule object.
79/// return kFALSE if the rule failed one of the test, the rule now needs to be deleted by the caller.
80
82{
83 //---------------------------------------------------------------------------
84 // Cannot verify the consistency if the TClass object is not present
85 /////////////////////////////////////////////////////////////////////////////
86
87 if( (checkConsistency != kNoCheck) && !fClass )
88 return kFALSE;
89
90 if( !rule->IsValid() )
91 return kFALSE;
92
93 //---------------------------------------------------------------------------
94 // If we don't check the consistency then we should just add the object
95 /////////////////////////////////////////////////////////////////////////////
96
97 if( checkConsistency == kNoCheck ) {
98 if( rule->GetEmbed() )
99 fPersistentRules->Add( rule );
100 else
101 fRemainingRules->Add( rule );
102 fAllRules->Add( rule );
103 return kTRUE;
104 }
105
106 //---------------------------------------------------------------------------
107 // Check if all of the target data members specified in the rule are
108 // present int the target class
109 /////////////////////////////////////////////////////////////////////////////
110
111 // Check only if we have some information about the class, otherwise we have
112 // nothing to check against
113 bool streamerInfosTest;
114 {
116 streamerInfosTest = (fClass->GetStreamerInfos()==nullptr || fClass->GetStreamerInfos()->IsEmpty());
117 }
118 if (rule->GetTarget() && fClass->GetState() > TClass::kEmulated && streamerInfosTest)
119 {
120 TObjArrayIter titer( rule->GetTarget() );
121 TObject* obj;
122 while( (obj = titer.Next()) ) {
123 TObjString* str = (TObjString*)obj;
124 if( !fClass->GetDataMember( str->GetString() ) && !fClass->GetBaseClass( str->GetString() ) ) {
125 if (checkConsistency == kCheckAll) {
126 if (errmsg) {
127 errmsg->Form("the target member (%s) is unknown",str->GetString().Data());
128 }
129 return kFALSE;
130 } else {
131 // We ignore the rules that do not apply ...
132 delete rule;
133 return kTRUE;
134 }
135 }
136 }
137 }
138
139 //---------------------------------------------------------------------------
140 // Check if there is a rule conflicting with this one
141 /////////////////////////////////////////////////////////////////////////////
142
143 std::vector<const TSchemaRule*> rules = FindRules( rule->GetSourceClass() );
144 //TObjArrayIter it( rules );
145 //TSchemaRule *r;
146
147 for(auto r : rules) { // while( (obj = it.Next()) ) {
148 if( rule->Conflicts( r ) ) {
149 //delete rules;
150 if ( *r == *rule) {
151 // The rules are duplicate from each other,
152 // just ignore the new ones.
153 if (errmsg) {
154 *errmsg = "it conflicts with one of the other rules";
155 }
156 delete rule;
157 return kTRUE;
158 }
159 if (errmsg) {
160 *errmsg = "The existing rule is:\n ";
161 r->AsString(*errmsg,"s");
162 *errmsg += "\nand the ignored rule is:\n ";
163 rule->AsString(*errmsg);
164 *errmsg += ".\n";
165 }
166 return kFALSE;
167 }
168 }
169
170 //---------------------------------------------------------------------------
171 // No conflicts - insert the rules
172 /////////////////////////////////////////////////////////////////////////////
173
174 if( rule->GetEmbed() )
175 fPersistentRules->Add( rule );
176 else
177 fRemainingRules->Add( rule );
178 fAllRules->Add( rule );
179
180 return kTRUE;
181}
182
183////////////////////////////////////////////////////////////////////////////////
184/// Fill the string 'out' with the string representation of the rule.
185
187{
189 TSchemaRule *rule;
190 while( (rule = (TSchemaRule*)it.Next()) ) {
191 rule->AsString(out);
192 out += "\n";
193 }
194}
195
196////////////////////////////////////////////////////////////////////////////////
197/// Return True if we have any rule whose source class is 'source'.
198
200{
202 TObject *obj;
203 while( (obj = it.Next()) ) {
204 TSchemaRule* rule = (TSchemaRule*)obj;
205 if( rule->GetSourceClass() == source )
206 return kTRUE;
207 }
208 // There was no explicit rule, let's see we have implicit rules.
209 if (fClass->GetCollectionProxy()) {
210 if (fClass->GetCollectionProxy()->GetValueClass() == nullptr) {
211 // We have a numeric collection, let see if the target is
212 // also a numeric collection.
213 TClass *src = TClass::GetClass(source);
214 if (src && src->GetCollectionProxy() &&
215 src->GetCollectionProxy()->HasPointers() == fClass->GetCollectionProxy()->HasPointers()) {
216 TVirtualCollectionProxy *proxy = src->GetCollectionProxy();
217 if (proxy->GetValueClass() == nullptr) {
218 return kTRUE;
219 }
220 }
221 } else {
222 TClass *vTargetClass = fClass->GetCollectionProxy()->GetValueClass();
223 TClass *src = TClass::GetClass(source);
224 if (vTargetClass->GetSchemaRules()) {
225 if (src && src->GetCollectionProxy() &&
226 src->GetCollectionProxy()->HasPointers() == fClass->GetCollectionProxy()->HasPointers()) {
227 TClass *vSourceClass = src->GetCollectionProxy()->GetValueClass();
228 if (vSourceClass) {
229 return vTargetClass->GetSchemaRules()->HasRuleWithSourceClass( vSourceClass->GetName() );
230 }
231 }
232 }
233 }
234 } else if (TClassEdit::IsStdPair(fClass->GetName())) {
235 if (TClassEdit::IsStdPair(source)) {
236 // std::pair can be converted into each other if both its parameter can be converted into
237 // each other.
238 TClass *src = TClass::GetClass(source);
239 if (!src) {
240 Error("HasRuleWithSourceClass","Can not find the TClass for %s when matching with %s\n",source.Data(),fClass->GetName());
241 return kFALSE;
242 }
243 TVirtualStreamerInfo *sourceInfo = src->GetStreamerInfo();
245 if (!sourceInfo) {
246 Error("HasRuleWithSourceClass","Can not find the StreamerInfo for %s when matching with %s\n",source.Data(),fClass->GetName());
247 return kFALSE;
248 }
249 if (!targetInfo) {
250 Error("HasRuleWithSourceClass","Can not find the StreamerInfo for target class %s\n",fClass->GetName());
251 return kFALSE;
252 }
253 for(int i = 0 ; i<2 ; ++i) {
254 TStreamerElement *sourceElement = (TStreamerElement*)sourceInfo->GetElements()->At(i);
255 TStreamerElement *targetElement = (TStreamerElement*)targetInfo->GetElements()->At(i);
256 if (sourceElement->GetClass()) {
257 if (!targetElement->GetClass()) {
258 return kFALSE;
259 }
260 if (sourceElement->GetClass() == targetElement->GetClass()) {
261 continue;
262 }
263 TSchemaRuleSet *rules = sourceElement->GetClass()->GetSchemaRules();
264 if (!rules || !rules->HasRuleWithSourceClass( targetElement->GetClass()->GetName() ) ) {
265 return kFALSE;
266 }
267 } else if (targetElement->GetClass()) {
268 return kFALSE;
269 } else {
270 // both side are numeric element we can deal with it.
271 }
272 }
273 // Both side are pairs and have convertible types, let records this as a renaming rule
274 ROOT::TSchemaRule *ruleobj = new ROOT::TSchemaRule();
275 ruleobj->SetSourceClass(source);
276 ruleobj->SetTargetClass(fClass->GetName());
277 ruleobj->SetVersion("[1-]");
278 const_cast<TSchemaRuleSet*>(this)->AddRule(ruleobj);
279 return kTRUE;
280 }
281 }
282 return kFALSE;
283}
284
285////////////////////////////////////////////////////////////////////////////////
286/// Return all the rules that are about the given 'source' class.
287/// User has to delete the returned array
288
290{
291 TObject* obj;
293 TMatches arr;
294 // arr->SetOwner( kFALSE );
295
296 while( (obj = it.Next()) ) {
297 TSchemaRule* rule = (TSchemaRule*)obj;
298 if( rule->GetSourceClass() == source )
299 arr.push_back( rule );
300 }
301
302#if 0
303 // Le't's see we have implicit rules.
304 if (fClass->GetCollectionProxy()) {
308 // We have a numeric collection, let see if the target is
309 // also a numeric collection (humm just a vector for now)
310 TClass *src = TClass::GetClass(source);
311 if (src && src->GetCollectionProxy()) {
312 TVirtualCollectionProxy *proxy = src->GetCollectionProxy();
313 if (proxy->GetValueClass() == 0) {
314 // ... would need to check if we already have
315 // the rule (or any rule?)
316 }
317 }
318 }
319 }
320#endif
321 return arr;
322}
323
324////////////////////////////////////////////////////////////////////////////////
325/// Return all the rules that applies to the specified version of the given 'source' class.
326/// User has to delete the returned array
327
329{
330 TObject* obj;
332 TMatches arr;
333 // arr->SetOwner( kFALSE );
334
335 while( (obj = it.Next()) ) {
336 TSchemaRule* rule = (TSchemaRule*)obj;
337 if( rule->GetSourceClass() == source && rule->TestVersion( version ) )
338 arr.push_back( rule );
339 }
340
341 return arr;
342}
343
344////////////////////////////////////////////////////////////////////////////////
345/// Return all the rules that applies to the specified checksum of the given 'source' class.
346/// User has to delete the returned array
347
349{
350 TObject* obj;
352 TMatches arr;
353 // arr->SetOwner( kFALSE );
354
355 while( (obj = it.Next()) ) {
356 TSchemaRule* rule = (TSchemaRule*)obj;
357 if( rule->GetSourceClass() == source && rule->TestChecksum( checksum ) )
358 arr.push_back( rule );
359 }
360
361 return arr;
362}
363
364////////////////////////////////////////////////////////////////////////////////
365/// Return all the rules that applies to the specified version OR checksum of the given 'source' class.
366/// User has to delete the returned array
367
368const TSchemaRuleSet::TMatches TSchemaRuleSet::FindRules( const TString &source, Int_t version, UInt_t checksum ) const
369{
370 TObject* obj;
372 TMatches arr;
373 // arr->SetOwner( kFALSE );
374
375 while( (obj = it.Next()) ) {
376 TSchemaRule* rule = (TSchemaRule*)obj;
377 if( rule->GetSourceClass() == source && ( rule->TestVersion( version ) || rule->TestChecksum( checksum ) ) )
378 arr.push_back( rule );
379 }
380
381 return arr;
382}
383
384////////////////////////////////////////////////////////////////////////////////
385
387{
388 return fClass;
389}
390
391////////////////////////////////////////////////////////////////////////////////
392
394{
395 if (fCheckSum == 0 && fClass) {
396 const_cast<TSchemaRuleSet*>(this)->fCheckSum = fClass->GetCheckSum();
397 }
398 return fCheckSum;
399}
400
401////////////////////////////////////////////////////////////////////////////////
402
404{
405 return fClassName;
406}
407
408////////////////////////////////////////////////////////////////////////////////
409
411{
412 return fVersion;
413}
414
415////////////////////////////////////////////////////////////////////////////////
416
418{
419 return fAllRules;
420}
421
422////////////////////////////////////////////////////////////////////////////////
423
425{
426 return fPersistentRules;
427}
428
429////////////////////////////////////////////////////////////////////////////////
430/// Remove given rule from the set - the rule is not being deleted!
431
433{
434 fPersistentRules->Remove( rule );
435 fRemainingRules->Remove( rule );
436 fAllRules->Remove( rule );
437}
438
439////////////////////////////////////////////////////////////////////////////////
440/// remove given array of rules from the set - the rules are not being deleted!
441
443{
444 TObject* obj;
445 TObjArrayIter it( rules );
446
447 while( (obj = it.Next()) ) {
448 fPersistentRules->Remove( obj );
449 fRemainingRules->Remove( obj );
450 fAllRules->Remove( obj );
451 }
452}
453
454////////////////////////////////////////////////////////////////////////////////
455/// Set the TClass associated with this rule set.
456
458{
459 fClass = cls;
460 fClassName = cls->GetName();
461 fVersion = cls->GetClassVersion();
462}
463
464
465////////////////////////////////////////////////////////////////////////////////
466/// Return the rule that has 'name' as a source.
467
469{
470 for( auto rule : *this ) {
471 if( rule->HasSource( name ) ) return rule;
472 }
473 return nullptr;
474}
475
476////////////////////////////////////////////////////////////////////////////////
477/// Return the rule that has 'name' as a target.
478
480{
481 for( auto rule : *this ) {
482 if( rule->HasTarget( name ) ) return rule;
483 }
484 return nullptr;
485}
486
487////////////////////////////////////////////////////////////////////////////////
488/// Return true if the set of rules has at least one rule that has the data
489/// member named 'name' as a source.
490/// If needingAlloc is true, only the rule that requires the data member to
491/// be cached will be taken in consideration.
492
494{
495 for( auto rule : *this ) {
496 if( rule->HasSource( name ) ) {
497 if (needingAlloc) {
498 const TObjArray *targets = rule->GetTarget();
499 if (targets && (targets->GetEntriesFast() > 1 || targets->IsEmpty()) ) {
500 return kTRUE;
501 }
502 if (targets && name != targets->UncheckedAt(0)->GetName() ) {
503 return kTRUE;
504 }
505 // If the rule has the same source and target and does not
506 // have any actions, then it does not need allocation.
507 if (rule->GetReadFunctionPointer() || rule->GetReadRawFunctionPointer()) {
508 return kTRUE;
509 }
510 } else {
511 return kTRUE;
512 }
513 }
514 }
515 return kFALSE;
516}
517
518////////////////////////////////////////////////////////////////////////////////
519/// Return true if the set of rules has at least one rule that has the data
520/// member named 'name' as a target.
521/// If willset is true, only the rule that will set the value of the data member.
522
524{
525 for(auto rule : *this) {
526 if( rule->HasTarget( name ) ) {
527 if (willset) {
528 const TObjArray *targets = rule->GetTarget();
529 if (targets && (targets->GetEntriesFast() > 1 || targets->IsEmpty()) ) {
530 return kTRUE;
531 }
532 const TObjArray *sources = rule->GetSource();
533 if (sources && (sources->GetEntriesFast() > 1 || sources->IsEmpty()) ) {
534 return kTRUE;
535 }
536 if (sources && name != sources->UncheckedAt(0)->GetName() ) {
537 return kTRUE;
538 }
539 // If the rule has the same source and target and does not
540 // have any actions, then it will not directly set the value.
541 if (rule->GetReadFunctionPointer() || rule->GetReadRawFunctionPointer()) {
542 return kTRUE;
543 }
544 } else {
545 return kTRUE;
546 }
547 }
548 }
549 return kFALSE;
550}
551
552////////////////////////////////////////////////////////////////////////////////
553/// Stream an object of class ROOT::TSchemaRuleSet.
554
556{
557 if (R__b.IsReading()) {
559 fAllRules->Clear();
561 } else {
564 }
565}
566
constexpr Bool_t kFALSE
Definition RtypesCore.h:94
constexpr Bool_t kTRUE
Definition RtypesCore.h:93
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:382
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 r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t src
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
#define R__LOCKGUARD(mutex)
const TSchemaRule * GetRuleWithSource(const TString &name) const
Return the rule that has 'name' as a source.
Bool_t HasRuleWithSource(const TString &name, Bool_t needingAlloc) const
Return true if the set of rules has at least one rule that has the data member named 'name' as a sour...
Bool_t HasRuleWithTarget(const TString &name, Bool_t willset) const
Return true if the set of rules has at least one rule that has the data member named 'name' as a targ...
const TSchemaRule * GetRuleWithTarget(const TString &name) const
Return the rule that has 'name' as a target.
void Streamer(TBuffer &) override
Stream an object of class ROOT::TSchemaRuleSet.
TClassRef fClass
Array of all rules.
TString fClassName
Target class pointer (for consistency checking)
void RemoveRule(TSchemaRule *rule)
Remove given rule from the set - the rule is not being deleted!
const TMatches FindRules(const TString &source) const
Return all the rules that are about the given 'source' class.
const TObjArray * GetPersistentRules() const
Bool_t AddRule(TSchemaRule *rule, EConsistencyCheck checkConsistency=kCheckAll, TString *errmsg=nullptr)
The consistency check always fails if the TClass object was not set! if checkConsistency is: kNoCheck...
void AsString(TString &out) const
Fill the string 'out' with the string representation of the rule.
Bool_t AddRules(TSchemaRuleSet *rules, EConsistencyCheck checkConsistency=kCheckAll, TString *errmsg=nullptr)
void ls(Option_t *option="") const override
The ls function lists the contents of a class on stdout.
TObjArray * fAllRules
Array of non-persistent rules - just for cleanup purposes - owns the elements.
void SetClass(TClass *cls)
Set the TClass associated with this rule set.
void RemoveRules(TObjArray *rules)
remove given array of rules from the set - the rules are not being deleted!
const TObjArray * GetRules() const
Bool_t HasRuleWithSourceClass(const TString &source) const
Return True if we have any rule whose source class is 'source'.
virtual ~TSchemaRuleSet()
Destructor.
TSchemaRuleSet()
Default constructor.
void AsString(TString &out, const char *options="") const
Add to the string 'out' the string representation of the rule.
Bool_t TestVersion(Int_t version) const
Check if given version number is defined in this rule.
const TObjArray * GetTarget() const
Get the target data members of this rule (i.e. the in memory data member).
Bool_t Conflicts(const TSchemaRule *rule) const
Check if this rule conflicts with the given one.
void SetTargetClass(const TString &classname)
Set the target class of this rule (i.e. the in memory class).
const char * GetSourceClass() const
Get the source class of this rule (i.e. the onfile class).
Bool_t TestChecksum(UInt_t checksum) const
Check if given checksum is defined in this rule.
Bool_t SetVersion(const TString &version)
Set the version string - returns kFALSE if the format is incorrect.
Bool_t IsValid() const
Return kTRUE if this rule is valid.
Bool_t GetEmbed() const
Return true if this rule should be saved in the ROOT File.
void SetSourceClass(const TString &classname)
Set the source class of this rule (i.e. the onfile class).
Buffer base class used for serializing objects.
Definition TBuffer.h:43
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
UInt_t GetCheckSum(ECheckSum code=kCurrentCheckSum) const
Call GetCheckSum with validity check.
Definition TClass.cxx:6505
TDataMember * GetDataMember(const char *datamember) const
Return pointer to datamember object with name "datamember".
Definition TClass.cxx:3439
EState GetState() const
Definition TClass.h:488
TClass * GetBaseClass(const char *classname)
Return pointer to the base class "classname".
Definition TClass.cxx:2655
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition TClass.cxx:1932
const TObjArray * GetStreamerInfos() const
Definition TClass.h:492
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4599
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2897
@ kEmulated
Definition TClass.h:125
Version_t GetClassVersion() const
Definition TClass.h:420
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
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
Iterator of object array.
Definition TObjArray.h:117
TObject * Next() override
Return next object in array. Returns 0 when no more objects in array.
An array of TObjects.
Definition TObjArray.h:31
Int_t GetEntriesFast() const
Definition TObjArray.h:58
void Clear(Option_t *option="") override
Remove all objects from the array.
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
TObject * UncheckedAt(Int_t i) const
Definition TObjArray.h:84
Bool_t IsEmpty() const override
Definition TObjArray.h:65
TObject * Remove(TObject *obj) override
Remove object from array.
void Add(TObject *obj) override
Definition TObjArray.h:68
Collectable string class.
Definition TObjString.h:28
const TString & GetString() const
Definition TObjString.h:46
Mother of all ROOT objects.
Definition TObject.h:41
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:444
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:993
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition TROOT.cxx:2887
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition TROOT.cxx:2895
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition TROOT.cxx:2746
TClass * GetClass() const
Basic string class.
Definition TString.h:139
const char * Data() const
Definition TString.h:376
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2356
Defines a common interface to inspect/change the contents of an object that represents a collection.
virtual Int_t GetProperties() const
Return miscallenous properties of the proxy (see TVirtualCollectionProxy::EProperty)
virtual TClass * GetValueClass() const =0
If the value type is a user-defined class, return a pointer to the TClass representing the value type...
virtual Int_t GetCollectionType() const =0
Return the type of the proxied collection (see enumeration TClassEdit::ESTLType)
virtual Bool_t HasPointers() const =0
Return true if the content is of type 'pointer to'.
Abstract Interface class describing Streamer information for one class.
virtual TObjArray * GetElements() const =0
Special implementation of ROOT::RRangeCast for TCollection, including a check that the cast target ty...
Definition TObject.h:387
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
bool IsStdPair(std::string_view name)
Definition TClassEdit.h:184