Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TClass.cxx
Go to the documentation of this file.
1// @(#)root/meta:$Id: 7109cb45f1219c2aae6be19906ae5a63e31972ef $
2// Author: Rene Brun 07/01/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 TClass
13TClass instances represent classes, structs and namespaces in the ROOT type system.
14
15TClass instances are created starting from different sources of information:
161. TStreamerInfo instances saved in a ROOT file which is opened. This is called in jargon an *emulated TClass*.
172. From TProtoClass instances saved in a ROOT pcm file created by the dictionary generator and the dictionary itself.
183. From a lookup in the AST built by cling.
19
20If a TClass instance is built through the mechanisms 1. and 2., it does not contain information about methods of the
21class/struct/namespace it represents. Conversely, if built through 3. or 1., it does not carry the information which is necessary
22to ROOT to perform I/O of instances of the class/struct it represents.
23The mechanisms 1., 2. and 3. are not mutually exclusive: it can happen that during the execution of the program, all
24the three are triggered, modifying the state of the TClass instance.
25
26In order to retrieve a TClass instance from the type system, a query can be executed as follows through the static
27TClass::GetClass method:
28
29~~~ {.cpp}
30auto myClassTClass_0 = TClass::GetClass("myClass");
31auto myClassTClass_1 = TClass::GetClass<myClass>();
32auto myClassTClass_2 = TClass::GetClass(myClassTypeInfo);
33~~~
34
35The name of classes is crucial for ROOT. A careful procedure of *name normalization* is carried out for
36each and every class. A *normalized name* is a valid C++ class name.
37In order to access the name of a class within the ROOT type system, the method TClass::GetName() can be used.
38*/
39
40//*-*x7.5 macros/layout_class
41
42#include "TClass.h"
43
44#include "strlcpy.h"
45#include "snprintf.h"
46#include "TBaseClass.h"
47#include "TBrowser.h"
48#include "TBuffer.h"
49#include "TClassGenerator.h"
50#include "TClassEdit.h"
51#include "TClassMenuItem.h"
52#include "TClassRef.h"
53#include "TClassTable.h"
54#include "TDataMember.h"
55#include "TDataType.h"
56#include "TDatime.h"
57#include "TEnum.h"
58#include "TError.h"
59#include "TExMap.h"
60#include "TFunctionTemplate.h"
61#include "THashList.h"
62#include "TInterpreter.h"
63#include "TMemberInspector.h"
64#include "TMethod.h"
65#include "TMethodArg.h"
66#include "TMethodCall.h"
67#include "TObjArray.h"
68#include "TObjString.h"
69#include "TProtoClass.h"
70#include "TROOT.h"
71#include "TRealData.h"
72#include "TCheckHashRecursiveRemoveConsistency.h" // Private header
73#include "TStreamer.h"
74#include "TStreamerElement.h"
77#include "TVirtualIsAProxy.h"
78#include "TVirtualRefProxy.h"
79#include "TVirtualMutex.h"
80#include "TVirtualPad.h"
81#include "THashTable.h"
82#include "TSchemaRuleSet.h"
83#include "TGenericClassInfo.h"
84#include "TIsAProxy.h"
85#include "TSchemaRule.h"
86#include "TSystem.h"
87#include "TThreadSlots.h"
88#include "ThreadLocalStorage.h"
89
90#include <cstdio>
91#include <cctype>
92#include <set>
93#include <iostream>
94#include <sstream>
95#include <string>
96#include <map>
97#include <typeinfo>
98#include <cmath>
99#include <cassert>
100#include <vector>
101#include <memory>
102
103#include "TSpinLockGuard.h"
104
105#ifdef WIN32
106#include <io.h>
107#include "Windows4Root.h"
108#include <Psapi.h>
109#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
110#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
111#else
112#include <dlfcn.h>
113#endif
114
115#include "TListOfDataMembers.h"
116#include "TListOfFunctions.h"
118#include "TListOfEnums.h"
119#include "TListOfEnumsWithLock.h"
120#include "TViewPubDataMembers.h"
121#include "TViewPubFunctions.h"
122#include "TArray.h"
123#include "TClonesArray.h"
124#include "TRef.h"
125#include "TRefArray.h"
126
127using namespace std;
128
129// Mutex to protect CINT and META operations
130// (exported to be used for similar cases in related classes)
131
133
134namespace {
135
136 static constexpr const char kUndeterminedClassInfoName[] = "<NOT YET DETERMINED FROM fClassInfo>";
137
138 class TMmallocDescTemp {
139 private:
140 void *fSave;
141 public:
142 TMmallocDescTemp(void *value = nullptr) :
144 ~TMmallocDescTemp() { ROOT::Internal::gMmallocDesc = fSave; }
145 };
146
147 // When a new class is created, we need to be able to find
148 // if there are any existing classes that have the same name
149 // after any typedefs are expanded. (This only really affects
150 // template arguments.) To avoid having to search through all classes
151 // in that case, we keep a hash table mapping from the fully
152 // typedef-expanded names to the original class names.
153 // An entry is made in the table only if they are actually different.
154 //
155 // In these objects, the TObjString base holds the typedef-expanded
156 // name (the hash key), and fOrigName holds the original class name
157 // (the value to which the key maps).
158 //
159 class TNameMapNode : public TObjString {
160 public:
161 TString fOrigName;
162
163 TNameMapNode(const char *typedf, const char *orig) :
164 TObjString (typedf),
165 fOrigName (orig)
166 {
167 }
168 };
169
170}
171
172std::atomic<Int_t> TClass::fgClassCount;
173
174static bool IsFromRootCling() {
175 // rootcling also uses TCling for generating the dictionary ROOT files.
176 const static bool foundSymbol = dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym");
177 return foundSymbol;
178}
179
180// Implementation of the TDeclNameRegistry
181
182////////////////////////////////////////////////////////////////////////////////
183/// TDeclNameRegistry class constructor.
184
186{
187 // MSVC doesn't support fSpinLock=ATOMIC_FLAG_INIT; in the class definition
188 std::atomic_flag_clear( &fSpinLock );
189}
190
191////////////////////////////////////////////////////////////////////////////////
192/// Extract this part of the name
193/// 1. Templates `ns::%ns2::,,,::%THISPART<...`
194/// 2. Namespaces,classes `ns::%ns2::,,,::%THISPART`
195
197{
198 // Sanity check
199 auto strLen = name ? strlen(name) : 0;
200 if (strLen == 0) return;
201 // find <. If none, put end of string
202 const char* endCharPtr = strchr(name, '<');
203 endCharPtr = !endCharPtr ? &name[strLen] : endCharPtr;
204 // find last : before the <. If not found, put begin of string
205 const char* beginCharPtr = endCharPtr;
206 while (beginCharPtr!=name){
207 if (*beginCharPtr==':'){
208 beginCharPtr++;
209 break;
210 }
211 beginCharPtr--;
212 }
213 beginCharPtr = beginCharPtr!=endCharPtr ? beginCharPtr : name;
214 std::string s(beginCharPtr, endCharPtr);
215 if (fVerbLevel>1)
216 printf("TDeclNameRegistry::AddQualifiedName Adding key %s for class/namespace %s\n", s.c_str(), name);
217 ROOT::Internal::TSpinLockGuard slg(fSpinLock);
218 fClassNamesSet.insert(s);
219}
220
221////////////////////////////////////////////////////////////////////////////////
222
224{
225 Bool_t found = false;
226 {
227 ROOT::Internal::TSpinLockGuard slg(fSpinLock);
228 found = fClassNamesSet.find(name) != fClassNamesSet.end();
229 }
230 return found;
231}
232
233////////////////////////////////////////////////////////////////////////////////
234
236{
237 if (fVerbLevel > 1) {
238 printf("TDeclNameRegistry Destructor. List of %lu names:\n",
239 (long unsigned int)fClassNamesSet.size());
240 for (auto const & key: fClassNamesSet) {
241 printf(" - %s\n", key.c_str());
242 }
243 }
244}
245
246////////////////////////////////////////////////////////////////////////////////
247
249 const char *name,
250 TDeclNameRegistry &emuRegistry): fState(state),fName(name), fNoInfoOrEmuOrFwdDeclNameRegistry(emuRegistry) {}
251
252////////////////////////////////////////////////////////////////////////////////
253
255 if (fState == TClass::kNoInfo ||
259 }
260 }
261
262// Initialise the global member of TClass
264
265//Intent of why/how TClass::New() is called
266//[Not a static data member because MacOS does not support static thread local data member ... who knows why]
268 TTHREAD_TLS(TClass::ENewType) fgCallingNew = TClass::kRealNew;
269 return fgCallingNew;
270}
271
273{
276
278 fCurrentValue(TClass__GetCallingNew()),
279 fOldValue(fCurrentValue)
280 {
281 fCurrentValue = newvalue;
282 }
283
285 {
286 fCurrentValue = fOldValue;
287 }
288};
289
290void TClass::RegisterAddressInRepository(const char * /*where*/, void *location, const TClass *what) const
291{
292 // Register the object for special handling in the destructor.
293
294 Version_t version = what->GetClassVersion();
295// if (!fObjectVersionRepository.count(location)) {
296// Info(where, "Registering address %p of class '%s' version %d", location, what->GetName(), version);
297// } else {
298// Warning(where, "Registering address %p again of class '%s' version %d", location, what->GetName(), version);
299// }
300 {
302 fObjectVersionRepository.insert(RepoCont_t::value_type(location, version));
303 }
304#if 0
305 // This code could be used to prevent an address to be registered twice.
306 std::pair<RepoCont_t::iterator, Bool_t> tmp = fObjectVersionRepository.insert(RepoCont_t::value_type>(location, version));
307 if (!tmp.second) {
308 Warning(where, "Reregistering an object of class '%s' version %d at address %p", what->GetName(), version, p);
309 fObjectVersionRepository.erase(tmp.first);
310 tmp = fObjectVersionRepository.insert(RepoCont_t::value_type>(location, version));
311 if (!tmp.second) {
312 Warning(where, "Failed to reregister an object of class '%s' version %d at address %p", what->GetName(), version, location);
313 }
314 }
315#endif
316}
317
318void TClass::UnregisterAddressInRepository(const char * /*where*/, void *location, const TClass *what) const
319{
320 // Remove an address from the repository of address/object.
321
323 RepoCont_t::iterator cur = fObjectVersionRepository.find(location);
324 for (; cur != fObjectVersionRepository.end();) {
325 RepoCont_t::iterator tmp = cur++;
326 if ((tmp->first == location) && (tmp->second == what->GetClassVersion())) {
327 // -- We still have an address, version match.
328 // Info(where, "Unregistering address %p of class '%s' version %d", location, what->GetName(), what->GetClassVersion());
329 fObjectVersionRepository.erase(tmp);
330 } else {
331 // -- No address, version match, we've reached the end.
332 break;
333 }
334 }
335}
336
337void TClass::MoveAddressInRepository(const char * /*where*/, void *oldadd, void *newadd, const TClass *what) const
338{
339 // Register in the repository that an object has moved.
340
341 // Move not only the object itself but also any base classes or sub-objects.
342 size_t objsize = what->Size();
343 long delta = (char*)newadd - (char*)oldadd;
345 RepoCont_t::iterator cur = fObjectVersionRepository.find(oldadd);
346 for (; cur != fObjectVersionRepository.end();) {
347 RepoCont_t::iterator tmp = cur++;
348 if (oldadd <= tmp->first && tmp->first < ( ((char*)oldadd) + objsize) ) {
349 // The location is within the object, let's move it.
350
351 fObjectVersionRepository.insert(RepoCont_t::value_type(((char*)tmp->first)+delta, tmp->second));
352 fObjectVersionRepository.erase(tmp);
353
354 } else {
355 // -- No address, version match, we've reached the end.
356 break;
357 }
358 }
359}
360
361//______________________________________________________________________________
362//______________________________________________________________________________
363namespace ROOT {
364#define R__USE_STD_MAP
366#if defined R__USE_STD_MAP
367 // This wrapper class allow to avoid putting #include <map> in the
368 // TROOT.h header file.
369 public:
370 typedef std::map<std::string,TClass*> IdMap_t;
374#ifdef R__WIN32
375 // Window's std::map does NOT defined mapped_type
376 typedef TClass* mapped_type;
377#else
379#endif
380
381 private:
383
384 public:
385 void Add(const key_type &key, mapped_type &obj)
386 {
387 // Add the <key,obj> pair to the map.
388 fMap[key] = obj;
389 }
390 mapped_type Find(const key_type &key) const
391 {
392 // Find the type corresponding to the key.
393 IdMap_t::const_iterator iter = fMap.find(key);
394 mapped_type cl = nullptr;
395 if (iter != fMap.end()) cl = iter->second;
396 return cl;
397 }
398 void Remove(const key_type &key) {
399 // Remove the type corresponding to the key.
400 fMap.erase(key);
401 }
402#else
403 private:
404 TMap fMap;
405
406 public:
407#ifdef R__COMPLETE_MEM_TERMINATION
409 TIter next(&fMap);
410 TObjString *key;
411 while((key = (TObjString*)next())) {
412 delete key;
413 }
414 }
415#endif
416 void Add(const char *key, TClass *&obj) {
417 TObjString *realkey = new TObjString(key);
418 fMap.Add(realkey, obj);
419 }
420 TClass* Find(const char *key) const {
421 const TPair *a = (const TPair *)fMap.FindObject(key);
422 if (a) return (TClass*) a->Value();
423 return 0;
424 }
425 void Remove(const char *key) {
426 TObjString realkey(key);
427 TObject *actual = fMap.Remove(&realkey);
428 delete actual;
429 }
430#endif
431 };
432
434 // Wrapper class for the multimap of DeclId_t and TClass.
435 public:
436 typedef multimap<TDictionary::DeclId_t, TClass*> DeclIdMap_t;
440 typedef std::pair <const_iterator, const_iterator> equal_range;
442
443 private:
445
446 public:
447 void Add(const key_type &key, mapped_type obj)
448 {
449 // Add the <key,obj> pair to the map.
450 std::pair<const key_type, mapped_type> pair = make_pair(key, obj);
451 fMap.insert(pair);
452 }
454 {
455 return fMap.count(key);
456 }
457 equal_range Find(const key_type &key) const
458 {
459 // Find the type corresponding to the key.
460 return fMap.equal_range(key);
461 }
462 void Remove(const key_type &key) {
463 // Remove the type corresponding to the key.
464 fMap.erase(key);
465 }
466 };
467}
468
470
471#ifdef R__COMPLETE_MEM_TERMINATION
472 static IdMap_t gIdMapObject;
473 return &gIdMapObject;
474#else
475 static IdMap_t *gIdMap = new IdMap_t;
476 return gIdMap;
477#endif
478}
479
481
482#ifdef R__COMPLETE_MEM_TERMINATION
483 static DeclIdMap_t gDeclIdMapObject;
484 return &gDeclIdMapObject;
485#else
486 static DeclIdMap_t *gDeclIdMap = new DeclIdMap_t;
487 return gDeclIdMap;
488#endif
489}
490
491////////////////////////////////////////////////////////////////////////////////
492/// static: Add a class to the list and map of classes.
493
495{
496 if (!cl) return;
497
499 gROOT->GetListOfClasses()->Add(cl);
500 if (cl->GetTypeInfo()) {
501 GetIdMap()->Add(cl->GetTypeInfo()->name(),cl);
502 }
503 if (cl->fClassInfo) {
504 GetDeclIdMap()->Add((void*)(cl->fClassInfo), cl);
505 }
506}
507
508////////////////////////////////////////////////////////////////////////////////
509/// static: Add a TClass* to the map of classes.
510
512{
513 if (!cl || !id) return;
514 GetDeclIdMap()->Add(id, cl);
515}
516
517////////////////////////////////////////////////////////////////////////////////
518/// static: Remove a class from the list and map of classes
519
521{
522 if (!oldcl) return;
523
525 gROOT->GetListOfClasses()->Remove(oldcl);
526 if (oldcl->GetTypeInfo()) {
527 GetIdMap()->Remove(oldcl->GetTypeInfo()->name());
528 }
529 if (oldcl->fClassInfo) {
530 //GetDeclIdMap()->Remove((void*)(oldcl->fClassInfo));
531 }
532}
533
534////////////////////////////////////////////////////////////////////////////////
535
537{
538 if (!id) return;
539 GetDeclIdMap()->Remove(id);
540}
541
542////////////////////////////////////////////////////////////////////////////////
543/// Indirect call to the implementation of ShowMember allowing [forward]
544/// declaration with out a full definition of the TClass class.
545
546void ROOT::Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector&insp)
547{
548 gInterpreter->InspectMembers(insp, obj, cl, kFALSE);
549}
550
551//______________________________________________________________________________
552//______________________________________________________________________________
553
556public:
557 TDumpMembers(bool noAddr): fNoAddr(noAddr) { }
558
560 void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override;
561};
562
563////////////////////////////////////////////////////////////////////////////////
564/// Print value of member mname.
565///
566/// This method is called by the ShowMembers() method for each
567/// data member when object.Dump() is invoked.
568///
569/// - cl is the pointer to the current class
570/// - pname is the parent name (in case of composed objects)
571/// - mname is the data member name
572/// - add is the data member address
573
574void TDumpMembers::Inspect(TClass *cl, const char *pname, const char *mname, const void *add, Bool_t /* isTransient */)
575{
576 const Int_t kvalue = 30;
577#ifdef R__B64
578 const Int_t ktitle = 50;
579#else
580 const Int_t ktitle = 42;
581#endif
582 const Int_t kline = 1024;
583 Int_t cdate = 0;
584 Int_t ctime = 0;
585 UInt_t *cdatime = nullptr;
586 char line[kline];
587
588 TDataType *membertype;
589 EDataType memberDataType = kNoType_t;
590 const char *memberName;
591 const char *memberFullTypeName;
592 const char *memberTitle;
593 Bool_t isapointer;
594 Bool_t isbasic;
595 Bool_t isarray;
596
597 if (TDataMember *member = cl->GetDataMember(mname)) {
598 if (member->GetDataType()) {
599 memberDataType = (EDataType)member->GetDataType()->GetType();
600 }
601 memberName = member->GetName();
602 memberFullTypeName = member->GetFullTypeName();
603 memberTitle = member->GetTitle();
604 isapointer = member->IsaPointer();
605 isbasic = member->IsBasic();
606 membertype = member->GetDataType();
607 isarray = member->GetArrayDim();
608 } else if (!cl->IsLoaded()) {
609 // The class is not loaded, hence it is 'emulated' and the main source of
610 // information is the StreamerInfo.
612 if (!info) return;
613 const char *cursor = mname;
614 while ( (*cursor)=='*' ) ++cursor;
615 TString elname( cursor );
616 Ssiz_t pos = elname.Index("[");
617 if ( pos != kNPOS ) {
618 elname.Remove( pos );
619 }
620 TStreamerElement *element = (TStreamerElement*)info->GetElements()->FindObject(elname.Data());
621 if (!element) return;
622 memberFullTypeName = element->GetTypeName();
623
624 memberDataType = (EDataType)element->GetType();
625
626 memberName = element->GetName();
627 memberTitle = element->GetTitle();
628 isapointer = element->IsaPointer() || element->GetType() == TVirtualStreamerInfo::kCharStar;
629 membertype = gROOT->GetType(memberFullTypeName);
630
631 isbasic = membertype !=nullptr;
632 isarray = element->GetArrayDim();
633 } else {
634 return;
635 }
636
637
638 Bool_t isdate = kFALSE;
639 if (strcmp(memberName,"fDatime") == 0 && memberDataType == kUInt_t) {
640 isdate = kTRUE;
641 }
642 Bool_t isbits = kFALSE;
643 if (strcmp(memberName,"fBits") == 0 && memberDataType == kUInt_t) {
644 isbits = kTRUE;
645 }
646 TClass * dataClass = TClass::GetClass(memberFullTypeName);
647 Bool_t isTString = (dataClass == TString::Class());
648 static TClassRef stdClass("std::string");
649 Bool_t isStdString = (dataClass == stdClass);
650
651 Int_t i;
652 for (i = 0;i < kline; i++) line[i] = ' ';
653 line[kline-1] = 0;
654 snprintf(line,kline,"%s%s ",pname,mname);
655 i = strlen(line); line[i] = ' ';
656
657 // Encode data value or pointer value
658 char *pointer = (char*)add;
659 char **ppointer = (char**)(pointer);
660
661 if (isapointer) {
662 char **p3pointer = (char**)(*ppointer);
663 if (!p3pointer)
664 snprintf(&line[kvalue],kline-kvalue,"->0");
665 else if (!isbasic) {
666 if (!fNoAddr) {
667 snprintf(&line[kvalue],kline-kvalue,"->%zx ", (size_t)p3pointer);
668 }
669 } else if (membertype) {
670 if (!strcmp(membertype->GetTypeName(), "char")) {
671 i = strlen(*ppointer);
672 if (kvalue+i > kline) i=kline-1-kvalue;
673 Bool_t isPrintable = kTRUE;
674 for (Int_t j = 0; j < i; j++) {
675 if (!std::isprint((*ppointer)[j])) {
676 isPrintable = kFALSE;
677 break;
678 }
679 }
680 if (isPrintable) {
681 strncpy(line + kvalue, *ppointer, i);
682 line[kvalue+i] = 0;
683 } else {
684 line[kvalue] = 0;
685 }
686 } else {
687 strncpy(&line[kvalue], membertype->AsString(p3pointer), TMath::Min(kline-1-kvalue,(int)strlen(membertype->AsString(p3pointer))));
688 }
689 } else if (!strcmp(memberFullTypeName, "char*") ||
690 !strcmp(memberFullTypeName, "const char*")) {
691 i = strlen(*ppointer);
692 if (kvalue+i >= kline) i=kline-1-kvalue;
693 Bool_t isPrintable = kTRUE;
694 for (Int_t j = 0; j < i; j++) {
695 if (!std::isprint((*ppointer)[j])) {
696 isPrintable = kFALSE;
697 break;
698 }
699 }
700 if (isPrintable) {
701 strncpy(line + kvalue, *ppointer, std::min( i, kline - kvalue));
702 line[kvalue+i] = 0;
703 } else {
704 line[kvalue] = 0;
705 }
706 } else {
707 if (!fNoAddr) {
708 snprintf(&line[kvalue],kline-kvalue,"->%zx ", (size_t)p3pointer);
709 }
710 }
711 } else if (membertype) {
712 if (isdate) {
713 cdatime = (UInt_t*)pointer;
714 TDatime::GetDateTime(cdatime[0],cdate,ctime);
715 snprintf(&line[kvalue],kline-kvalue,"%d/%d",cdate,ctime);
716 } else if (isbits) {
717 snprintf(&line[kvalue],kline-kvalue,"0x%08x", *(UInt_t*)pointer);
718 } else {
719 strncpy(&line[kvalue], membertype->AsString(pointer), TMath::Min(kline-1-kvalue,(int)strlen(membertype->AsString(pointer))));
720 }
721 } else {
722 if (isStdString) {
723 std::string *str = (std::string*)pointer;
724 snprintf(&line[kvalue],kline-kvalue,"%s",str->c_str());
725 } else if (isTString) {
726 TString *str = (TString*)pointer;
727 snprintf(&line[kvalue],kline-kvalue,"%s",str->Data());
728 } else {
729 if (!fNoAddr) {
730 snprintf(&line[kvalue],kline-kvalue,"->%zx ", (size_t)pointer);
731 }
732 }
733 }
734 // Encode data member title
735 if (isdate == kFALSE && strcmp(memberFullTypeName, "char*") && strcmp(memberFullTypeName, "const char*")) {
736 i = strlen(&line[0]); line[i] = ' ';
737 assert(250 > ktitle);
738 strlcpy(&line[ktitle],memberTitle,250-ktitle+1); // strlcpy copy 'size-1' characters.
739 }
740 if (isarray) {
741 // Should iterate over the element
742 strncat(line, " ...", kline-strlen(line)-1);
743 }
744 Printf("%s", line);
745}
746
748
749//______________________________________________________________________________
750
752
753private:
756
757public:
758 TBuildRealData(void *obj, TClass *cl) {
759 // Main constructor.
760 fRealDataObject = obj;
761 fRealDataClass = cl;
762 }
764 void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override;
765
766};
767
768////////////////////////////////////////////////////////////////////////////////
769/// This method is called from ShowMembers() via BuildRealdata().
770
771void TBuildRealData::Inspect(TClass* cl, const char* pname, const char* mname, const void* add, Bool_t isTransient)
772{
773 TDataMember* dm = cl->GetDataMember(mname);
774 if (!dm) {
775 return;
776 }
777
778 Bool_t isTransientMember = kFALSE;
779
780 if (!dm->IsPersistent()) {
781 // For the DataModelEvolution we need access to the transient member.
782 // so we now record them in the list of RealData.
783 isTransientMember = kTRUE;
784 isTransient = kTRUE;
785 }
786
787 TString rname( pname );
788 // Take into account cases like TPaveStats->TPaveText->TPave->TBox.
789 // Check that member is in a derived class or an object in the class.
790 if (cl != fRealDataClass) {
791 if (!fRealDataClass->InheritsFrom(cl)) {
792 Ssiz_t dot = rname.Index('.');
793 if (dot == kNPOS) {
794 return;
795 }
796 rname[dot] = '\0';
797 if (!fRealDataClass->GetDataMember(rname)) {
798 //could be a data member in a base class like in this example
799 // class Event : public Data {
800 // class Data : public TObject {
801 // EventHeader fEvtHdr;
802 // class EventHeader {
803 // Int_t fEvtNum;
804 // Int_t fRun;
805 // Int_t fDate;
806 // EventVertex fVertex;
807 // class EventVertex {
808 // EventTime fTime;
809 // class EventTime {
810 // Int_t fSec;
811 // Int_t fNanoSec;
812 if (!fRealDataClass->GetBaseDataMember(rname)) {
813 return;
814 }
815 }
816 rname[dot] = '.';
817 }
818 }
819
820 Longptr_t offset = Longptr_t(((Longptr_t) add) - ((Longptr_t) fRealDataObject));
821
822 if (TClassEdit::IsStdArray(dm->GetTypeName())){ // We tackle the std array case
823 TString rdName;
824 TRealData::GetName(rdName,dm);
825 rname += rdName;
826 TRealData* rd = new TRealData(rname.Data(), offset, dm);
827 fRealDataClass->GetListOfRealData()->Add(rd);
828 return;
829 }
830
831 rname += mname;
832
833 if (dm->IsaPointer()) {
834 // Data member is a pointer.
835 TRealData* rd = new TRealData(rname, offset, dm);
836 if (isTransientMember) { rd->SetBit(TRealData::kTransient); };
837 fRealDataClass->GetListOfRealData()->Add(rd);
838 } else {
839 // Data Member is a basic data type.
840 TRealData* rd = new TRealData(rname, offset, dm);
841 if (isTransientMember) { rd->SetBit(TRealData::kTransient); };
842 if (!dm->IsBasic()) {
843 rd->SetIsObject(kTRUE);
844
845 // Make sure that BuildReadData is called for any abstract
846 // bases classes involved in this object, i.e for all the
847 // classes composing this object (base classes, type of
848 // embedded object and same for their data members).
849 //
850 TClass* dmclass = TClass::GetClass(dm->GetTypeName(), kTRUE, isTransient);
851 if (!dmclass) {
852 dmclass = TClass::GetClass(dm->GetTrueTypeName(), kTRUE, isTransient);
853 }
854 if (dmclass) {
855 if ((dmclass != cl) && !dm->IsaPointer()) {
856 if (dmclass->GetCollectionProxy()) {
857 TClass* valcl = dmclass->GetCollectionProxy()->GetValueClass();
858 // We create the real data for the content of the collection to help the case
859 // of split branches in a TTree (where the node for the data member itself
860 // might have been elided). However, in some cases, like transient members
861 // and/or classes, the content might not be create-able. An example is the
862 // case of a map<A,B> where either A or B does not have default constructor
863 // and thus the compilation of the default constructor for pair<A,B> will
864 // fail (noisily) [This could also apply to any template instance, where it
865 // might have a default constructor definition that can not be compiled due
866 // to the template parameter]
867 if (valcl) {
868 Bool_t wantBuild = kTRUE;
869 if (valcl->Property() & kIsAbstract) wantBuild = kFALSE;
870 if ( (isTransient)
872 && (!valcl->IsLoaded()) ) {
873 // Case where the collection dictionary was not requested and
874 // the content's dictionary was also not requested.
875 // [This is a super set of what we need, but we can't really detect it :(]
876 wantBuild = kFALSE;
877 }
878
879 if (wantBuild) valcl->BuildRealData(nullptr, isTransient);
880 }
881 } else {
882 void* addrForRecursion = nullptr;
883 if (GetObjectValidity() == kValidObjectGiven)
884 addrForRecursion = const_cast<void*>(add);
885
886 dmclass->BuildRealData(addrForRecursion, isTransient);
887 }
888 }
889 }
890 }
891 fRealDataClass->GetListOfRealData()->Add(rd);
892 }
893}
894
895//______________________________________________________________________________
896//______________________________________________________________________________
897//______________________________________________________________________________
898
899////////////////////////////////////////////////////////////////////////////////
900
902public:
905
907 {
908 // main constructor.
909 fBrowser = b; fCount = 0;
910 }
911 virtual ~TAutoInspector() {}
913 void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override;
915};
916
917////////////////////////////////////////////////////////////////////////////////
918/// This method is called from ShowMembers() via AutoBrowse().
919
920void TAutoInspector::Inspect(TClass *cl, const char *tit, const char *name,
921 const void *addr, Bool_t /* isTransient */)
922{
923 if(tit && strchr(tit,'.')) return ;
924 if (fCount && !fBrowser) return;
925
926 TString ts;
927
928 if (!cl) return;
929 //if (*(cl->GetName()) == 'T') return;
930 if (*name == '*') name++;
931 int ln = strcspn(name,"[ ");
932 TString iname(name,ln);
933
934 ClassInfo_t *classInfo = cl->GetClassInfo();
935 if (!classInfo) return;
936
937 // Browse data members
939 TString mname;
940
941 int found=0;
942 while (gCling->DataMemberInfo_Next(m)) { // MemberLoop
943 mname = gCling->DataMemberInfo_Name(m);
944 mname.ReplaceAll("*","");
945 if ((found = (iname==mname))) break;
946 }
947 assert(found);
948
949 // we skip: non static members and non objects
950 // - the member G__virtualinfo inserted by the CINT RTTI system
951
952 //Long_t prop = m.Property() | m.Type()->Property();
954 if (prop & kIsStatic) return;
955 if (prop & kIsFundamental) return;
956 if (prop & kIsEnum) return;
957 if (mname == "G__virtualinfo") return;
958
959 int size = sizeof(void*);
960
961 int nmax = 1;
962 if (prop & kIsArray) {
963 for (int dim = 0; dim < gCling->DataMemberInfo_ArrayDim(m); dim++) nmax *= gCling->DataMemberInfo_MaxIndex(m,dim);
964 }
965
968 TClass * clm = TClass::GetClass(clmName.c_str());
969 R__ASSERT(clm);
970 if (!(prop & kIsPointer)) {
971 size = clm->Size();
973 }
974
975
978
979 for(int i=0; i<nmax; i++) {
980
981 char *ptr = (char*)addr + i*size;
982
983 void *obj = (prop & kIsPointer) ? *((void**)ptr) : (TObject*)ptr;
984
985 if (!obj) continue;
986
987 fCount++;
988 if (!fBrowser) return;
989
990 TString bwname;
991 TClass *actualClass = clm->GetActualClass(obj);
992 if (clm->IsTObject()) {
993 TObject *tobj = (TObject*)clm->DynamicCast(TObject::Class(),obj);
994 bwname = tobj->GetName();
995 } else {
996 bwname = actualClass->GetName();
997 bwname += "::";
998 bwname += mname;
999 }
1000
1001 if (!clm->IsTObject() ||
1002 bwname.Length()==0 ||
1003 strcmp(bwname.Data(),actualClass->GetName())==0) {
1004 bwname = name;
1005 int l = strcspn(bwname.Data(),"[ ");
1006 if (l<bwname.Length() && bwname[l]=='[') {
1007 char cbuf[13]; snprintf(cbuf,13,"[%02d]",i);
1008 ts.Replace(0,999,bwname,l);
1009 ts += cbuf;
1010 bwname = (const char*)ts;
1011 }
1012 }
1013
1014 if (proxy==nullptr) {
1015
1016 fBrowser->Add(obj,clm,bwname);
1017
1018 } else {
1019 TClass *valueCl = proxy->GetValueClass();
1020
1021 if (valueCl==nullptr) {
1022
1023 fBrowser->Add( obj, clm, bwname );
1024
1025 } else {
1026 TVirtualCollectionProxy::TPushPop env(proxy, obj);
1027 TClass *actualCl = nullptr;
1028
1029 int sz = proxy->Size();
1030
1031 char fmt[] = {"#%09d"};
1032 fmt[3] = '0'+(int)log10(double(sz))+1;
1033 char buf[20];
1034 for (int ii=0;ii<sz;ii++) {
1035 void *p = proxy->At(ii);
1036
1037 if (proxy->HasPointers()) {
1038 p = *((void**)p);
1039 if(!p) continue;
1040 actualCl = valueCl->GetActualClass(p);
1041 p = actualCl->DynamicCast(valueCl,p,0);
1042 }
1043 fCount++;
1044 snprintf(buf,20,fmt,ii);
1045 ts = bwname;
1046 ts += buf;
1047 fBrowser->Add( p, actualCl, ts );
1048 }
1049 }
1050 }
1051 }
1052}
1053
1054//______________________________________________________________________________
1055//______________________________________________________________________________
1056//______________________________________________________________________________
1057
1059
1060////////////////////////////////////////////////////////////////////////////////
1061/// Internal, default constructor.
1062///
1063/// \note Use `TClass::GetClass("ClassName")` to get access to a TClass object for a certain class!
1064
1066 TDictionary(),
1067 fPersistentRef(nullptr),
1068 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1069 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1070 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1072 fInstanceCount(0), fOnHeap(0),
1073 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1074 fTypeInfo(nullptr), fShowMembers(nullptr),
1075 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1076 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1077 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1080 fState(kNoInfo),
1081 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1083
1084{
1085 // Default ctor.
1086
1088 {
1089 TMmallocDescTemp setreset;
1090 fStreamerInfo = new TObjArray(1, -2);
1091 }
1092 fDeclFileLine = -2; // -2 for standalone TClass (checked in dtor)
1093}
1094
1095////////////////////////////////////////////////////////////////////////////////
1096/// Create a TClass object. This object contains the full dictionary
1097/// of a class. It has list to baseclasses, datamembers and methods.
1098/// Use this ctor to create a standalone TClass object. Only useful
1099/// to get a temporary TClass interface to an interpreted class. Used by TTabCom.
1100///
1101/// \note Use `TClass::GetClass("ClassName")` to get access to a TClass object for a certain class!
1102
1103TClass::TClass(const char *name, Bool_t silent) :
1105 fPersistentRef(nullptr),
1106 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1107 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1108 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1109 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1110 fInstanceCount(0), fOnHeap(0),
1111 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1112 fTypeInfo(nullptr), fShowMembers(nullptr),
1113 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1114 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1115 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1116 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1117 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1118 fState(kNoInfo),
1119 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1120 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1121{
1123
1124 if (!gROOT)
1125 ::Fatal("TClass::TClass", "ROOT system not initialized");
1126
1127 {
1128 TMmallocDescTemp setreset;
1129 fStreamerInfo = new TObjArray(1, -2);
1130 }
1131 fDeclFileLine = -2; // -2 for standalone TClass (checked in dtor)
1132
1134 if (!gInterpreter)
1135 ::Fatal("TClass::TClass", "gInterpreter not initialized");
1136
1137 gInterpreter->SetClassInfo(this); // sets fClassInfo pointer
1138 if (!silent && !fClassInfo && !TClassEdit::IsArtificial(name))
1139 ::Warning("TClass::TClass", "no dictionary for class %s is available", name);
1141
1143 fConversionStreamerInfo = nullptr;
1144}
1145
1146////////////////////////////////////////////////////////////////////////////////
1147/// Internal constructor.
1148///
1149/// \note Use `TClass::GetClass("ClassName")` to get access to a TClass object for a certain class!
1150
1151TClass::TClass(const char *name, Version_t cversion, Bool_t silent) :
1153 fPersistentRef(nullptr),
1154 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1155 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1156 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1157 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1158 fInstanceCount(0), fOnHeap(0),
1159 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1160 fTypeInfo(nullptr), fShowMembers(nullptr),
1161 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1162 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1163 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1164 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1165 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1166 fState(kNoInfo),
1167 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1168 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1169{
1171 Init(name, cversion, nullptr, nullptr, nullptr, nullptr, -1, -1, nullptr, silent);
1172}
1173
1174////////////////////////////////////////////////////////////////////////////////
1175/// Internal constructor, mimicing the case of a class fwd declared in the interpreter.
1176///
1177/// \note Use `TClass::GetClass("ClassName")` to get access to a TClass object for a certain class!
1178
1179TClass::TClass(const char *name, Version_t cversion, EState theState, Bool_t silent) :
1181 fPersistentRef(nullptr),
1182 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1183 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1184 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1185 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1186 fInstanceCount(0), fOnHeap(0),
1187 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1188 fTypeInfo(nullptr), fShowMembers(nullptr),
1189 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1190 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1191 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1192 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1193 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1194 fState(theState),
1195 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1196 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1197{
1199
1200 // Treat the case in which a TClass instance is created for a namespace
1201 if (theState == kNamespaceForMeta){
1203 theState = kForwardDeclared; // it immediately decays in kForwardDeclared
1204 }
1205
1206 if (theState != kForwardDeclared && theState != kEmulated)
1207 ::Fatal("TClass::TClass",
1208 "A TClass entry cannot be initialized in a state different from kForwardDeclared or kEmulated.");
1209 Init(name, cversion, nullptr, nullptr, nullptr, nullptr, -1, -1, nullptr, silent);
1210}
1211
1212////////////////////////////////////////////////////////////////////////////////
1213/// Internal constructor.
1214///
1215/// Create a TClass object. This object contains the full dictionary
1216/// of a class. It has list to baseclasses, datamembers and methods.
1217/// Use this ctor to create a standalone TClass object. Most useful
1218/// to get a TClass interface to an interpreted class. Used by TTabCom.
1219///
1220/// This copies the ClassInfo (i.e. does *not* take ownership of it).
1221///
1222/// \note Use `TClass::GetClass("class")` to get access to a TClass object for a certain class!
1223
1224TClass::TClass(ClassInfo_t *classInfo, Version_t cversion,
1225 const char *dfil, const char *ifil, Int_t dl, Int_t il, Bool_t silent) :
1226 TDictionary(""),
1227 fPersistentRef(nullptr),
1228 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1229 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1230 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1231 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1232 fInstanceCount(0), fOnHeap(0),
1233 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1234 fTypeInfo(nullptr), fShowMembers(nullptr),
1235 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1236 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1237 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1238 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1239 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1240 fState(kNoInfo),
1241 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1242 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1243{
1245
1246 if (!gROOT)
1247 ::Fatal("TClass::TClass", "ROOT system not initialized");
1248
1249 fDeclFileLine = -2; // -2 for standalone TClass (checked in dtor)
1250
1252 if (!gInterpreter)
1253 ::Fatal("TClass::TClass", "gInterpreter not initialized");
1254
1255 if (!classInfo || !gInterpreter->ClassInfo_IsValid(classInfo)) {
1256 MakeZombie();
1257 fState = kNoInfo;
1258 } else {
1259 fName = gInterpreter->ClassInfo_FullName(classInfo);
1260
1262 Init(fName, cversion, nullptr, nullptr, dfil, ifil, dl, il, classInfo, silent);
1263 }
1265
1266 fConversionStreamerInfo = nullptr;
1267}
1268
1269
1270////////////////////////////////////////////////////////////////////////////////
1271/// Internal constructor.
1272///
1273/// \note Use `TClass::GetClass("class")` to get access to a TClass object for a certain class!
1274
1275TClass::TClass(const char *name, Version_t cversion,
1276 const char *dfil, const char *ifil, Int_t dl, Int_t il, Bool_t silent) :
1278 fPersistentRef(nullptr),
1279 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1280 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1281 fAllPubMethod(nullptr), fClassMenuList(nullptr),
1282 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1283 fInstanceCount(0), fOnHeap(0),
1284 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1285 fTypeInfo(nullptr), fShowMembers(nullptr),
1286 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1287 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1288 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1289 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1290 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1291 fState(kNoInfo),
1292 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1293 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1294{
1296 Init(name,cversion, nullptr, nullptr, dfil, ifil, dl, il, nullptr, silent);
1297}
1298
1299////////////////////////////////////////////////////////////////////////////////
1300/// Internal constructor.
1301///
1302/// \note Use `TClass::GetClass("class")` to get access to a TClass object for a certain class!
1303
1304TClass::TClass(const char *name, Version_t cversion,
1305 const std::type_info &info, TVirtualIsAProxy *isa,
1306 const char *dfil, const char *ifil, Int_t dl, Int_t il,
1307 Bool_t silent) :
1309 fPersistentRef(nullptr),
1310 fStreamerInfo(nullptr), fConversionStreamerInfo(nullptr), fRealData(nullptr),
1311 fBase(nullptr), fData(nullptr), fUsingData(nullptr), fEnums(nullptr), fFuncTemplate(nullptr), fMethod(nullptr), fAllPubData(nullptr),
1312 fAllPubMethod(nullptr),
1313 fClassMenuList(nullptr),
1314 fDeclFileName(""), fImplFileName(""), fDeclFileLine(0), fImplFileLine(0),
1315 fInstanceCount(0), fOnHeap(0),
1316 fCheckSum(0), fCollectionProxy(nullptr), fClassVersion(0), fClassInfo(nullptr),
1317 fTypeInfo(nullptr), fShowMembers(nullptr),
1318 fStreamer(nullptr), fIsA(nullptr), fGlobalIsA(nullptr), fIsAMethod(nullptr),
1319 fMerge(nullptr), fResetAfterMerge(nullptr), fNew(nullptr), fNewArray(nullptr), fDelete(nullptr), fDeleteArray(nullptr),
1320 fDestructor(nullptr), fDirAutoAdd(nullptr), fStreamerFunc(nullptr), fConvStreamerFunc(nullptr), fSizeof(-1),
1321 fCanSplit(-1), fIsSyntheticPair(kFALSE), fHasCustomStreamerMember(kFALSE), fProperty(0), fClassProperty(0), fHasRootPcmInfo(kFALSE), fCanLoadClassInfo(kFALSE),
1322 fIsOffsetStreamerSet(kFALSE), fVersionUsed(kFALSE), fRuntimeProperties(0), fOffsetStreamer(0), fStreamerType(TClass::kDefault),
1323 fState(kHasTClassInit),
1324 fCurrentInfo(nullptr), fLastReadInfo(nullptr), fRefProxy(nullptr),
1325 fSchemaRules(nullptr), fStreamerImpl(&TClass::StreamerDefault)
1326{
1328 // use info
1329 Init(name, cversion, &info, isa, dfil, ifil, dl, il, nullptr, silent);
1330}
1331
1332////////////////////////////////////////////////////////////////////////////////
1333/// we found at least one equivalent.
1334/// let's force a reload
1335
1337{
1338 TClass::RemoveClass(oldcl);
1339
1340 if (oldcl->CanIgnoreTObjectStreamer()) {
1342 }
1343
1345 TIter next(oldcl->GetStreamerInfos());
1346 while ((info = (TVirtualStreamerInfo*)next())) {
1347 info->Clear("build");
1348 info->SetClass(this);
1349 if (IsSyntheticPair()) {
1350 // Some pair's StreamerInfo were inappropriately marked as versioned
1351 info->SetClassVersion(1);
1352 // There is already a TStreamerInfo put there by the synthetic
1353 // creation.
1354 fStreamerInfo->Add(info);
1355 } else {
1357 }
1358 }
1359 oldcl->fStreamerInfo->Clear();
1360
1361 oldcl->ReplaceWith(this);
1362 delete oldcl;
1363}
1364
1365////////////////////////////////////////////////////////////////////////////////
1366/// Initialize a TClass object. This object contains the full dictionary
1367/// of a class. It has list to baseclasses, datamembers and methods.
1368
1369void TClass::Init(const char *name, Version_t cversion,
1370 const std::type_info *typeinfo, TVirtualIsAProxy *isa,
1371 const char *dfil, const char *ifil, Int_t dl, Int_t il,
1372 ClassInfo_t *givenInfo,
1373 Bool_t silent)
1374{
1375 if (!gROOT)
1376 ::Fatal("TClass::TClass", "ROOT system not initialized");
1377 if (!name || !name[0]) {
1378 ::Error("TClass::Init", "The name parameter is invalid (null or empty)");
1379 MakeZombie();
1380 return;
1381 }
1382 // Always strip the default STL template arguments (from any template argument or the class name)
1384 fName = name; // We can assume that the artificial class name is already normalized.
1385 else
1387
1388 fClassVersion = cversion;
1389 fDeclFileName = dfil ? dfil : "";
1390 fImplFileName = ifil ? ifil : "";
1391 fDeclFileLine = dl;
1392 fImplFileLine = il;
1393 fTypeInfo = typeinfo;
1394 fIsA = isa;
1395 if ( fIsA ) fIsA->SetClass(this);
1396 // See also TCling::GenerateTClass() which will update fClassVersion after creation!
1397 fStreamerInfo = new TObjArray(fClassVersion+2+10,-1); // +10 to read new data by old
1398 fProperty = -1;
1399 fClassProperty = 0;
1400 const bool ispair = TClassEdit::IsStdPair(fName);
1401 if (ispair)
1403
1405
1406 TClass *oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(fName.Data());
1407
1409
1410 if (oldcl && oldcl->TestBit(kLoading)) {
1411 // Do not recreate a class while it is already being created!
1412
1413 // We can no longer reproduce this case, to check whether we are, we use
1414 // this code:
1415 // Fatal("Init","A bad replacement for %s was requested\n",name);
1416 return;
1417 }
1418
1419 TClass **persistentRef = nullptr;
1420 if (oldcl) {
1421
1422 persistentRef = oldcl->fPersistentRef.exchange(nullptr);
1423
1424 // The code from here is also in ForceReload.
1425 TClass::RemoveClass(oldcl);
1426 // move the StreamerInfo immediately so that there are
1427 // properly updated!
1428
1429 if (oldcl->CanIgnoreTObjectStreamer()) {
1431 }
1433
1434 TIter next(oldcl->GetStreamerInfos());
1435 while ((info = (TVirtualStreamerInfo*)next())) {
1436 // We need to force a call to BuildOld
1437 info->Clear("build");
1438 info->SetClass(this);
1440 }
1441 oldcl->fStreamerInfo->Clear();
1442 // The code diverges here from ForceReload.
1443
1444 // Move the Schema Rules too.
1445 fSchemaRules = oldcl->fSchemaRules;
1446 oldcl->fSchemaRules = nullptr;
1447
1448 // Move the TFunctions.
1450 if (fFuncTemplate)
1451 fFuncTemplate->fClass = this;
1452 oldcl->fFuncTemplate = nullptr;
1453 fMethod.store( oldcl->fMethod );
1454 if (fMethod)
1455 (*fMethod).fClass = this;
1456 oldcl->fMethod = nullptr;
1457
1458 }
1459
1461 // Advertise ourself as the loading class for this class name
1462 TClass::AddClass(this);
1463
1465
1466 if (!gInterpreter)
1467 ::Fatal("TClass::Init", "gInterpreter not initialized");
1468
1469 if (givenInfo) {
1470 bool invalid = !gInterpreter->ClassInfo_IsValid(givenInfo);
1471 bool notloaded = !gInterpreter->ClassInfo_IsLoaded(givenInfo);
1472 auto property = gInterpreter->ClassInfo_Property(givenInfo);
1473
1474 if (invalid || (notloaded && (property & kIsNamespace)) ||
1477 MakeZombie();
1478 fState = kNoInfo;
1479 TClass::RemoveClass(this);
1480 return;
1481 }
1482 }
1483
1484 if (!invalid) {
1485 fClassInfo = gInterpreter->ClassInfo_Factory(givenInfo);
1486 fCanLoadClassInfo = false; // avoids calls to LoadClassInfo() if info is already loaded
1487 if (fState <= kEmulated)
1489 }
1490 }
1491
1492 // We need to check if the class it is not fwd declared for the cases where we
1493 // created a TClass directly in the kForwardDeclared state. Indeed in those cases
1494 // fClassInfo will always be nullptr.
1496
1497 if (fState == kHasTClassInit) {
1498 // If the TClass is being generated from a ROOT dictionary,
1499 // even though we do not seem to have a CINT dictionary for
1500 // the class, we will will try to load it anyway UNLESS
1501 // the class is an STL container (or string).
1502 // This is because we do not expect the CINT dictionary
1503 // to be present for all STL classes (and we can handle
1504 // the lack of CINT dictionary in that cases).
1505 // However, the cling the dictionary no longer carries
1506 // an instantiation with it, unless we request the loading
1507 // here *or* the user explicitly instantiate the template
1508 // we would not have a ClassInfo for the template
1509 // instantiation.
1511 // Here we check and grab the info from the rootpcm.
1513 if (proto)
1514 proto->FillTClass(this);
1515 }
1516 if (!fHasRootPcmInfo && gInterpreter->CheckClassInfo(fName, /* autoload = */ kTRUE)) {
1517 gInterpreter->SetClassInfo(this, kFALSE, silent); // sets fClassInfo pointer
1518 if (fClassInfo) {
1519 // This should be moved out of GetCheckSum itself however the last time
1520 // we tried this cause problem, in particular in the end-of-process operation.
1521 // fCheckSum = GetCheckSum(kLatestCheckSum);
1522 } else {
1523 if (!fClassInfo) {
1524 if (IsZombie()) {
1525 TClass::RemoveClass(this);
1526 return;
1527 }
1528 }
1529 }
1530 }
1531 }
1532 if (!silent && (!fClassInfo && !fCanLoadClassInfo) && !isStl && !TClassEdit::IsArtificial(fName) &&
1534 if (fState == kHasTClassInit) {
1535 if (fImplFileLine == -1 && fClassVersion == 0) {
1536 // We have a 'transient' class with a ClassDefInline and apparently no interpreter
1537 // information. Since it is transient, it is more than likely that the lack
1538 // will be harmles.
1539 } else {
1540 ::Error("TClass::Init", "no interpreter information for class %s is available even though it has a TClass "
1541 "initialization routine.",
1542 fName.Data());
1543 }
1544 } else {
1545 const bool ispairbase = TClassEdit::IsStdPairBase(fName.Data()) && !IsFromRootCling();
1546 if (!ispairbase)
1547 ::Warning("TClass::Init", "no dictionary for class %s is available", fName.Data());
1548 }
1549 }
1550
1551 fgClassCount++;
1553
1554 // Make the typedef-expanded -> original hash table entries.
1555 // There may be several entries for any given key.
1556 // We only make entries if the typedef-expanded name
1557 // is different from the original name.
1558 TString resolvedThis;
1559 if (!givenInfo && strchr (name, '<')) {
1560 if ( fName != name) {
1561 if (!fgClassTypedefHash) {
1562 fgClassTypedefHash = new THashTable (100, 5);
1564 }
1565
1566 fgClassTypedefHash->Add (new TNameMapNode (name, fName));
1568
1569 }
1570 resolvedThis = TClassEdit::ResolveTypedef (name, kTRUE);
1571 if (resolvedThis != name) {
1572 if (!fgClassTypedefHash) {
1573 fgClassTypedefHash = new THashTable (100, 5);
1575 }
1576
1577 fgClassTypedefHash->Add (new TNameMapNode (resolvedThis, fName));
1579 }
1580
1581 }
1582
1583 //In case a class with the same name had been created by TVirtualStreamerInfo
1584 //we must delete the old class, importing only the StreamerInfo structure
1585 //from the old dummy class.
1586 if (oldcl) {
1587
1588 oldcl->ReplaceWith(this);
1589 delete oldcl;
1590
1591 } else if (!givenInfo && resolvedThis.Length() > 0 && fgClassTypedefHash) {
1592
1593 // Check for existing equivalent.
1594
1595 if (resolvedThis != fName) {
1596 oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(resolvedThis);
1597 if (oldcl && oldcl != this) {
1598 persistentRef = oldcl->fPersistentRef.exchange(nullptr);
1599 ForceReload (oldcl);
1600 }
1601 }
1602 TIter next( fgClassTypedefHash->GetListForObject(resolvedThis) );
1603 while ( TNameMapNode* htmp = static_cast<TNameMapNode*> (next()) ) {
1604 if (resolvedThis != htmp->String()) continue;
1605 oldcl = (TClass*)gROOT->GetListOfClasses()->FindObject(htmp->fOrigName); // gROOT->GetClass (htmp->fOrigName, kFALSE);
1606 if (oldcl && oldcl != this) {
1607 persistentRef = oldcl->fPersistentRef.exchange(nullptr);
1608 ForceReload (oldcl);
1609 }
1610 }
1611 }
1612 if (fClassInfo) {
1614 if ( fDeclFileName == nullptr || fDeclFileName[0] == '\0' ) {
1615 fDeclFileName = kUndeterminedClassInfoName;
1616 // Missing interface:
1617 // fDeclFileLine = gInterpreter->ClassInfo_FileLine( fClassInfo );
1618
1619 // But really do not want to set ImplFileLine as it is currently the
1620 // marker of being 'loaded' or not (reminder loaded == has a TClass bootstrap).
1621 }
1622 }
1623
1624 if (persistentRef) {
1625 fPersistentRef = persistentRef;
1626 } else {
1627 fPersistentRef = new TClass*;
1628 }
1629 *fPersistentRef = this;
1630
1631 if ( isStl || !strncmp(GetName(),"stdext::hash_",13) || !strncmp(GetName(),"__gnu_cxx::hash_",16) ) {
1632 if (fState != kHasTClassInit) {
1633 // If we have a TClass compiled initialization, we can safely assume that
1634 // there will also be a collection proxy.
1636 if (fCollectionProxy) {
1638
1639 // Numeric Collections have implicit conversions:
1641
1642 } else if (!silent) {
1643 Warning("Init","Collection proxy for %s was not properly initialized!",GetName());
1644 }
1645 if (fStreamer==nullptr) {
1647 }
1648 }
1649 } else if (TClassEdit::IsStdPair(GetName())) {
1650 // std::pairs have implicit conversions
1652 }
1653
1655}
1656
1657////////////////////////////////////////////////////////////////////////////////
1658/// TClass dtor. Deletes all list that might have been created.
1659
1661{
1663
1664 // Remove from the typedef hashtables.
1666 TString resolvedThis = TClassEdit::ResolveTypedef (GetName(), kTRUE);
1667 TIter next (fgClassTypedefHash->GetListForObject (resolvedThis));
1668 while ( TNameMapNode* htmp = static_cast<TNameMapNode*> (next()) ) {
1669 if (resolvedThis == htmp->String() && htmp->fOrigName == GetName()) {
1670 fgClassTypedefHash->Remove (htmp);
1671 delete htmp;
1672 break;
1673 }
1674 }
1675 }
1676
1677 // Not owning lists, don't call Delete()
1678 // But this still need to be done first because the TList destructor
1679 // does access the object contained (via GetObject()->TestBit(kCanDelete))
1680 delete fStreamer; fStreamer =nullptr;
1681 delete fAllPubData; fAllPubData =nullptr;
1682 delete fAllPubMethod; fAllPubMethod=nullptr;
1683
1684 delete fPersistentRef.load();
1685
1686 if (fBase.load())
1687 (*fBase).Delete();
1688 delete fBase.load(); fBase = nullptr;
1689
1690 if (fData.load())
1691 (*fData).Delete();
1692 delete fData.load(); fData = nullptr;
1693
1694 if (fUsingData.load())
1695 (*fUsingData).Delete();
1696 delete fUsingData.load(); fUsingData = nullptr;
1697
1698 if (fEnums.load())
1699 (*fEnums).Delete();
1700 delete fEnums.load(); fEnums = nullptr;
1701
1702 if (fFuncTemplate)
1704 delete fFuncTemplate; fFuncTemplate = nullptr;
1705
1706 if (fMethod.load())
1707 (*fMethod).Delete();
1708 delete fMethod.load(); fMethod=nullptr;
1709
1710 if (fRealData)
1711 fRealData->Delete();
1712 delete fRealData; fRealData=nullptr;
1713
1714 if (fStreamerInfo)
1716 delete fStreamerInfo; fStreamerInfo = nullptr;
1717
1718 if (fDeclFileLine >= -1)
1719 TClass::RemoveClass(this);
1720
1722 fClassInfo=nullptr;
1723
1724 if (fClassMenuList)
1726 delete fClassMenuList; fClassMenuList=nullptr;
1727
1729
1730 if ( fIsA ) delete fIsA;
1731
1732 if ( fRefProxy ) fRefProxy->Release();
1733 fRefProxy = nullptr;
1734
1735 delete fStreamer;
1736 delete fCollectionProxy;
1737 delete fIsAMethod.load();
1738 delete fSchemaRules;
1739 if (fConversionStreamerInfo.load()) {
1740 std::map<std::string, TObjArray*>::iterator it;
1741 std::map<std::string, TObjArray*>::iterator end = (*fConversionStreamerInfo).end();
1742 for( it = (*fConversionStreamerInfo).begin(); it != end; ++it ) {
1743 delete it->second;
1744 }
1745 delete fConversionStreamerInfo.load();
1746 }
1747}
1748
1749////////////////////////////////////////////////////////////////////////////////
1750
1751namespace {
1752 Int_t ReadRulesContent(FILE *f)
1753 {
1754 // Read a class.rules file which contains one rule per line with comment
1755 // starting with a #
1756 // Returns the number of rules loaded.
1757 // Returns -1 in case of error.
1758
1759 R__ASSERT(f!=nullptr);
1760 TString rule(1024);
1761 int c, state = 0;
1762 Int_t count = 0;
1763
1764 while ((c = fgetc(f)) != EOF) {
1765 if (c == 13) // ignore CR
1766 continue;
1767 if (c == '\n') {
1768 if (state != 3) {
1769 state = 0;
1770 if (rule.Length() > 0) {
1771 if (TClass::AddRule(rule)) {
1772 ++count;
1773 }
1774 rule.Clear();
1775 }
1776 }
1777 continue;
1778 }
1779 switch (state) {
1780 case 0: // start of line
1781 switch (c) {
1782 case ' ':
1783 case '\t':
1784 break;
1785 case '#':
1786 state = 1;
1787 break;
1788 default:
1789 state = 2;
1790 break;
1791 }
1792 break;
1793
1794 case 1: // comment
1795 break;
1796
1797 case 2: // rule
1798 switch (c) {
1799 case '\\':
1800 state = 3; // Continuation request
1801 default:
1802 break;
1803 }
1804 break;
1805 }
1806 switch (state) {
1807 case 2:
1808 rule.Append(c);
1809 break;
1810 }
1811 }
1812 return count;
1813 }
1814}
1815
1816////////////////////////////////////////////////////////////////////////////////
1817/// Read the class.rules files from the default location:.
1818/// $ROOTSYS/etc/class.rules (or ROOTETCDIR/class.rules)
1819
1821{
1822 static const char *suffix = "class.rules";
1823 TString sname = suffix;
1825
1826 Int_t res = -1;
1827
1828 FILE * f = fopen(sname,"r");
1829 if (f != nullptr) {
1830 res = ReadRulesContent(f);
1831 fclose(f);
1832 } else {
1833 ::Error("TClass::ReadRules()", "Cannot find rules file %s", sname.Data());
1834 }
1835 return res;
1836}
1837
1838////////////////////////////////////////////////////////////////////////////////
1839/// Read a class.rules file which contains one rule per line with comment
1840/// starting with a #
1841/// - Returns the number of rules loaded.
1842/// - Returns -1 in case of error.
1843
1845{
1846 if (!filename || !filename[0]) {
1847 ::Error("TClass::ReadRules", "no file name specified");
1848 return -1;
1849 }
1850
1851 FILE * f = fopen(filename,"r");
1852 if (f == nullptr) {
1853 ::Error("TClass::ReadRules","Failed to open %s\n",filename);
1854 return -1;
1855 }
1856 Int_t count = ReadRulesContent(f);
1857
1858 fclose(f);
1859 return count;
1860
1861}
1862
1863////////////////////////////////////////////////////////////////////////////////
1864/// Add a schema evolution customization rule.
1865/// The syntax of the rule can be either the short form:
1866/// ~~~ {.cpp}
1867/// [type=Read] classname membername [attributes=... ] [version=[...] ] [checksum=[...] ] [oldtype=...] [code={...}]
1868/// ~~~
1869/// or the long form
1870/// ~~~ {.cpp}
1871/// [type=Read] sourceClass=classname [targetclass=newClassname] [ source="type membername; [type2 membername2]" ]
1872/// [target="membername3;membername4"] [attributes=... ] [version=...] [checksum=...] [code={...}|functionname]
1873/// ~~~
1874///
1875/// For example to set HepMC::GenVertex::m_event to _not_ owned the object it is pointing to:
1876/// HepMC::GenVertex m_event attributes=NotOwner
1877///
1878/// Semantic of the tags:
1879/// - type : the type of the rule, valid values: Read, ReadRaw, Write, WriteRaw, the default is 'Read'.
1880/// - sourceClass : the name of the class as it is on the rule file
1881/// - targetClass : the name of the class as it is in the current code ; defaults to the value of sourceClass
1882/// - source : the types and names of the data members from the class on file that are needed, the list is separated by semi-colons ';'
1883/// - oldtype: in the short form only, indicates the type on disk of the data member.
1884/// - target : the names of the data members updated by this rule, the list is separated by semi-colons ';'
1885/// - attributes : list of possible qualifiers among: Owner, NotOwner
1886/// - version : list of the version of the class layout that this rule applies to. The syntax can be [1,4,5] or [2-] or [1-3] or [-3]
1887/// - checksum : comma delimited list of the checksums of the class layout that this rule applies to.
1888/// - code={...} : code to be executed for the rule or name of the function implementing it.
1889
1890Bool_t TClass::AddRule( const char *rule )
1891{
1892 ROOT::TSchemaRule *ruleobj = new ROOT::TSchemaRule();
1893 if (! ruleobj->SetFromRule( rule ) ) {
1894 delete ruleobj;
1895 return kFALSE;
1896 }
1897
1899
1900 TClass *cl = TClass::GetClass( ruleobj->GetTargetClass() );
1901 if (!cl) {
1902 // Create an empty emulated class for now.
1903 cl = gInterpreter->GenerateTClass(ruleobj->GetTargetClass(), /* emulation = */ kTRUE, /*silent = */ kTRUE);
1904 }
1906
1907 TString errmsg;
1908 if( !rset->AddRule( ruleobj, ROOT::Detail::TSchemaRuleSet::kCheckConflict, &errmsg ) ) {
1909 ::Warning( "TClass::AddRule", "The rule for class: \"%s\": version, \"%s\" and data members: \"%s\" has been skipped because it conflicts with one of the other rules (%s).",
1910 ruleobj->GetTargetClass(), ruleobj->GetVersion(), ruleobj->GetTargetString(), errmsg.Data() );
1911 delete ruleobj;
1912 return kFALSE;
1913 }
1914 return kTRUE;
1915}
1916
1917////////////////////////////////////////////////////////////////////////////////
1918/// Adopt a new set of Data Model Evolution rules.
1919
1921{
1923
1924 delete fSchemaRules;
1925 fSchemaRules = rules;
1926 fSchemaRules->SetClass( this );
1927}
1928
1929////////////////////////////////////////////////////////////////////////////////
1930/// Return the set of the schema rules if any.
1931
1933{
1934 return fSchemaRules;
1935}
1936
1937////////////////////////////////////////////////////////////////////////////////
1938/// Return the set of the schema rules if any.
1939/// If create is true, create an empty set
1940
1942{
1943 if (create && fSchemaRules == nullptr) {
1945 fSchemaRules->SetClass( this );
1946 }
1947 return fSchemaRules;
1948}
1949
1950////////////////////////////////////////////////////////////////////////////////
1951
1952void TClass::AddImplFile(const char* filename, int line) {
1953 // Currently reset the implementation file and line.
1954 // In the close future, it will actually add this file and line
1955 // to a "list" of implementation files.
1956
1959}
1960
1961////////////////////////////////////////////////////////////////////////////////
1962/// Browse external object inherited from TObject.
1963/// It passes through inheritance tree and calls TBrowser::Add
1964/// in appropriate cases. Static function.
1965
1967{
1968 if (!obj) return 0;
1969
1970 TAutoInspector insp(b);
1971 obj->ShowMembers(insp);
1972 return insp.fCount;
1973}
1974
1975////////////////////////////////////////////////////////////////////////////////
1976/// Browse objects of of the class described by this TClass object.
1977
1978Int_t TClass::Browse(void *obj, TBrowser *b) const
1979{
1980 if (!obj) return 0;
1981
1982 TClass *actual = GetActualClass(obj);
1983 if (IsTObject()) {
1984 // Call TObject::Browse.
1985
1986 if (!fIsOffsetStreamerSet) {
1988 }
1989 TObject* realTObject = (TObject*)((size_t)obj + fOffsetStreamer);
1990 realTObject->Browse(b);
1991 return 1;
1992 } else if (actual != this) {
1993 return actual->Browse(obj, b);
1994 } else if (GetCollectionProxy()) {
1995
1996 // do something useful.
1997
1998 } else {
1999 TAutoInspector insp(b);
2000 CallShowMembers(obj,insp,kFALSE);
2001 return insp.fCount;
2002 }
2003
2004 return 0;
2005}
2006
2007////////////////////////////////////////////////////////////////////////////////
2008/// This method is called by a browser to get the class information.
2009
2011{
2012 if (!HasInterpreterInfo()) return;
2013
2014 if (b) {
2015 if (!fRealData) BuildRealData();
2016
2017 b->Add(GetListOfDataMembers(), "Data Members");
2018 b->Add(GetListOfRealData(), "Real Data Members");
2019 b->Add(GetListOfMethods(), "Methods");
2020 b->Add(GetListOfBases(), "Base Classes");
2021 }
2022}
2023
2024////////////////////////////////////////////////////////////////////////////////
2025/// Build a full list of persistent data members.
2026/// Scans the list of all data members in the class itself and also
2027/// in all base classes. For each persistent data member, inserts a
2028/// TRealData object in the list fRealData.
2029///
2030
2031void TClass::BuildRealData(void* pointer, Bool_t isTransient)
2032{
2033
2035
2036 // Only do this once.
2037 if (fRealData) {
2038 return;
2039 }
2040
2041 if (fClassVersion == 0) {
2042 isTransient = kTRUE;
2043 }
2044
2045 // When called via TMapFile (e.g. Update()) make sure that the dictionary
2046 // gets allocated on the heap and not in the mapped file.
2047 TMmallocDescTemp setreset;
2048
2049 // Handle emulated classes and STL containers specially.
2051 // We are an emulated class or an STL container.
2052 fRealData = new TList;
2053 BuildEmulatedRealData("", 0, this, isTransient);
2054 return;
2055 }
2056
2057 // return early on string
2058 static TClassRef clRefString("std::string");
2059 if (clRefString == this) {
2060 return;
2061 }
2062
2063 // Complain about stl classes ending up here (unique_ptr etc) - except for
2064 // pair where we will build .first, .second just fine
2065 // and those for which the user explicitly requested a dictionary.
2066 if (!isTransient && GetState() != kHasTClassInit
2069 Error("BuildRealData", "Inspection for %s not supported!", GetName());
2070 }
2071
2072 // The following statement will recursively call
2073 // all the subclasses of this class.
2074 fRealData = new TList;
2075 TBuildRealData brd(pointer, this);
2076
2077 // CallShowMember will force a call to InheritsFrom, which indirectly
2078 // calls TClass::GetClass. It forces the loading of new typedefs in
2079 // case some of them were not yet loaded.
2080 if ( ! CallShowMembers(pointer, brd, isTransient) ) {
2081 if ( isTransient ) {
2082 // This is a transient data member, so it is probably fine to not have
2083 // access to its content. However let's no mark it as definitively setup,
2084 // since another class might use this class for a persistent data member and
2085 // in this case we really want the error message.
2086 delete fRealData;
2087 fRealData = nullptr;
2088 } else {
2089 Error("BuildRealData", "Cannot find any ShowMembers function for %s!", GetName());
2090 }
2091 }
2092
2093 // Take this opportunity to build the real data for base classes.
2094 // In case one base class is abstract, it would not be possible later
2095 // to create the list of real data for this abstract class.
2096 TBaseClass* base = nullptr;
2097 TIter next(GetListOfBases());
2098 while ((base = (TBaseClass*) next())) {
2099 if (base->IsSTLContainer()) {
2100 continue;
2101 }
2102 TClass* c = base->GetClassPointer();
2103 if (c) {
2104 c->BuildRealData(nullptr, isTransient);
2105 }
2106 }
2107}
2108
2109////////////////////////////////////////////////////////////////////////////////
2110/// Build the list of real data for an emulated class
2111
2113{
2115
2117 if (Property() & kIsAbstract) {
2119 } else {
2120 info = GetStreamerInfoImpl(fClassVersion, isTransient);
2121 }
2122 if (!info) {
2123 // This class is abstract, but we don't yet have a SteamerInfo for it ...
2124 Error("BuildEmulatedRealData","Missing StreamerInfo for %s",GetName());
2125 // Humm .. no information ... let's bail out
2126 return;
2127 }
2128
2129 TIter next(info->GetElements());
2130 TStreamerElement *element;
2131 while ((element = (TStreamerElement*)next())) {
2132 Int_t etype = element->GetType();
2133 Longptr_t eoffset = element->GetOffset();
2134 TClass *cle = element->GetClassPointer();
2135 if (element->IsBase() || etype == TVirtualStreamerInfo::kBase) {
2136 //base class are skipped in this loop, they will be added at the end.
2137 continue;
2138 } else if (etype == TVirtualStreamerInfo::kTObject ||
2141 etype == TVirtualStreamerInfo::kAny) {
2142 //member class
2143 TString rdname; rdname.Form("%s%s",name,element->GetFullName());
2144 TRealData *rd = new TRealData(rdname,offset+eoffset,nullptr);
2145 if (gDebug > 0) printf(" Class: %s, adding TRealData=%s, offset=%ld\n",cl->GetName(),rd->GetName(),rd->GetThisOffset());
2146 cl->GetListOfRealData()->Add(rd);
2147 // Now we a dot
2148 rdname.Form("%s%s.",name,element->GetFullName());
2149 if (cle) cle->BuildEmulatedRealData(rdname,offset+eoffset,cl, isTransient);
2150 } else {
2151 //others
2152 TString rdname; rdname.Form("%s%s",name,element->GetFullName());
2153 TRealData *rd = new TRealData(rdname,offset+eoffset,nullptr);
2154 if (gDebug > 0) printf(" Class: %s, adding TRealData=%s, offset=%ld\n",cl->GetName(),rd->GetName(),rd->GetThisOffset());
2155 cl->GetListOfRealData()->Add(rd);
2156 }
2157 //if (fClassInfo==0 && element->IsBase()) {
2158 // if (fBase==0) fBase = new TList;
2159 // TClass *base = element->GetClassPointer();
2160 // fBase->Add(new TBaseClass(this, cl, eoffset));
2161 //}
2162 }
2163 // The base classes must added last on the list of real data (to help with ambiguous data member names)
2164 next.Reset();
2165 while ((element = (TStreamerElement*)next())) {
2166 Int_t etype = element->GetType();
2167 if (element->IsBase() || etype == TVirtualStreamerInfo::kBase) {
2168 //base class
2169 Longptr_t eoffset = element->GetOffset();
2170 TClass *cle = element->GetClassPointer();
2171 if (cle) cle->BuildEmulatedRealData(name,offset+eoffset,cl, isTransient);
2172 }
2173 }
2174}
2175
2176
2177////////////////////////////////////////////////////////////////////////////////
2178/// Calculate the offset between an object of this class to
2179/// its base class TObject. The pointer can be adjusted by
2180/// that offset to access any virtual method of TObject like
2181/// Streamer() and ShowMembers().
2182
2184{
2187 // When called via TMapFile (e.g. Update()) make sure that the dictionary
2188 // gets allocated on the heap and not in the mapped file.
2189
2190 TMmallocDescTemp setreset;
2192 if (fStreamerType == kTObject) {
2194 }
2196 }
2197}
2198
2199
2200////////////////////////////////////////////////////////////////////////////////
2201/// Call ShowMembers() on the obj of this class type, passing insp and parent.
2202/// isATObject is -1 if unknown, 0 if it is not a TObject, and 1 if it is a TObject.
2203/// The function returns whether it was able to call ShowMembers().
2204
2205Bool_t TClass::CallShowMembers(const void* obj, TMemberInspector &insp, Bool_t isTransient) const
2206{
2207 if (fShowMembers) {
2208 // This should always works since 'pointer' should be pointing
2209 // to an object of the actual type of this TClass object.
2210 fShowMembers(obj, insp, isTransient);
2211 return kTRUE;
2212 } else {
2213
2215 if (fClassInfo) {
2216
2217 if (strcmp(GetName(), "string") == 0) {
2218 // For std::string we know that we do not have a ShowMembers
2219 // function and that it's okay.
2220 return kTRUE;
2221 }
2222 // Since we do have some dictionary information, let's
2223 // call the interpreter's ShowMember.
2224 // This works with Cling to support interpreted classes.
2225 gInterpreter->InspectMembers(insp, obj, this, isTransient);
2226 return kTRUE;
2227
2228 } else if (TVirtualStreamerInfo* sinfo = GetStreamerInfo()) {
2229 sinfo->CallShowMembers(obj, insp, isTransient);
2230 return kTRUE;
2231 } // isATObject
2232 } // fShowMembers is set
2233
2234 return kFALSE;
2235}
2236
2237////////////////////////////////////////////////////////////////////////////////
2238/// Do a ShowMembers() traversal of all members and base classes' members
2239/// using the reflection information from the interpreter. Works also for
2240/// interpreted objects.
2241
2242void TClass::InterpretedShowMembers(void* obj, TMemberInspector &insp, Bool_t isTransient)
2243{
2244 return gInterpreter->InspectMembers(insp, obj, this, isTransient);
2245}
2246
2248{
2249 if (fCanSplit >= 0) {
2250 return ! ( fCanSplit & 0x2 );
2251 }
2252
2254
2255 if (GetCollectionProxy() != nullptr) {
2256 // A collection can never affect its derived class 'splittability'
2257 return kTRUE;
2258 }
2259
2260 if (this == TRef::Class()) { fCanSplit = 2; return kFALSE; }
2261 if (this == TRefArray::Class()) { fCanSplit = 2; return kFALSE; }
2262 if (this == TArray::Class()) { fCanSplit = 2; return kFALSE; }
2263 if (this == TClonesArray::Class()) { fCanSplit = 1; return kTRUE; }
2264 if (this == TCollection::Class()) { fCanSplit = 2; return kFALSE; }
2265
2266 // TTree is not always available (for example in rootcling), so we need
2267 // to grab it silently.
2268 auto refTreeClass( TClass::GetClass("TTree",kTRUE,kTRUE) );
2269 if (this == refTreeClass) { fCanSplit = 2; return kFALSE; }
2270
2271 if (!HasDataMemberInfo()) {
2272 TVirtualStreamerInfo *sinfo = ((TClass *)this)->GetCurrentStreamerInfo();
2273 if (sinfo==nullptr) sinfo = GetStreamerInfo();
2274 TIter next(sinfo->GetElements());
2275 TStreamerElement *element;
2276 while ((element = (TStreamerElement*)next())) {
2277 if (element->IsA() == TStreamerBase::Class()) {
2278 TClass *clbase = element->GetClassPointer();
2279 if (!clbase) {
2280 // If there is a missing base class, we can't split the immediate
2281 // derived class.
2282 fCanSplit = 0;
2283 return kFALSE;
2284 } else if (!clbase->CanSplitBaseAllow()) {
2285 fCanSplit = 2;
2286 return kFALSE;
2287 }
2288 }
2289 }
2290 }
2291
2292 // If we don't have data member info there is no more information
2293 // we can find out.
2294 if (!HasDataMemberInfo()) return kTRUE;
2295
2296 TObjLink *lnk = GetListOfBases() ? fBase.load()->FirstLink() : nullptr;
2297
2298 // Look at inheritance tree
2299 while (lnk) {
2300 TBaseClass *base = (TBaseClass*) lnk->GetObject();
2301 TClass *c = base->GetClassPointer();
2302 if(!c) {
2303 // If there is a missing base class, we can't split the immediate
2304 // derived class.
2305 fCanSplit = 0;
2306 return kFALSE;
2307 } else if (!c->CanSplitBaseAllow()) {
2308 fCanSplit = 2;
2309 return kFALSE;
2310 }
2311 lnk = lnk->Next();
2312 }
2313 return kTRUE;
2314}
2315
2316////////////////////////////////////////////////////////////////////////////////
2317/// Return true if the data member of this TClass can be saved separately.
2318
2320{
2321 // Note: add the possibility to set it for the class and the derived class.
2322 // save the info in TVirtualStreamerInfo
2323 // deal with the info in MakeProject
2324 if (fCanSplit >= 0) {
2325 // The user explicitly set the value
2326 return (fCanSplit & 0x1) == 1;
2327 }
2328
2330 TClass *This = const_cast<TClass*>(this);
2331
2332 if (this == TObject::Class()) { This->fCanSplit = 1; return kTRUE; }
2333 if (fName == "TClonesArray") { This->fCanSplit = 1; return kTRUE; }
2334 if (fRefProxy) { This->fCanSplit = 0; return kFALSE; }
2335 if (fName.BeginsWith("TVectorT<")) { This->fCanSplit = 0; return kFALSE; }
2336 if (fName.BeginsWith("TMatrixT<")) { This->fCanSplit = 0; return kFALSE; }
2337 if (fName == "string") { This->fCanSplit = 0; return kFALSE; }
2338 if (fName == "std::string") { This->fCanSplit = 0; return kFALSE; }
2339
2340 if (GetCollectionProxy()!=nullptr) {
2341 // For STL collection we need to look inside.
2342
2343 // However we do not split collections of collections
2344 // nor collections of strings
2345 // nor collections of pointers (unless explicit request (see TBranchSTL)).
2346
2347 if (GetCollectionProxy()->HasPointers()) { This->fCanSplit = 0; return kFALSE; }
2348
2349 TClass *valueClass = GetCollectionProxy()->GetValueClass();
2350 if (valueClass == nullptr) { This->fCanSplit = 0; return kFALSE; }
2351 static TClassRef stdStringClass("std::string");
2352 if (valueClass==TString::Class() || valueClass==stdStringClass)
2353 { This->fCanSplit = 0; return kFALSE; }
2354 if (!valueClass->CanSplit()) { This->fCanSplit = 0; return kFALSE; }
2355 if (valueClass->GetCollectionProxy() != nullptr) { This->fCanSplit = 0; return kFALSE; }
2356
2357 This->fCanSplit = 1;
2358 return kTRUE;
2359
2360 }
2361
2362 if (GetStreamer() != nullptr || fStreamerFunc != nullptr) {
2363
2364 // We have an external custom streamer provided by the user, we must not
2365 // split it.
2366 This->fCanSplit = 0;
2367 return kFALSE;
2368
2369 } else if ( fHasCustomStreamerMember ) {
2370
2371 // We have a custom member function streamer or
2372 // an older (not StreamerInfo based) automatic streamer.
2373 This->fCanSplit = 0;
2374 return kFALSE;
2375 }
2376
2377 if (Size()==1) {
2378 // 'Empty' class there is nothing to split!.
2379 This->fCanSplit = 0;
2380 return kFALSE;
2381 }
2382
2383
2384 if ( !This->CanSplitBaseAllow() ) {
2385 return kFALSE;
2386 }
2387
2388 This->fCanSplit = 1;
2389 return kTRUE;
2390}
2391
2392////////////////////////////////////////////////////////////////////////////////
2393/// Return the C++ property of this class, eg. is abstract, has virtual base
2394/// class, see EClassProperty in TDictionary.h
2395
2397{
2398 if (fProperty == -1) Property();
2399 return fClassProperty;
2400}
2401
2402////////////////////////////////////////////////////////////////////////////////
2403/// Create a Clone of this TClass object using a different name but using the same 'dictionary'.
2404/// This effectively creates a hard alias for the class name.
2405
2406TObject *TClass::Clone(const char *new_name) const
2407{
2408 if (new_name == nullptr || new_name[0]=='\0' || fName == new_name) {
2409 Error("Clone","The name of the class must be changed when cloning a TClass object.");
2410 return nullptr;
2411 }
2412
2413 // Need to lock access to TROOT::GetListOfClasses so the cloning happens atomically
2415 // Temporarily remove the original from the list of classes.
2416 TClass::RemoveClass(const_cast<TClass*>(this));
2417
2418 TClass *copy;
2419 if (fTypeInfo) {
2420 copy = new TClass(GetName(),
2422 *fTypeInfo,
2423 new TIsAProxy(*fTypeInfo),
2427 GetImplFileLine());
2428 } else {
2429 copy = new TClass(GetName(),
2434 GetImplFileLine());
2435 }
2436 copy->fShowMembers = fShowMembers;
2437 // Remove the copy before renaming it
2438 TClass::RemoveClass(copy);
2439 copy->fName = new_name;
2440 TClass::AddClass(copy);
2441
2442 copy->SetNew(fNew);
2443 copy->SetNewArray(fNewArray);
2444 copy->SetDelete(fDelete);
2450 if (fStreamer) {
2452 }
2453 // If IsZombie is true, something went wrong and we will not be
2454 // able to properly copy the collection proxy
2455 if (fCollectionProxy && !copy->IsZombie()) {
2457 }
2458 copy->SetClassSize(fSizeof);
2459 if (fRefProxy) {
2461 }
2462 TClass::AddClass(const_cast<TClass*>(this));
2463 return copy;
2464}
2465
2466////////////////////////////////////////////////////////////////////////////////
2467/// Replaces the collection proxy for this class. The provided object is cloned
2468/// and the copy is then owned by `TClass`.
2469
2471{
2472// // This code was used too quickly test the STL Emulation layer
2473// Int_t k = TClassEdit::IsSTLCont(GetName());
2474// if (k==1||k==-1) return;
2475
2476 delete fCollectionProxy;
2477 fCollectionProxy = orig.Generate();
2478}
2479
2480////////////////////////////////////////////////////////////////////////////////
2481/// Draw detailed class inheritance structure.
2482/// If a class B inherits from a class A, the description of B is drawn
2483/// on the right side of the description of A.
2484/// Member functions overridden by B are shown in class A with a blue line
2485/// erasing the corresponding member function
2486
2488{
2489 if (!HasInterpreterInfo()) return;
2490
2492
2493 // Should we create a new canvas?
2494 TString opt = option;
2495 if (!ctxt.GetSaved() || !opt.Contains("same")) {
2496 TVirtualPad *padclass = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("R__class");
2497 if (!padclass) {
2498 gROOT->ProcessLine("new TCanvas(\"R__class\",\"class\",20,20,1000,750);");
2499 } else {
2500 padclass->cd();
2501 }
2502 }
2503
2504 if (gPad)
2506}
2507
2508////////////////////////////////////////////////////////////////////////////////
2509/// Dump contents of object on stdout.
2510/// Using the information in the object dictionary
2511/// each data member is interpreted.
2512/// If a data member is a pointer, the pointer value is printed
2513/// 'obj' is assume to point to an object of the class describe by this TClass
2514///
2515/// The following output is the Dump of a TArrow object:
2516/// ~~~ {.cpp}
2517/// fAngle 0 Arrow opening angle (degrees)
2518/// fArrowSize 0.2 Arrow Size
2519/// fOption.*fData
2520/// fX1 0.1 X of 1st point
2521/// fY1 0.15 Y of 1st point
2522/// fX2 0.67 X of 2nd point
2523/// fY2 0.83 Y of 2nd point
2524/// fUniqueID 0 object unique identifier
2525/// fBits 50331648 bit field status word
2526/// fLineColor 1 line color
2527/// fLineStyle 1 line style
2528/// fLineWidth 1 line width
2529/// fFillColor 19 fill area color
2530/// fFillStyle 1001 fill area style
2531/// ~~~
2532///
2533/// If noAddr is true, printout of all pointer values is skipped.
2534
2535void TClass::Dump(const void *obj, Bool_t noAddr /*=kFALSE*/) const
2536{
2537
2538 Longptr_t prObj = noAddr ? 0 : (Longptr_t)obj;
2539 if (IsTObject()) {
2540 if (!fIsOffsetStreamerSet) {
2542 }
2543 TObject *tobj = (TObject*)((Longptr_t)obj + fOffsetStreamer);
2544
2545
2546 if (sizeof(this) == 4)
2547 Printf("==> Dumping object at: 0x%08lx, name=%s, class=%s\n",prObj,tobj->GetName(),GetName());
2548 else
2549 Printf("==> Dumping object at: 0x%016lx, name=%s, class=%s\n",prObj,tobj->GetName(),GetName());
2550 } else {
2551
2552 if (sizeof(this) == 4)
2553 Printf("==> Dumping object at: 0x%08lx, class=%s\n",prObj,GetName());
2554 else
2555 Printf("==> Dumping object at: 0x%016lx, class=%s\n",prObj,GetName());
2556 }
2557
2558 TDumpMembers dm(noAddr);
2559 if (!CallShowMembers(obj, dm, kFALSE)) {
2560 Info("Dump", "No ShowMembers function, dumping disabled");
2561 }
2562}
2563
2564////////////////////////////////////////////////////////////////////////////////
2565/// Introduce an escape character (@) in front of a special chars.
2566/// You need to use the result immediately before it is being overwritten.
2567
2568char *TClass::EscapeChars(const char *text) const
2569{
2570 static const UInt_t maxsize = 255;
2571 static char name[maxsize+2]; //One extra if last char needs to be escaped
2572
2573 UInt_t nch = text ? strlen(text) : 0;
2574 UInt_t icur = 0;
2575 for (UInt_t i = 0; i < nch && icur < maxsize; ++i, ++icur) {
2576 if (text[i] == '\"' || text[i] == '[' || text[i] == '~' ||
2577 text[i] == ']' || text[i] == '&' || text[i] == '#' ||
2578 text[i] == '!' || text[i] == '^' || text[i] == '<' ||
2579 text[i] == '?' || text[i] == '>') {
2580 name[icur] = '@';
2581 ++icur;
2582 }
2583 name[icur] = text[i];
2584 }
2585 name[icur] = 0;
2586 return name;
2587}
2588
2589////////////////////////////////////////////////////////////////////////////////
2590/// Return a pointer to the real class of the object.
2591/// This is equivalent to object->IsA() when the class has a ClassDef.
2592/// It is REQUIRED that object is coming from a proper pointer to the
2593/// class represented by 'this'.
2594/// Example: Special case:
2595/// ~~~ {.cpp}
2596/// class MyClass : public AnotherClass, public TObject
2597/// ~~~
2598/// then on return, one must do:
2599/// ~~~ {.cpp}
2600/// TObject *obj = (TObject*)((void*)myobject)directory->Get("some object of MyClass");
2601/// MyClass::Class()->GetActualClass(obj); // this would be wrong!!!
2602/// ~~~
2603/// Also if the class represented by 'this' and NONE of its parents classes
2604/// have a virtual ptr table, the result will be 'this' and NOT the actual
2605/// class.
2606
2607TClass *TClass::GetActualClass(const void *object) const
2608{
2609 if (!object)
2610 return (TClass*)this;
2611 if (fIsA) {
2612 return (*fIsA)(object); // ROOT::IsA((ThisClass*)object);
2613 } else if (fGlobalIsA) {
2614 return fGlobalIsA(this,object);
2615 } else {
2616 if (IsTObject()) {
2617
2618 if (!fIsOffsetStreamerSet) {
2620 }
2621 TObject* realTObject = (TObject*)((size_t)object + fOffsetStreamer);
2622
2623 return realTObject->IsA();
2624 }
2625
2626 if (HasInterpreterInfo()) {
2627
2628 TVirtualIsAProxy *isa = nullptr;
2630 isa = (TVirtualIsAProxy*)gROOT->ProcessLineFast(TString::Format("new ::TInstrumentedIsAProxy<%s>(0);",GetName()));
2631 }
2632 else {
2633 isa = (TVirtualIsAProxy*)gROOT->ProcessLineFast(TString::Format("new ::TIsAProxy(typeid(%s));",GetName()));
2634 }
2635 if (isa) {
2637 const_cast<TClass*>(this)->fIsA = isa;
2638 }
2639 if (fIsA) {
2640 return (*fIsA)(object); // ROOT::IsA((ThisClass*)object);
2641 }
2642 }
2644 if (sinfo) {
2645 return sinfo->GetActualClass(object);
2646 }
2647 return (TClass*)this;
2648 }
2649}
2650
2651////////////////////////////////////////////////////////////////////////////////
2652/// Return pointer to the base class "classname". Returns 0 in case
2653/// "classname" is not a base class. Takes care of multiple inheritance.
2654
2655TClass *TClass::GetBaseClass(const char *classname)
2656{
2657 // check if class name itself is equal to classname
2658 if (strcmp(GetName(), classname) == 0) return this;
2659
2660 if (!HasDataMemberInfo()) return nullptr;
2661
2662 // Make sure we deal with possible aliases, we could also have normalized
2663 // the name.
2664 TClass *search = TClass::GetClass(classname,kTRUE,kTRUE);
2665
2666 if (search) return GetBaseClass(search);
2667 else return nullptr;
2668}
2669
2670////////////////////////////////////////////////////////////////////////////////
2671/// Return pointer to the base class "cl". Returns 0 in case "cl"
2672/// is not a base class. Takes care of multiple inheritance.
2673
2675{
2676 // check if class name itself is equal to classname
2677 if (cl == this) return this;
2678
2679 if (!HasDataMemberInfo()) return nullptr;
2680
2681 TObjLink *lnk = GetListOfBases() ? fBase.load()->FirstLink() : nullptr;
2682
2683 // otherwise look at inheritance tree
2684 while (lnk) {
2685 TClass *c, *c1;
2686 TBaseClass *base = (TBaseClass*) lnk->GetObject();
2687 c = base->GetClassPointer();
2688 if (c) {
2689 if (cl == c) return c;
2690 c1 = c->GetBaseClass(cl);
2691 if (c1) return c1;
2692 }
2693 lnk = lnk->Next();
2694 }
2695 return nullptr;
2696}
2697
2698////////////////////////////////////////////////////////////////////////////////
2699/// Return data member offset to the base class "cl".
2700/// - Returns -1 in case "cl" is not a base class.
2701/// - Returns -2 if cl is a base class, but we can't find the offset
2702/// because it's virtual.
2703/// Takes care of multiple inheritance.
2704
2706{
2707 // check if class name itself is equal to classname
2708 if (cl == this) return 0;
2709
2710 if (!fBase.load()) {
2712 // If the information was not provided by the root pcm files and
2713 // if we can not find the ClassInfo, we have to fall back to the
2714 // StreamerInfo
2715 if (!fClassInfo) {
2717 if (!sinfo) return -1;
2718 TStreamerElement *element;
2719 Int_t offset = 0;
2720
2721 TObjArray &elems = *(sinfo->GetElements());
2722 Int_t size = elems.GetLast()+1;
2723 for(Int_t i=0; i<size; i++) {
2724 element = (TStreamerElement*)elems[i];
2725 if (element->IsBase()) {
2726 if (element->IsA() == TStreamerBase::Class()) {
2727 TStreamerBase *base = (TStreamerBase*)element;
2728 TClass *baseclass = base->GetClassPointer();
2729 if (!baseclass) return -1;
2730 Int_t subOffset = baseclass->GetBaseClassOffsetRecurse(cl);
2731 if (subOffset == -2) return -2;
2732 if (subOffset != -1) return offset+subOffset;
2733 offset += baseclass->Size();
2734 } else if (element->IsA() == TStreamerSTL::Class()) {
2735 TStreamerSTL *base = (TStreamerSTL*)element;
2736 TClass *baseclass = base->GetClassPointer();
2737 if (!baseclass) return -1;
2738 Int_t subOffset = baseclass->GetBaseClassOffsetRecurse(cl);
2739 if (subOffset == -2) return -2;
2740 if (subOffset != -1) return offset+subOffset;
2741 offset += baseclass->Size();
2742
2743 } else {
2744 Error("GetBaseClassOffsetRecurse","Unexpected element type for base class: %s\n",element->IsA()->GetName());
2745 }
2746 }
2747 }
2748 return -1;
2749 }
2750 }
2751
2752 TClass *c;
2753 Int_t off;
2754 TBaseClass *inh;
2755 TObjLink *lnk = nullptr;
2756 if (fBase.load() == nullptr)
2757 lnk = GetListOfBases()->FirstLink();
2758 else
2759 lnk = fBase.load()->FirstLink();
2760
2761 // otherwise look at inheritance tree
2762 while (lnk) {
2763 inh = (TBaseClass *)lnk->GetObject();
2764 //use option load=kFALSE to avoid a warning like:
2765 //"Warning in <TClass::TClass>: no dictionary for class TRefCnt is available"
2766 //We can not afford to not have the class if it exist, so we
2767 //use kTRUE.
2768 c = inh->GetClassPointer(kTRUE); // kFALSE);
2769 if (c) {
2770 if (cl == c) {
2771 if ((inh->Property() & kIsVirtualBase) != 0)
2772 return -2;
2773 return inh->GetDelta();
2774 }
2775 off = c->GetBaseClassOffsetRecurse(cl);
2776 if (off == -2) return -2;
2777 if (off != -1) {
2778 return off + inh->GetDelta();
2779 }
2780 }
2781 lnk = lnk->Next();
2782 }
2783 return -1;
2784}
2785
2786////////////////////////////////////////////////////////////////////////////////
2787/// - Return data member offset to the base class "cl".
2788/// - Returns -1 in case "cl" is not a base class.
2789/// Takes care of multiple inheritance.
2790
2791Int_t TClass::GetBaseClassOffset(const TClass *toBase, void *address, bool isDerivedObject)
2792{
2793 // Warning("GetBaseClassOffset","Requires the use of fClassInfo for %s to %s",GetName(),toBase->GetName());
2794
2795 if (this == toBase) return 0;
2796
2797 if ((!address /* || !has_virtual_base */) &&
2799 // At least of the ClassInfo have not been loaded in memory yet and
2800 // since there is no virtual base class (or we don't have enough so it
2801 // would not make a difference) we can use the 'static' information
2803 if (offset != -2) {
2804 return offset;
2805 }
2806 return offset;
2807 }
2808
2809 ClassInfo_t* derived = GetClassInfo();
2810 ClassInfo_t* base = toBase->GetClassInfo();
2811 if(derived && base) {
2812 // TClingClassInfo::GetBaseOffset takes the lock.
2813 return gCling->ClassInfo_GetBaseOffset(derived, base, address, isDerivedObject);
2814 }
2815 else {
2817 if (offset != -2) {
2818 return offset;
2819 }
2820 }
2821 return -1;
2822}
2823
2824////////////////////////////////////////////////////////////////////////////////
2825/// Return pointer to (base) class that contains datamember.
2826
2827TClass *TClass::GetBaseDataMember(const char *datamember)
2828{
2829 if (!HasDataMemberInfo()) return nullptr;
2830
2831 // Check if data member exists in class itself
2832 TDataMember *dm = GetDataMember(datamember);
2833 if (dm) return this;
2834
2835 // if datamember not found in class, search in next base classes
2836 TBaseClass *inh;
2837 TIter next(GetListOfBases());
2838 while ((inh = (TBaseClass *) next())) {
2839 TClass *c = inh->GetClassPointer();
2840 if (c) {
2841 TClass *cdm = c->GetBaseDataMember(datamember);
2842 if (cdm) return cdm;
2843 }
2844 }
2845
2846 return nullptr;
2847}
2848
2849namespace {
2850 // A local Helper class used to keep 2 pointer (the collection proxy
2851 // and the class streamer) in the thread local storage.
2852
2853 struct TClassLocalStorage {
2854 TClassLocalStorage() : fCollectionProxy(nullptr), fStreamer(nullptr) {};
2855
2856 TVirtualCollectionProxy *fCollectionProxy;
2857 TClassStreamer *fStreamer;
2858
2859 static TClassLocalStorage *GetStorage(const TClass *cl)
2860 {
2861 // Return the thread storage for the TClass.
2862
2863 void **thread_ptr = (*gThreadTsd)(nullptr,ROOT::kClassThreadSlot);
2864 if (thread_ptr) {
2865 if (*thread_ptr==nullptr) *thread_ptr = new TExMap();
2866 TExMap *lmap = (TExMap*)(*thread_ptr);
2867 ULong_t hash = TString::Hash(&cl, sizeof(void*));
2868 ULongptr_t local = 0;
2869 UInt_t slot;
2870 if ((local = (ULongptr_t)lmap->GetValue(hash, (Longptr_t)cl, slot)) != 0) {
2871 } else {
2872 local = (ULongptr_t) new TClassLocalStorage();
2873 lmap->AddAt(slot, hash, (Longptr_t)cl, local);
2874 }
2875 return (TClassLocalStorage*)local;
2876 }
2877 return nullptr;
2878 }
2879 };
2880}
2881
2882////////////////////////////////////////////////////////////////////////////////
2883/// Return the 'type' of the STL the TClass is representing.
2884/// and return ROOT::kNotSTL if it is not representing an STL collection.
2885
2887{
2888 auto proxy = GetCollectionProxy();
2889 if (proxy) return (ROOT::ESTLType)proxy->GetCollectionType();
2890 return ROOT::kNotSTL;
2891}
2892
2893
2894////////////////////////////////////////////////////////////////////////////////
2895/// Return the proxy describing the collection (if any).
2896
2898{
2899 // Use assert, so that this line (slow because of the TClassEdit) is completely
2900 // removed in optimized code.
2901 //assert(TestBit(kLoading) || !TClassEdit::IsSTLCont(fName) || fCollectionProxy || 0 == "The TClass for the STL collection has no collection proxy!");
2903 TClassLocalStorage *local = TClassLocalStorage::GetStorage(this);
2904 if (local == nullptr) return fCollectionProxy;
2905 if (local->fCollectionProxy==nullptr) local->fCollectionProxy = fCollectionProxy->Generate();
2906 return local->fCollectionProxy;
2907 }
2908 return fCollectionProxy;
2909}
2910
2911////////////////////////////////////////////////////////////////////////////////
2912/// Return the Streamer Class allowing streaming (if any).
2913
2915{
2916 if (gThreadTsd && fStreamer) {
2917 TClassLocalStorage *local = TClassLocalStorage::GetStorage(this);
2918 if (local==nullptr) return fStreamer;
2919 if (local->fStreamer==nullptr) {
2920 local->fStreamer = fStreamer->Generate();
2921 const std::type_info &orig = ( typeid(*fStreamer) );
2922 if (!local->fStreamer) {
2923 Warning("GetStreamer","For %s, the TClassStreamer (%s) passed's call to Generate failed!",GetName(),orig.name());
2924 } else {
2925 const std::type_info &copy = ( typeid(*local->fStreamer) );
2926 if (strcmp(orig.name(),copy.name())!=0) {
2927 Warning("GetStreamer","For %s, the TClassStreamer passed does not properly implement the Generate method (%s vs %s)\n",GetName(),orig.name(),copy.name());
2928 }
2929 }
2930 }
2931 return local->fStreamer;
2932 }
2933 return fStreamer;
2934}
2935
2936////////////////////////////////////////////////////////////////////////////////
2937/// Get a wrapper/accessor function around this class custom streamer (member function).
2938
2940{
2941 return fStreamerFunc;
2942}
2943
2944////////////////////////////////////////////////////////////////////////////////
2945/// Get a wrapper/accessor function around this class custom conversion streamer (member function).
2946
2948{
2949 return fConvStreamerFunc;
2950}
2951
2952////////////////////////////////////////////////////////////////////////////////
2953/// Return the proxy implementing the IsA functionality.
2954
2956{
2957 return fIsA;
2958}
2959
2960////////////////////////////////////////////////////////////////////////////////
2961/// Static method returning pointer to TClass of the specified class name.
2962/// If load is true an attempt is made to obtain the class by loading
2963/// the appropriate shared library (directed by the rootmap file).
2964/// If silent is 'true', do not warn about missing dictionary for the class.
2965/// (typically used for class that are used only for transient members)
2966/// Returns 0 in case class is not found.
2967
2968TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent)
2969{
2970 return TClass::GetClass(name, load, silent, 0, 0);
2971}
2972
2973TClass *TClass::GetClass(const char *name, Bool_t load, Bool_t silent, size_t hint_pair_offset, size_t hint_pair_size)
2974{
2975 if (!name || !name[0]) return nullptr;
2976
2977 if (strstr(name, "(anonymous)")) return nullptr;
2978 if (strstr(name, "(unnamed)")) return nullptr;
2979 if (strncmp(name,"class ",6)==0) name += 6;
2980 if (strncmp(name,"struct ",7)==0) name += 7;
2981
2982 if (!gROOT->GetListOfClasses()) return nullptr;
2983
2984 // FindObject will take the read lock before actually getting the
2985 // TClass pointer so we will need not get a partially initialized
2986 // object.
2987 TClass *cl = (TClass*)gROOT->GetListOfClasses()->FindObject(name);
2988
2989 // Early return to release the lock without having to execute the
2990 // long-ish normalization.
2991 if (cl && (cl->IsLoaded() || cl->TestBit(kUnloading))) return cl;
2992
2994
2995 // Now that we got the write lock, another thread may have constructed the
2996 // TClass while we were waiting, so we need to do the checks again.
2997
2998 cl = (TClass*)gROOT->GetListOfClasses()->FindObject(name);
2999 if (cl) {
3000 if (cl->IsLoaded() || cl->TestBit(kUnloading)) return cl;
3001
3002 // We could speed-up some of the search by adding (the equivalent of)
3003 //
3004 // if (cl->GetState() == kInterpreter) return cl
3005 //
3006 // In this case, if a ROOT dictionary was available when the TClass
3007 // was first requested it would have been used and if a ROOT dictionary is
3008 // loaded later on TClassTable::Add will take care of updating the TClass.
3009 // So as far as ROOT dictionary are concerned, if the current TClass is
3010 // in interpreted state, we are sure there is nothing to load.
3011 //
3012 // However (see TROOT::LoadClass), the TClass can also be loaded/provided
3013 // by a user provided TClassGenerator. We have no way of knowing whether
3014 // those do (or even can) behave the same way as the ROOT dictionary and
3015 // have the 'dictionary is now available for use' step informs the existing
3016 // TClass that their dictionary is now available.
3017
3018 //we may pass here in case of a dummy class created by TVirtualStreamerInfo
3019 load = kTRUE;
3020 }
3021
3023 // If there is a @ symbol (followed by a version number) then this is a synthetic class name created
3024 // from an already normalized name for the purpose of supporting schema evolution.
3025 // There is no dictionary or interpreter information about this kind of class, the only
3026 // (undesirable) side-effect of doing the search would be a waste of CPU time and potential
3027 // auto-loading or auto-parsing based on the scope of the name.
3028 return cl;
3029 }
3030
3031 // To avoid spurious auto parsing, let's check if the name as-is is
3032 // known in the TClassTable.
3034 if (dict) {
3035 // The name is normalized, so the result of the first search is
3036 // authoritative.
3037 if (!cl && !load) return nullptr;
3038
3039 TClass *loadedcl = (dict)();
3040 if (loadedcl) {
3041 loadedcl->PostLoadCheck();
3042 return loadedcl;
3043 }
3044
3045 // We should really not fall through to here, but if we do, let's just
3046 // continue as before ...
3047 }
3048
3049 std::string normalizedName;
3050 Bool_t checkTable = kFALSE;
3051
3052 if (!cl) {
3053 {
3055 TClassEdit::GetNormalizedName(normalizedName, name);
3056 }
3057 // Try the normalized name.
3058 if (normalizedName != name) {
3059 cl = (TClass*)gROOT->GetListOfClasses()->FindObject(normalizedName.c_str());
3060
3061 if (cl) {
3062 if (cl->IsLoaded() || cl->TestBit(kUnloading)) return cl;
3063
3064 //we may pass here in case of a dummy class created by TVirtualStreamerInfo
3065 load = kTRUE;
3066 }
3067 checkTable = kTRUE;
3068 }
3069 } else {
3070 normalizedName = cl->GetName(); // Use the fact that all TClass names are normalized.
3071 checkTable = load && (normalizedName != name);
3072 }
3073
3074 if (!load) return nullptr;
3075
3076// This assertion currently fails because of
3077// TClass *c1 = TClass::GetClass("basic_iostream<char,char_traits<char> >");
3078// TClass *c2 = TClass::GetClass("std::iostream");
3079// where the TClassEdit normalized name of iostream is basic_iostream<char>
3080// i.e missing the addition of the default parameter. This is because TClingLookupHelper
3081// uses only 'part' of TMetaUtils::GetNormalizedName.
3082
3083// if (!cl) {
3084// TDataType* dataType = (TDataType*)gROOT->GetListOfTypes()->FindObject(name);
3085// TClass *altcl = dataType ? (TClass*)gROOT->GetListOfClasses()->FindObject(dataType->GetFullTypeName()) : 0;
3086// if (altcl && normalizedName != altcl->GetName())
3087// ::Fatal("TClass::GetClass","The existing name (%s) for %s is different from the normalized name: %s\n",
3088// altcl->GetName(), name, normalizedName.c_str());
3089// }
3090
3091 // We want to avoid auto-parsing due to intentionally missing dictionary for std::pair.
3092 // However, we don't need this special treatement in rootcling (there is no auto-parsing)
3093 // and we want to make that the TClass for the pair goes through the regular creation
3094 // mechanism (i.e. in rootcling they should be in kInterpreted state and never in
3095 // kEmulated state) so that they have proper interpreter (ClassInfo) information which
3096 // will be used to create the TProtoClass (if one is requested for the pair).
3097 const bool ispair = TClassEdit::IsStdPair(normalizedName) && !IsFromRootCling();
3098 const bool ispairbase = TClassEdit::IsStdPairBase(normalizedName) && !IsFromRootCling();
3099
3100 TClass *loadedcl = nullptr;
3101 if (checkTable) {
3102 loadedcl = LoadClassDefault(normalizedName.c_str(),silent);
3103 } else {
3104 if (gInterpreter->AutoLoad(normalizedName.c_str(),kTRUE)) {
3105 // At this point more information has been loaded. This
3106 // information might be pertinent to the normalization of the name.
3107 // For example it might contain or be a typedef for which we don't
3108 // have a forward declaration (eg. typedef to instance of class
3109 // template with default parameters). So let's redo the normalization
3110 // as the new information (eg. typedef in TROOT::GetListOfTypes) might
3111 // lead to a different value.
3112 {
3114 TClassEdit::GetNormalizedName(normalizedName, name);
3115 }
3116 loadedcl = LoadClassDefault(normalizedName.c_str(),silent);
3117 }
3118 auto e = TEnum::GetEnum(normalizedName.c_str(), TEnum::kNone);
3119 if (e)
3120 return nullptr;
3121 // Maybe this was a typedef: let's try to see if this is the case
3122 if (!loadedcl && !ispair && !ispairbase) {
3123 if (TDataType* theDataType = gROOT->GetType(normalizedName.c_str())){
3124 // We have a typedef: we get the name of the underlying type
3125 auto underlyingTypeName = theDataType->GetTypeName();
3126 // We see if we can bootstrap a class with it
3127 auto underlyingTypeDict = TClassTable::GetDictNorm(underlyingTypeName.Data());
3128 if (underlyingTypeDict){
3129 loadedcl = underlyingTypeDict();
3130 }
3131
3132 }
3133 }
3134 }
3135 if (loadedcl) return loadedcl;
3136
3137 // See if the TClassGenerator can produce the TClass we need.
3138 loadedcl = LoadClassCustom(normalizedName.c_str(),silent);
3139 if (loadedcl) return loadedcl;
3140
3141 // We have not been able to find a loaded TClass, return the Emulated
3142 // TClass if we have one.
3143 if (cl) return cl;
3144
3145 if (ispair) {
3146 if (hint_pair_offset && hint_pair_size) {
3147 auto pairinfo = TVirtualStreamerInfo::Factory()->GenerateInfoForPair(normalizedName, silent, hint_pair_offset, hint_pair_size);
3148 // Fall-through to allow TClass to be created when known by the interpreter
3149 // This is used in the case where TStreamerInfo can not handle them.
3150 if (pairinfo)
3151 return pairinfo->GetClass();
3152 } else {
3153 // Check if we have an STL container that might provide it.
3154 static const size_t slen = strlen("pair");
3155 static const char *associativeContainer[] = { "map", "unordered_map", "multimap",
3156 "unordered_multimap", "set", "unordered_set", "multiset", "unordered_multiset" };
3157 for(auto contname : associativeContainer) {
3158 std::string collname = contname;
3159 collname.append( normalizedName.c_str() + slen );
3160 TClass *collcl = TClass::GetClass(collname.c_str(), false, silent);
3161 if (!collcl)
3162 collcl = LoadClassDefault(collname.c_str(), silent);
3163 if (collcl) {
3164 auto p = collcl->GetCollectionProxy();
3165 if (p)
3166 cl = p->GetValueClass();
3167 if (cl)
3168 return cl;
3169 }
3170 }
3171 }
3172 } else if (TClassEdit::IsSTLCont( normalizedName.c_str() )) {
3173
3174 return gInterpreter->GenerateTClass(normalizedName.c_str(), kTRUE, silent);
3175 }
3176
3177 // Check the interpreter only after autoparsing the template if any.
3178 if (!ispairbase) {
3179 std::string::size_type posLess = normalizedName.find('<');
3180 if (posLess != std::string::npos) {
3181 gCling->AutoParse(normalizedName.substr(0, posLess).c_str());
3182 }
3183 }
3184
3185 //last attempt. Look in CINT list of all (compiled+interpreted) classes
3186 if (gDebug>0){
3187 printf("TClass::GetClass: Header Parsing - The representation of %s was not found in the type system. A lookup in the interpreter is about to be tried: this can cause parsing. This can be avoided selecting %s in the linkdef/selection file.\n",normalizedName.c_str(), normalizedName.c_str());
3188 }
3189 if (normalizedName.length()) {
3190 auto cci = gInterpreter->CheckClassInfo(normalizedName.c_str(), kTRUE /* autoload */,
3191 kTRUE /*Only class, structs and ns*/);
3192
3193 // We could have an interpreted class with an inline ClassDef, in this case we do not
3194 // want to create an 'interpreted' TClass but we want the one triggered via the call to
3195 // the Dictionary member. If we go ahead and generate the 'interpreted' version it will
3196 // replace if/when there is a call to IsA on an object of this type.
3197
3199 auto ci = gInterpreter->ClassInfo_Factory(normalizedName.c_str());
3200 auto funcDecl = gInterpreter->GetFunctionWithPrototype(ci, "Dictionary", "", false, ROOT::kExactMatch);
3201 auto method = gInterpreter->MethodInfo_Factory(funcDecl);
3202 typedef void (*tcling_callfunc_Wrapper_t)(void *, int, void **, void *);
3203 auto funcPtr = (tcling_callfunc_Wrapper_t)gInterpreter->MethodInfo_InterfaceMethod(method);
3204
3205 TClass *res = nullptr;
3206 if (funcPtr)
3207 funcPtr(nullptr, 0, nullptr, &res);
3208 // else
3209 // We could fallback to the interpreted case ...
3210 // For now just 'fail' (return nullptr)
3211
3212 gInterpreter->MethodInfo_Delete(method);
3213 gInterpreter->ClassInfo_Delete(ci);
3214
3215 return res;
3216 } else if (cci) {
3217 // Get the normalized name based on the decl (currently the only way
3218 // to get the part to add or drop the default arguments as requested by the user)
3219 std::string alternative;
3220 gInterpreter->GetInterpreterTypeName(normalizedName.c_str(), alternative, kTRUE);
3221 if (alternative.empty())
3222 return nullptr;
3223 const char *altname = alternative.c_str();
3224 if (strncmp(altname, "std::", 5) == 0) {
3225 // For namespace (for example std::__1), GetInterpreterTypeName does
3226 // not strip std::, so we must do it explicitly here.
3227 altname += 5;
3228 }
3229 if (altname != normalizedName && strcmp(altname, name) != 0) {
3230 // altname now contains the full name of the class including a possible
3231 // namespace if there has been a using namespace statement.
3232
3233 // At least in the case C<string [2]> (normalized) vs C<string[2]> (altname)
3234 // the TClassEdit normalization and the TMetaUtils normalization leads to
3235 // two different space layout. To avoid an infinite recursion, we also
3236 // add the test on (altname != name)
3237
3238 return GetClass(altname, load);
3239 }
3240
3241 TClass *ncl = gInterpreter->GenerateTClass(normalizedName.c_str(), /* emulation = */ kFALSE, silent);
3242 if (!ncl->IsZombie()) {
3243 return ncl;
3244 }
3245 delete ncl;
3246 }
3247 }
3248 return nullptr;
3249}
3250
3251////////////////////////////////////////////////////////////////////////////////
3252/// Return pointer to class with name.
3253
3254TClass *TClass::GetClass(const std::type_info& typeinfo, Bool_t load, Bool_t /* silent */, size_t hint_pair_offset, size_t hint_pair_size)
3255{
3256 if (!gROOT->GetListOfClasses())
3257 return nullptr;
3258
3259 //protect access to TROOT::GetIdMap
3261
3262 TClass* cl = GetIdMap()->Find(typeinfo.name());
3263
3264 if (cl && cl->IsLoaded()) return cl;
3265
3267
3268 // Now that we got the write lock, another thread may have constructed the
3269 // TClass while we were waiting, so we need to do the checks again.
3270
3271 cl = GetIdMap()->Find(typeinfo.name());
3272
3273 if (cl) {
3274 if (cl->IsLoaded()) return cl;
3275 //we may pass here in case of a dummy class created by TVirtualStreamerInfo
3276 load = kTRUE;
3277 } else {
3278 // Note we might need support for typedefs and simple types!
3279
3280 // TDataType *objType = GetType(name, load);
3281 //if (objType) {
3282 // const char *typdfName = objType->GetTypeName();
3283 // if (typdfName && strcmp(typdfName, name)) {
3284 // cl = GetClass(typdfName, load);
3285 // return cl;
3286 // }
3287 // }
3288 }
3289
3290 if (!load) return nullptr;
3291
3292 DictFuncPtr_t dict = TClassTable::GetDict(typeinfo);
3293 if (dict) {
3294 cl = (dict)();
3295 if (cl) cl->PostLoadCheck();
3296 return cl;
3297 }
3298 if (cl) return cl;
3299
3300 TIter next(gROOT->GetListOfClassGenerators());
3301 TClassGenerator *gen;
3302 while( (gen = (TClassGenerator*) next()) ) {
3303 cl = gen->GetClass(typeinfo,load);
3304 if (cl) {
3305 cl->PostLoadCheck();
3306 return cl;
3307 }
3308 }
3309
3310 // try AutoLoading the typeinfo
3311 int autoload_old = gCling->SetClassAutoLoading(1);
3312 if (!autoload_old) {
3313 // Re-disable, we just meant to test
3315 }
3316 if (autoload_old && gInterpreter->AutoLoad(typeinfo,kTRUE)) {
3317 // Disable autoload to avoid potential infinite recursion
3319 cl = GetClass(typeinfo, load, hint_pair_offset, hint_pair_size);
3320 if (cl) {
3321 return cl;
3322 }
3323 }
3324
3325 if (hint_pair_offset) {
3326 int err = 0;
3327 char* demangled_name = TClassEdit::DemangleTypeIdName(typeinfo, err);
3328 if (!err) {
3329 cl = TClass::GetClass(demangled_name, load, kTRUE, hint_pair_offset, hint_pair_size);
3330 free(demangled_name);
3331 if (cl)
3332 return cl;
3333 }
3334 }
3335
3336 // last attempt. Look in the interpreter list of all (compiled+interpreted)
3337 // classes
3338 cl = gInterpreter->GetClass(typeinfo, load);
3339
3340 return cl; // Can be zero.
3341}
3342
3343////////////////////////////////////////////////////////////////////////////////
3344/// Static method returning pointer to TClass of the specified ClassInfo.
3345/// If load is true an attempt is made to obtain the class by loading
3346/// the appropriate shared library (directed by the rootmap file).
3347/// If silent is 'true', do not warn about missing dictionary for the class.
3348/// (typically used for class that are used only for transient members)
3349/// Returns 0 in case class is not found.
3350
3351TClass *TClass::GetClass(ClassInfo_t *info, Bool_t load, Bool_t silent)
3352{
3353 if (!info || !gCling->ClassInfo_IsValid(info)) return nullptr;
3354 if (!gROOT->GetListOfClasses()) return nullptr;
3355
3356 // Technically we need the write lock only for the call to ClassInfo_FullName
3357 // and GenerateTClass but FindObject will take the read lock (and LoadClass will
3358 // take the write lock). Since taking/releasing the lock is expensive, let just
3359 // take the write guard and keep it.
3361
3362 // Get the normalized name.
3364
3365 TClass *cl = (TClass*)gROOT->GetListOfClasses()->FindObject(name);
3366
3367 if (cl) {
3368 if (cl->IsLoaded()) return cl;
3369
3370 //we may pass here in case of a dummy class created by TVirtualStreamerInfo
3371 load = kTRUE;
3372
3373 }
3374
3375 if (!load) return nullptr;
3376
3377 TClass *loadedcl = nullptr;
3378 if (cl) loadedcl = gROOT->LoadClass(cl->GetName(),silent);
3379 else loadedcl = gROOT->LoadClass(name,silent);
3380
3381 if (loadedcl) return loadedcl;
3382
3383 if (cl) return cl; // If we found the class but we already have a dummy class use it.
3384
3385 // We did not find a proper TClass but we do know (we have a valid
3386 // ClassInfo) that the class is known to the interpreter.
3387 TClass *ncl = gInterpreter->GenerateTClass(info, silent);
3388 if (!ncl->IsZombie()) {
3389 return ncl;
3390 } else {
3391 delete ncl;
3392 return nullptr;
3393 }
3394}
3395
3396////////////////////////////////////////////////////////////////////////////////
3397
3400}
3401
3402////////////////////////////////////////////////////////////////////////////////
3403
3404Bool_t TClass::GetClass(DeclId_t id, std::vector<TClass*> &classes)
3405{
3406 if (!gROOT->GetListOfClasses()) return 0;
3407
3408 DeclIdMap_t* map = GetDeclIdMap();
3409 // Get all the TClass pointer that have the same DeclId.
3410 DeclIdMap_t::equal_range iter = map->Find(id);
3411 if (iter.first == iter.second) return false;
3412 std::vector<TClass*>::iterator vectIt = classes.begin();
3413 for (DeclIdMap_t::const_iterator it = iter.first; it != iter.second; ++it)
3414 vectIt = classes.insert(vectIt, it->second);
3415 return true;
3416}
3417
3418////////////////////////////////////////////////////////////////////////////////
3419/// Return a pointer to the dictionary loading function generated by
3420/// rootcint
3421
3423{
3425}
3426
3427////////////////////////////////////////////////////////////////////////////////
3428/// Return a pointer to the dictionary loading function generated by
3429/// rootcint
3430
3431DictFuncPtr_t TClass::GetDict (const std::type_info& info)
3432{
3433 return TClassTable::GetDict(info);
3434}
3435
3436////////////////////////////////////////////////////////////////////////////////
3437/// Return pointer to datamember object with name "datamember".
3438
3439TDataMember *TClass::GetDataMember(const char *datamember) const
3440{
3441 if ((!(fData.load() && (*fData).IsLoaded()) && !HasInterpreterInfo())
3442 || datamember == nullptr) return nullptr;
3443
3444 // Strip off leading *'s and trailing [
3445 const char *start_name = datamember;
3446 while (*start_name == '*') ++start_name;
3447
3448 // Empty name are 'legal', they represent anonymous unions.
3449 // if (*start_name == 0) return 0;
3450
3451 if (const char *s = strchr(start_name, '[')){
3452 UInt_t len = s-start_name;
3453 TString name(start_name,len);
3454 return (TDataMember *)((TClass*)this)->GetListOfDataMembers(kFALSE)->FindObject(name.Data());
3455 } else {
3456 return (TDataMember *)((TClass*)this)->GetListOfDataMembers(kFALSE)->FindObject(start_name);
3457 }
3458}
3459
3460////////////////////////////////////////////////////////////////////////////////
3461/// Return name of the file containing the declaration of this class.
3462
3463const char *TClass::GetDeclFileName() const
3464{
3465 if (fDeclFileName == kUndeterminedClassInfoName)
3466 return gInterpreter->ClassInfo_FileName( fClassInfo );
3467 return fDeclFileName;
3468}
3469
3470////////////////////////////////////////////////////////////////////////////////
3471/// return offset for member name. name can be a data member in
3472/// the class itself, one of its base classes, or one member in
3473/// one of the aggregated classes.
3474///
3475/// In case of an emulated class, the list of emulated TRealData is built
3476
3478{
3479 TRealData *rd = GetRealData(name);
3480 if (rd) return rd->GetThisOffset();
3481 if (strchr(name,'[')==nullptr) {
3482 // If this is a simple name there is a chance to find it in the
3483 // StreamerInfo even if we did not find it in the RealData.
3484 // For example an array name would be fArray[3] in RealData but
3485 // just fArray in the streamerInfo.
3486 TVirtualStreamerInfo *info = const_cast<TClass*>(this)->GetCurrentStreamerInfo();
3487 if (info) {
3488 return info->GetOffset(name);
3489 }
3490 }
3491 return 0;
3492}
3493
3494////////////////////////////////////////////////////////////////////////////////
3495/// Return pointer to TRealData element with name "name".
3496///
3497/// Name can be a data member in the class itself,
3498/// one of its base classes, or a member in
3499/// one of the aggregated classes.
3500///
3501/// In case of an emulated class, the list of emulated TRealData is built.
3502
3504{
3505 if (!fRealData) {
3506 const_cast<TClass*>(this)->BuildRealData();
3507 }
3508
3509 if (!fRealData) {
3510 return nullptr;
3511 }
3512
3513 if (!name) {
3514 return nullptr;
3515 }
3516
3517 // First try just the whole name.
3519 if (rd) {
3520 return rd;
3521 }
3522
3523 std::string givenName(name);
3524
3525 // Try ignoring the array dimensions.
3526 std::string::size_type firstBracket = givenName.find_first_of("[");
3527 if (firstBracket != std::string::npos) {
3528 // -- We are looking for an array data member.
3529 std::string nameNoDim(givenName.substr(0, firstBracket));
3530 TObjLink* lnk = fRealData->FirstLink();
3531 while (lnk) {
3532 TObject* obj = lnk->GetObject();
3533 std::string objName(obj->GetName());
3534 std::string::size_type pos = objName.find_first_of("[");
3535 // Only match arrays to arrays for now.
3536 if (pos != std::string::npos) {
3537 objName.erase(pos);
3538 if (objName == nameNoDim) {
3539 return static_cast<TRealData*>(obj);
3540 }
3541 }
3542 lnk = lnk->Next();
3543 }
3544 }
3545
3546 // Now try it as a pointer.
3547 std::ostringstream ptrname;
3548 ptrname << "*" << givenName;
3549 rd = (TRealData*) fRealData->FindObject(ptrname.str().c_str());
3550 if (rd) {
3551 return rd;
3552 }
3553
3554 // Check for a dot in the name.
3555 std::string::size_type firstDot = givenName.find_first_of(".");
3556 if (firstDot == std::string::npos) {
3557 // -- Not found, a simple name, all done.
3558 return nullptr;
3559 }
3560
3561 //
3562 // At this point the name has a dot in it, so it is the name
3563 // of some contained sub-object.
3564 //
3565
3566 // May be a pointer like in TH1: fXaxis.fLabels (in TRealdata is named fXaxis.*fLabels)
3567 std::string::size_type lastDot = givenName.find_last_of(".");
3568 std::ostringstream starname;
3569 starname << givenName.substr(0, lastDot) << ".*" << givenName.substr(lastDot + 1);
3570 rd = (TRealData*) fRealData->FindObject(starname.str().c_str());
3571 if (rd) {
3572 return rd;
3573 }
3574
3575 // Last attempt in case a member has been changed from
3576 // a static array to a pointer, for example the member
3577 // was arr[20] and is now *arr.
3578 //
3579 // Note: In principle, one could also take into account
3580 // the opposite situation where a member like *arr has
3581 // been converted to arr[20].
3582 //
3583 // FIXME: What about checking after the first dot as well?
3584 //
3585 std::string::size_type bracket = starname.str().find_first_of("[");
3586 if (bracket != std::string::npos) {
3587 rd = (TRealData*) fRealData->FindObject(starname.str().substr(0, bracket).c_str());
3588 if (rd) {
3589 return rd;
3590 }
3591 }
3592
3593 // Strip the first component, it may be the name of
3594 // the branch (old TBranchElement code), and try again.
3595 std::string firstDotName(givenName.substr(firstDot + 1));
3596
3597 rd = GetRealData(firstDotName.c_str());
3598 if (rd)
3599 return rd;
3600
3601 // Not found;
3602 return nullptr;
3603}
3604
3605////////////////////////////////////////////////////////////////////////////////
3606
3608{
3609 if (!gInterpreter || !HasInterpreterInfo()) return nullptr;
3610
3611 // The following
3613
3615}
3616
3617////////////////////////////////////////////////////////////////////////////////
3618/// Get the list of shared libraries containing the code for class cls.
3619/// The first library in the list is the one containing the class, the
3620/// others are the libraries the first one depends on. Returns 0
3621/// in case the library is not found.
3622
3624{
3625 if (!gInterpreter) return nullptr;
3626
3627 if (fSharedLibs.IsNull())
3628 fSharedLibs = gInterpreter->GetClassSharedLibs(fName);
3629
3630 return !fSharedLibs.IsNull() ? fSharedLibs.Data() : nullptr;
3631}
3632
3633////////////////////////////////////////////////////////////////////////////////
3634/// Return list containing the TBaseClass(es) of a class.
3635
3637{
3638 if (!fBase.load()) {
3639 if (fCanLoadClassInfo) {
3640 if (fState == kHasTClassInit) {
3641
3643 if (!fHasRootPcmInfo) {
3644 // The bases are in our ProtoClass; we don't need the class info.
3646 if (proto && proto->FillTClass(this))
3647 return fBase;
3648 }
3649 }
3650 // We test again on fCanLoadClassInfo has another thread may have executed it.
3652 LoadClassInfo();
3653 }
3654 }
3655 if (!fClassInfo)
3656 return nullptr;
3657
3658 if (!gInterpreter)
3659 Fatal("GetListOfBases", "gInterpreter not initialized");
3660
3662 if (!fBase.load()) {
3663 gInterpreter->CreateListOfBaseClasses(this);
3664 }
3665 }
3666 return fBase;
3667}
3668
3669////////////////////////////////////////////////////////////////////////////////
3670/// Return a list containing the TEnums of a class.
3671///
3672/// The list returned is safe to use from multiple thread without explicitly
3673/// taking the ROOT global lock.
3674///
3675/// In the case the TClass represents a namespace, the returned list will
3676/// implicit take the ROOT global lock upon any access (see TListOfEnumsWithLock)
3677///
3678/// In the case the TClass represents a class or struct and requestListLoading
3679/// is true, the list is immutable (and thus safe to access from multiple thread
3680/// without taking the global lock at all).
3681///
3682/// In the case the TClass represents a class or struct and requestListLoading
3683/// is false, the list is mutable and thus we return a TListOfEnumsWithLock
3684/// which will implicit take the ROOT global lock upon any access.
3685
3686TList *TClass::GetListOfEnums(Bool_t requestListLoading /* = kTRUE */)
3687{
3688 auto temp = fEnums.load();
3689 if (temp) {
3690 if (requestListLoading) {
3691 if (fProperty == -1) Property();
3692 if (! ((kIsClass | kIsStruct | kIsUnion) & fProperty) ) {
3694 temp->Load();
3695 } else if ( temp->IsA() == TListOfEnumsWithLock::Class() ) {
3696 // We have a class for which the list was not loaded fully at
3697 // first use.
3699 temp->Load();
3700 }
3701 }
3702 return temp;
3703 }
3704
3705 if (!requestListLoading) {
3706 if (fProperty == -1) Property();
3708 if (fEnums.load()) {
3709 return fEnums.load();
3710 }
3711
3712 if (IsFromRootCling()) // rootcling is single thread (this save some space in the rootpcm).
3713 fEnums = new TListOfEnums(this);
3714 else
3715 fEnums = new TListOfEnumsWithLock(this);
3716 return fEnums;
3717 }
3718
3720 if (fEnums.load()) {
3721 (*fEnums).Load();
3722 return fEnums.load();
3723 }
3724 if (fProperty == -1) Property();
3725 if ( (kIsClass | kIsStruct | kIsUnion) & fProperty) {
3726 // For this case, the list will be immutable
3727 temp = new TListOfEnums(this);
3728 } else {
3729 //namespaces can have enums added to them
3730 temp = new TListOfEnumsWithLock(this);
3731 }
3732 temp->Load();
3733 fEnums = temp;
3734 return temp;
3735}
3736
3737////////////////////////////////////////////////////////////////////////////////
3738/// Create the list containing the TDataMembers (of actual data members or members
3739/// pulled in through using declarations) of a class.
3740
3741TList *TClass::CreateListOfDataMembers(std::atomic<TListOfDataMembers*> &data, TDictionary::EMemberSelection selection, bool load)
3742{
3744
3745 if (!data) {
3747 // The members are in our ProtoClass; we don't need the class info.
3749 if (proto && proto->FillTClass(this))
3750 return data;
3751 }
3752
3753 data = new TListOfDataMembers(this, selection);
3754 }
3755 if (IsClassStructOrUnion()) {
3756 // If the we have a class or struct or union, the order
3757 // of data members is the list is essential since it determines their
3758 // order on file. So we must always load. Also, the list is fixed
3759 // since the language does not allow to add members.
3760 if (!(*data).IsLoaded())
3761 (*data).Load();
3762
3763 } else if (load) (*data).Load();
3764 return data;
3765}
3766
3767////////////////////////////////////////////////////////////////////////////////
3768/// Return list containing the TDataMembers of a class.
3769
3771{
3772 // Fast path, no lock? Classes load at creation time.
3773 if (IsClassStructOrUnion()) {
3774 auto data = fData.load();
3775 if (data && data->IsLoaded())
3776 return data;
3777 } else if (!load && fData)
3778 return fData;
3779
3781}
3782
3783////////////////////////////////////////////////////////////////////////////////
3784/// Return list containing the TDataMembers of using declarations of a class.
3785
3787{
3788 // Fast path, no lock? Classes load at creation time.
3789 if ((!load || IsClassStructOrUnion()) && fUsingData)
3790 return fUsingData;
3791
3793}
3794
3795////////////////////////////////////////////////////////////////////////////////
3796/// Return TListOfFunctionTemplates for a class.
3797
3799{
3801
3803 if (load) fFuncTemplate->Load();
3804 return fFuncTemplate;
3805}
3806
3807////////////////////////////////////////////////////////////////////////////////
3808/// Return list containing the TMethods of a class.
3809/// If load is true, the list is populated with all the defined function
3810/// and currently instantiated function template.
3811
3813{
3815
3816 if (!fMethod.load()) GetMethodList();
3817 if (load) {
3818 if (gDebug>0) Info("GetListOfMethods","Header Parsing - Asking for all the methods of class %s: this can involve parsing.",GetName());
3819 (*fMethod).Load();
3820 }
3821 return fMethod;
3822}
3823
3824////////////////////////////////////////////////////////////////////////////////
3825/// Return the collection of functions named "name".
3826
3828{
3829 return const_cast<TClass*>(this)->GetMethodList()->GetListForObject(name);
3830}
3831
3832
3833////////////////////////////////////////////////////////////////////////////////
3834/// Returns a list of all public methods of this class and its base classes.
3835/// Refers to a subset of the methods in GetListOfMethods() so don't do
3836/// GetListOfAllPublicMethods()->Delete().
3837/// Algorithm used to get the list is:
3838/// - put all methods of the class in the list (also protected and private
3839/// ones).
3840/// - loop over all base classes and add only those methods not already in the
3841/// list (also protected and private ones).
3842/// - once finished, loop over resulting list and remove all private and
3843/// protected methods.
3844
3846{
3848
3850 if (load) {
3851 if (gDebug>0) Info("GetListOfAllPublicMethods","Header Parsing - Asking for all the methods of class %s: this can involve parsing.",GetName());
3853 }
3854 return fAllPubMethod;
3855}
3856
3857////////////////////////////////////////////////////////////////////////////////
3858/// Returns a list of all public data members of this class and its base
3859/// classes. Refers to a subset of the data members in GetListOfDatamembers()
3860/// so don't do GetListOfAllPublicDataMembers()->Delete().
3861
3863{
3865
3867 if (load) fAllPubData->Load();
3868 return fAllPubData;
3869}
3870
3871////////////////////////////////////////////////////////////////////////////////
3872/// Returns list of methods accessible by context menu.
3873
3875{
3876 if (!HasInterpreterInfo()) return;
3877
3878 // get the base class
3879 TIter nextBase(GetListOfBases(), kIterBackward);
3880 TBaseClass *baseClass;
3881 while ((baseClass = (TBaseClass *) nextBase())) {
3882 TClass *base = baseClass->GetClassPointer();
3883 if (base) base->GetMenuItems(list);
3884 }
3885
3886 // remove methods redefined in this class with no menu
3887 TMethod *method, *m;
3889 while ((method = (TMethod*)next())) {
3890 m = (TMethod*)list->FindObject(method->GetName());
3891 if (method->IsMenuItem() != kMenuNoMenu) {
3892 if (!m)
3893 list->AddFirst(method);
3894 } else {
3895 if (m && m->GetNargs() == method->GetNargs())
3896 list->Remove(m);
3897 }
3898 }
3899}
3900
3901////////////////////////////////////////////////////////////////////////////////
3902/// Check whether a class has a dictionary or not.
3903/// This is equivalent to ask if a class is coming from a bootstrapping
3904/// procedure initiated during the loading of a library.
3905
3907{
3908 return IsLoaded();
3909}
3910
3911////////////////////////////////////////////////////////////////////////////////
3912/// Check whether a class has a dictionary or ROOT can load one.
3913/// This is equivalent to ask HasDictionary() or whether a library is known
3914/// where it can be loaded from, or whether a Dictionary function is
3915/// available because the class's dictionary library was already loaded.
3916
3918{
3919 if (TClass* cl = (TClass*)gROOT->GetListOfClasses()->FindObject(clname))
3920 return cl->IsLoaded();
3921 return gClassTable->GetDict(clname) || gInterpreter->GetClassSharedLibs(clname);
3922}
3923
3924////////////////////////////////////////////////////////////////////////////////
3925/// Verify the base classes always.
3926
3928{
3929 TList* lb = GetListOfBases();
3930 if (!lb) return;
3931 TIter nextBase(lb);
3932 TBaseClass* base = nullptr;
3933 while ((base = (TBaseClass*)nextBase())) {
3934 TClass* baseCl = base->GetClassPointer();
3935 if (baseCl) {
3936 baseCl->GetMissingDictionariesWithRecursionCheck(result, visited, recurse);
3937 }
3938 }
3939}
3940
3941////////////////////////////////////////////////////////////////////////////////
3942/// Verify the Data Members.
3943
3945{
3947 if (!ldm) return ;
3948 TIter nextMemb(ldm);
3949 TDataMember * dm = nullptr;
3950 while ((dm = (TDataMember*)nextMemb())) {
3951 // If it is a transient
3952 if(!dm->IsPersistent()) {
3953 continue;
3954 }
3955 if (dm->Property() & kIsStatic) {
3956 continue;
3957 }
3958 // If it is a built-in data type.
3959 TClass* dmTClass = nullptr;
3960 if (dm->GetDataType()) {
3961 // We have a basic datatype.
3962 dmTClass = nullptr;
3963 // Otherwise get the string representing the type.
3964 } else if (dm->GetTypeName()) {
3965 dmTClass = TClass::GetClass(dm->GetTypeName());
3966 }
3967 if (dmTClass) {
3968 dmTClass->GetMissingDictionariesWithRecursionCheck(result, visited, recurse);
3969 }
3970 }
3971}
3972
3974{
3975 // Pair is a special case and we have to check its elements for missing dictionaries
3976 // Pair is a transparent container so we should always look at its.
3977
3979 for (int i = 0; i < 2; i++) {
3980 TClass* pairElement = ((TStreamerElement*)SI->GetElements()->At(i))->GetClass();
3981 if (pairElement) {
3982 pairElement->GetMissingDictionariesWithRecursionCheck(result, visited, recurse);
3983 }
3984 }
3985}
3986
3987////////////////////////////////////////////////////////////////////////////////
3988/// From the second level of recursion onwards it is different state check.
3989
3991{
3992 if (result.FindObject(this) || visited.FindObject(this)) return;
3993
3994 static TClassRef sCIString("string");
3995 if (this == sCIString) return;
3996
3997 TClassEdit::TSplitType splitType(fName);
3998 if (splitType.IsTemplate()) {
3999 // We now treat special cases:
4000 // - pair
4001 // - unique_ptr
4002 // - array
4003 // - tuple
4004
4005 // Small helper to get the TClass instance from a classname and recursively
4006 // investigate it
4007 auto checkDicts = [&](const string &clName){
4008 auto cl = TClass::GetClass(clName.c_str());
4009 if (!cl) {
4010 // We try to remove * and const from the type name if any
4011 const auto clNameShortType = TClassEdit::ShortType(clName.c_str(), 1);
4012 cl = TClass::GetClass(clNameShortType.c_str());
4013 }
4014 if (cl && !cl->HasDictionary()) {
4015 cl->GetMissingDictionariesWithRecursionCheck(result, visited, recurse);
4016 }
4017 };
4018
4019 const auto &elements = splitType.fElements;
4020 const auto &templName = elements[0];
4021
4022 // Special treatment for pair.
4023 if (templName == "pair") {
4025 return;
4026 }
4027
4028 // Special treatment of unique_ptr or array
4029 // They are treated together since they have 1 single template argument
4030 // which is interesting when checking for missing dictionaries.
4031 if (templName == "unique_ptr" || templName == "array") {
4032 checkDicts(elements[1]);
4033 return;
4034 }
4035
4036 // Special treatment of tuple
4037 // This type must be treated separately since it can have N template
4038 // arguments which are interesting, unlike unique_ptr or array.
4039 if (templName == "tuple") {
4040 // -1 because the elements end with a list of the "stars", i.e. number of
4041 // * after the type name
4042 const auto nTemplArgs = elements.size() - 1;
4043 // loop starts at 1 because the first element is the template name
4044 for (auto iTemplArg = 1U; iTemplArg < nTemplArgs; ++iTemplArg) {
4045 checkDicts(elements[iTemplArg]);
4046 }
4047 return;
4048 }
4049 } // this is not a template
4050
4051 if (!HasDictionary()) {
4052 result.Add(this);
4053 }
4054
4055 visited.Add(this);
4056 //Check whether a custom streamer
4058 if (GetCollectionProxy()) {
4059 // We need to look at the collection's content
4060 // The collection has different kind of elements the check would be required.
4061 TClass* t = nullptr;
4062 if ((t = GetCollectionProxy()->GetValueClass())) {
4063 if (!t->HasDictionary()) {
4065 }
4066 }
4067 } else {
4068 if (recurse) {
4069 GetMissingDictionariesForMembers(result, visited, recurse);
4070 }
4072 }
4073 }
4074}
4075
4076////////////////////////////////////////////////////////////////////////////////
4077/// Get the classes that have a missing dictionary starting from this one.
4078/// - With recurse = false the classes checked for missing dictionaries are:
4079/// the class itself, all base classes, direct data members,
4080/// and for collection proxies the container's
4081/// elements without iterating over the element's data members;
4082/// - With recurse = true the classes checked for missing dictionaries are:
4083/// the class itself, all base classes, recursing on the data members,
4084/// and for the collection proxies recursion on the elements of the
4085/// collection and iterating over the element's data members.
4086
4088{
4089 // Top level recursion it different from the following levels of recursion.
4090
4091 if (result.FindObject(this)) return;
4092
4093 static TClassRef sCIString("string");
4094 if (this == sCIString) return;
4095
4096 THashTable visited;
4097
4100 return;
4101 }
4102
4103 if (strncmp(fName, "unique_ptr<", 11) == 0 || strncmp(fName, "array<", 6) == 0 || strncmp(fName, "tuple<", 6) == 0) {
4105 return;
4106 }
4107
4108 if (!HasDictionary()) {
4109 result.Add(this);
4110 }
4111
4112 visited.Add(this);
4113
4114 //Check whether a custom streamer
4116 if (GetCollectionProxy()) {
4117 // We need to look at the collection's content
4118 // The collection has different kind of elements the check would be required.
4119 TClass* t = nullptr;
4120 if ((t = GetCollectionProxy()->GetValueClass())) {
4121 if (!t->HasDictionary()) {
4123 }
4124 }
4125 } else {
4126 GetMissingDictionariesForMembers(result, visited, recurse);
4128 }
4129 }
4130}
4131
4132////////////////////////////////////////////////////////////////////////////////
4133/// Return kTRUE if the class has elements.
4134
4135Bool_t TClass::IsFolder(void *obj) const
4136{
4137 return Browse(obj,(TBrowser*)nullptr);
4138}
4139
4140//______________________________________________________________________________
4141//______________________________________________________________________________
4142void TClass::ReplaceWith(TClass *newcl) const
4143{
4144 // Inform the other objects to replace this object by the new TClass (newcl)
4145
4147 //we must update the class pointers pointing to 'this' in all TStreamerElements
4148 TIter nextClass(gROOT->GetListOfClasses());
4149 TClass *acl;
4151
4152 // Since we are in the process of replacing a TClass by a TClass
4153 // coming from a dictionary, there is no point in loading any
4154 // libraries during this search.
4156 while ((acl = (TClass*)nextClass())) {
4157 if (acl == newcl) continue;
4158
4159 TIter nextInfo(acl->GetStreamerInfos());
4160 while ((info = (TVirtualStreamerInfo*)nextInfo())) {
4161
4162 info->Update(this, newcl);
4163 }
4164 }
4165
4166 gInterpreter->UnRegisterTClassUpdate(this);
4167}
4168
4169////////////////////////////////////////////////////////////////////////////////
4170/// Make sure that the current ClassInfo is up to date.
4171
4173{
4174 Warning("ResetClassInfo(Long_t tagnum)","Call to deprecated interface (does nothing)");
4175}
4176
4177////////////////////////////////////////////////////////////////////////////////
4178/// Make sure that the current ClassInfo is up to date.
4179
4181{
4183
4185
4186 if (fClassInfo) {
4188 gInterpreter->ClassInfo_Delete(fClassInfo);
4189 fClassInfo = nullptr;
4190 }
4191 // We can not check at this point whether after the unload there will
4192 // still be interpreter information about this class (as v5 was doing),
4193 // instead this function must only be called if the definition is (about)
4194 // to be unloaded.
4195
4196 ResetCaches();
4197
4198 // We got here because the definition Decl is about to be unloaded.
4200 if (fStreamerInfo->GetEntries() != 0) {
4202 } else {
4204 }
4205 } else {
4206 // if the ClassInfo was loaded for a class with a TClass Init and it
4207 // gets unloaded, should we guess it can be reloaded?
4209 }
4210}
4211
4212////////////////////////////////////////////////////////////////////////////////
4213/// To clean out all caches.
4214
4216{
4217 R__ASSERT(!TestBit(kLoading) && "Resetting the caches does not make sense during loading!" );
4218
4219 // Not owning lists, don't call Delete(), but unload
4220 if (fData.load())
4221 (*fData).Unload();
4222 if (fUsingData.load())
4223 (*fUsingData).Unload();
4224 if (fEnums.load())
4225 (*fEnums).Unload();
4226 if (fMethod.load())
4227 (*fMethod).Unload();
4228
4229 delete fAllPubData; fAllPubData = nullptr;
4230
4231 if (fBase.load())
4232 (*fBase).Delete();
4233 delete fBase.load(); fBase = nullptr;
4234
4235 if (fRealData)
4236 fRealData->Delete();
4237 delete fRealData; fRealData=nullptr;
4238}
4239
4240////////////////////////////////////////////////////////////////////////////////
4241/// Resets the menu list to it's standard value.
4242
4244{
4245 if (fClassMenuList)
4247 else
4248 fClassMenuList = new TList();
4250}
4251
4252////////////////////////////////////////////////////////////////////////////////
4253/// The ls function lists the contents of a class on stdout. Ls output
4254/// is typically much less verbose then Dump().
4255/// If options contains 'streamerinfo', run ls on the list of streamerInfos
4256/// and the list of conversion streamerInfos.
4257
4258void TClass::ls(Option_t *options) const
4259{
4260 TNamed::ls(options);
4261 if (options==nullptr || options[0]==0) return;
4262
4263 if (strstr(options,"streamerinfo")!=nullptr) {
4264 GetStreamerInfos()->ls(options);
4265
4266 if (fConversionStreamerInfo.load()) {
4267 std::map<std::string, TObjArray*>::iterator it;
4268 std::map<std::string, TObjArray*>::iterator end = (*fConversionStreamerInfo).end();
4269 for( it = (*fConversionStreamerInfo).begin(); it != end; ++it ) {
4270 it->second->ls(options);
4271 }
4272 }
4273 }
4274}
4275
4276////////////////////////////////////////////////////////////////////////////////
4277/// Makes a customizable version of the popup menu list, i.e. makes a list
4278/// of TClassMenuItem objects of methods accessible by context menu.
4279/// The standard (and different) way consists in having just one element
4280/// in this list, corresponding to the whole standard list.
4281/// Once the customizable version is done, one can remove or add elements.
4282
4284{
4286 TClassMenuItem *menuItem;
4287
4288 // Make sure fClassMenuList is initialized and empty.
4289 GetMenuList()->Delete();
4290
4291 TList* methodList = new TList;
4292 GetMenuItems(methodList);
4293
4294 TMethod *method;
4295 TMethodArg *methodArg;
4296 TClass *classPtr = nullptr;
4297 TIter next(methodList);
4298
4299 while ((method = (TMethod*) next())) {
4300 // if go to a mother class method, add separator
4301 if (classPtr != method->GetClass()) {
4302 menuItem = new TClassMenuItem(TClassMenuItem::kPopupSeparator, this);
4303 fClassMenuList->AddLast(menuItem);
4304 classPtr = method->GetClass();
4305 }
4306 // Build the signature of the method
4307 TString sig;
4308 TList* margsList = method->GetListOfMethodArgs();
4309 TIter nextarg(margsList);
4310 while ((methodArg = (TMethodArg*)nextarg())) {
4311 sig = sig+","+methodArg->GetFullTypeName();
4312 }
4313 if (sig.Length()!=0) sig.Remove(0,1); // remove first comma
4315 method->GetName(), method->GetName(),nullptr,
4316 sig.Data(),-1,TClassMenuItem::kIsSelf);
4317 if (method->IsMenuItem() == kMenuToggle) menuItem->SetToggle();
4318 fClassMenuList->Add(menuItem);
4319 }
4320 delete methodList;
4321}
4322
4323////////////////////////////////////////////////////////////////////////////////
4324/// Register the fact that an object was moved from the memory location
4325/// 'arenaFrom' to the memory location 'arenaTo'.
4326
4327void TClass::Move(void *arenaFrom, void *arenaTo) const
4328{
4329 // If/when we have access to a copy constructor (or better to a move
4330 // constructor), this function should also perform the data move.
4331 // For now we just information the repository.
4332
4333 if ((GetState() <= kEmulated) && !fCollectionProxy) {
4334 MoveAddressInRepository("TClass::Move",arenaFrom,arenaTo,this);
4335 }
4336}
4337
4338////////////////////////////////////////////////////////////////////////////////
4339/// Return the list of menu items associated with the class.
4340
4342 if (!fClassMenuList) {
4343 fClassMenuList = new TList();
4345 }
4346 return fClassMenuList;
4347}
4348
4349////////////////////////////////////////////////////////////////////////////////
4350/// Return (create an empty one if needed) the list of functions.
4351/// The major difference with GetListOfMethod is that this returns
4352/// the internal type of fMethod and thus can not be made public.
4353/// It also never 'loads' the content of the list.
4354
4356{
4357 if (!fMethod.load()) {
4358 std::unique_ptr<TListOfFunctions> temp{ new TListOfFunctions(this) };
4359 TListOfFunctions* expected = nullptr;
4360 if(fMethod.compare_exchange_strong(expected, temp.get()) ) {
4361 temp.release();
4362 }
4363 }
4364 return fMethod;
4365}
4366
4367
4368////////////////////////////////////////////////////////////////////////////////
4369/// Return pointer to method without looking at parameters.
4370/// Does not look in (possible) base classes.
4371/// Has the side effect of loading all the TMethod object in the list
4372/// of the class.
4373
4374TMethod *TClass::GetMethodAny(const char *method)
4375{
4376 if (!HasInterpreterInfo()) return nullptr;
4377 return (TMethod*) GetMethodList()->FindObject(method);
4378}
4379
4380////////////////////////////////////////////////////////////////////////////////
4381/// Return pointer to method without looking at parameters.
4382/// Does look in all base classes.
4383
4385{
4386 if (!HasInterpreterInfo()) return nullptr;
4387
4388 TMethod* m = GetMethodAny(method);
4389 if (m) return m;
4390
4391 TBaseClass *base;
4392 TIter nextb(GetListOfBases());
4393 while ((base = (TBaseClass *) nextb())) {
4394 TClass *c = base->GetClassPointer();
4395 if (c) {
4396 m = c->GetMethodAllAny(method);
4397 if (m) return m;
4398 }
4399 }
4400
4401 return nullptr;
4402}
4403
4404////////////////////////////////////////////////////////////////////////////////
4405/// Find the best method (if there is one) matching the parameters.
4406/// The params string must contain argument values, like "3189, \"aap\", 1.3".
4407/// The function invokes GetClassMethod to search for a possible method
4408/// in the class itself or in its base classes. Returns 0 in case method
4409/// is not found.
4410
4411TMethod *TClass::GetMethod(const char *method, const char *params,
4412 Bool_t objectIsConst /* = kFALSE */)
4413{
4415 if (!fClassInfo) return nullptr;
4416
4417 if (!gInterpreter)
4418 Fatal("GetMethod", "gInterpreter not initialized");
4419
4420 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithValues(fClassInfo,
4421 method, params,
4422 objectIsConst);
4423
4424 if (!decl) return nullptr;
4425
4426 // search recursively in this class or its base classes
4428 if (f) return f;
4429
4430 Error("GetMethod",
4431 "\nDid not find matching TMethod <%s> with \"%s\" %sfor %s",
4432 method,params,objectIsConst ? "const " : "", GetName());
4433 return nullptr;
4434}
4435
4436
4437////////////////////////////////////////////////////////////////////////////////
4438/// Find a method with decl id in this class or its bases.
4439
4441 if (TFunction* method = GetMethodList()->Get(declId))
4442 return static_cast<TMethod *>(method);
4443
4444 for (auto item : *GetListOfBases())
4445 if (auto base = static_cast<TBaseClass *>(item)->GetClassPointer())
4446 if (TFunction* method = base->FindClassOrBaseMethodWithId(declId))
4447 return static_cast<TMethod *>(method);
4448
4449 return nullptr;
4450}
4451
4452////////////////////////////////////////////////////////////////////////////////
4453/// Find the method with a given prototype. The proto string must be of the
4454/// form: "char*,int,double". Returns 0 in case method is not found.
4455
4456TMethod *TClass::GetMethodWithPrototype(const char *method, const char *proto,
4457 Bool_t objectIsConst /* = kFALSE */,
4458 ROOT::EFunctionMatchMode mode /* = ROOT::kConversionMatch */)
4459{
4461 if (!fClassInfo) return nullptr;
4462
4463 if (!gInterpreter)
4464 Fatal("GetMethodWithPrototype", "gInterpreter not initialized");
4465
4466 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithPrototype(fClassInfo,
4467 method, proto,
4468 objectIsConst, mode);
4469
4470 if (!decl) return nullptr;
4472 if (f) return f;
4473 Error("GetMethodWithPrototype",
4474 "\nDid not find matching TMethod <%s> with \"%s\" %sfor %s",
4475 method,proto,objectIsConst ? "const " : "", GetName());
4476 return nullptr;
4477}
4478
4479////////////////////////////////////////////////////////////////////////////////
4480/// Look for a method in this class that has the interface function
4481/// address faddr.
4482
4484{
4485 if (!HasInterpreterInfo()) return nullptr;
4486
4487 TMethod *m;
4488 TIter next(GetListOfMethods());
4489 while ((m = (TMethod *) next())) {
4490 if (faddr == (Longptr_t)m->InterfaceMethod())
4491 return m;
4492 }
4493 return nullptr;
4494}
4495
4496////////////////////////////////////////////////////////////////////////////////
4497/// Look for a method in this class that has the name and matches the parameters.
4498/// The params string must contain argument values, like "3189, \"aap\", 1.3".
4499/// Returns 0 in case method is not found.
4500/// See TClass::GetMethod to also search the base classes.
4501
4502TMethod *TClass::GetClassMethod(const char *name, const char* params,
4503 Bool_t objectIsConst /* = kFALSE */)
4504{
4506 if (!fClassInfo) return nullptr;
4507
4508 if (!gInterpreter)
4509 Fatal("GetClassMethod", "gInterpreter not initialized");
4510
4511 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithValues(fClassInfo,
4512 name, params,
4513 objectIsConst);
4514
4515 if (!decl) return nullptr;
4516
4517 TFunction *f = GetMethodList()->Get(decl);
4518
4519 return (TMethod*)f; // Could be zero if the decl is actually in a base class.
4520}
4521
4522////////////////////////////////////////////////////////////////////////////////
4523/// Find the method with a given prototype. The proto string must be of the
4524/// form: "char*,int,double". Returns 0 in case method is not found.
4525/// See TClass::GetMethodWithPrototype to also search the base classes.
4526
4528 Bool_t objectIsConst /* = kFALSE */,
4529 ROOT::EFunctionMatchMode mode /* = ROOT::kConversionMatch */)
4530{
4532 if (!fClassInfo) return nullptr;
4533
4534 if (!gInterpreter)
4535 Fatal("GetClassMethodWithPrototype", "gInterpreter not initialized");
4536
4537 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithPrototype(fClassInfo,
4538 name, proto,
4539 objectIsConst,
4540 mode);
4541
4542 if (!decl) return nullptr;
4543
4544 TFunction *f = GetMethodList()->Get(decl);
4545
4546 return (TMethod*)f; // Could be zero if the decl is actually in a base class.
4547}
4548
4549////////////////////////////////////////////////////////////////////////////////
4550/// Return the number of data members of this class
4551/// Note that in case the list of data members is not yet created, it will be done
4552/// by GetListOfDataMembers().
4553
4555{
4556 if (!HasDataMemberInfo()) return 0;
4557
4559 if (lm)
4560 return lm->GetSize();
4561 else
4562 return 0;
4563}
4564
4565////////////////////////////////////////////////////////////////////////////////
4566/// Return the number of methods of this class
4567/// Note that in case the list of methods is not yet created, it will be done
4568/// by GetListOfMethods().
4569/// This will also load/populate the list of methods, to get 'just' the
4570/// number of currently loaded methods use:
4571/// cl->GetListOfMethods(false)->GetSize();
4572
4574{
4575 if (!HasInterpreterInfo()) return 0;
4576
4577 TList *lm = GetListOfMethods();
4578 if (lm)
4579 return lm->GetSize();
4580 else
4581 return 0;
4582}
4583
4584////////////////////////////////////////////////////////////////////////////////
4585/// returns a pointer to the TVirtualStreamerInfo object for version
4586/// If the object does not exist, it is created
4587///
4588/// Note: There are two special version numbers:
4589///
4590/// - 0: Use the class version from the currently loaded class library.
4591/// - -1: Assume no class library loaded (emulated class).
4592///
4593/// Warning: If we create a new streamer info, whether or not the build
4594/// optimizes is controlled externally to us by a global variable!
4595/// Don't call us unless you have set that variable properly
4596/// with TStreamer::Optimize()!
4597///
4598
4599TVirtualStreamerInfo* TClass::GetStreamerInfo(Int_t version /* = 0 */, Bool_t isTransient /* = false */) const
4600{
4602
4603 // Version 0 is special, it means the currently loaded version.
4604 // We need to set it at the beginning to be able to guess it correctly.
4605
4606 if (version == 0)
4607 version = fClassVersion;
4608
4609 // If the StreamerInfo is assigned to the fLastReadInfo, we are
4610 // guaranteed it was built and compiled.
4611 if (sinfo && sinfo->GetClassVersion() == version)
4612 return sinfo;
4613
4614 // Note that the access to fClassVersion above is technically not thread-safe with a low probably of problems.
4615 // fClassVersion is not an atomic and is modified TClass::SetClassVersion (called from RootClassVersion via
4616 // ROOT::ResetClassVersion) and is 'somewhat' protected by the atomic fVersionUsed.
4617 // However, direct access to fClassVersion should be replaced by calls to GetClassVersion to set fVersionUsed.
4618 // Even with such a change the code here and in these functions need to be reviewed as a cursory look seem
4619 // to indicates they are not yet properly protection against mutli-thread access.
4620 //
4621 // However, the use of these functions is rare and mostly done at library loading time which should
4622 // in almost all cases preceeds the possibility of GetStreamerInfo being called from multiple thread
4623 // on that same TClass object.
4624 //
4625 // Summary: need careful review but risk of problem is extremely low.
4626
4628
4629 return GetStreamerInfoImpl(version, isTransient);
4630};
4631
4632// Implementation of/for TStreamerInfo::GetStreamerInfo.
4633// This routine assumes the global lock has been taken.
4635{
4636 // Warning: version may be -1 for an emulated class, or -2 if the
4637 // user requested the emulated streamerInfo for an abstract
4638 // base class, even though we have a dictionary for it.
4639
4640 if ((version < -1) || (version >= (fStreamerInfo->GetSize()-1))) {
4641 Error("GetStreamerInfo", "class: %s, attempting to access a wrong version: %d", GetName(), version);
4642 // FIXME: Shouldn't we go to -1 here, or better just abort?
4643 version = fClassVersion;
4644 }
4645
4647
4648 if (!sinfo && (version != fClassVersion)) {
4649 // When the requested version does not exist we return
4650 // the TVirtualStreamerInfo for the currently loaded class version.
4651 // FIXME: This arguably makes no sense, we should warn and return nothing instead.
4652 // Note: This is done for STL collections
4653 // Note: fClassVersion could be -1 here (for an emulated class).
4654 // This is also the code path take for unversioned classes.
4656 }
4657
4658 if (!sinfo) {
4659 // We just were not able to find a streamer info, we have to make a new one.
4660 TMmallocDescTemp setreset;
4661 sinfo = TVirtualStreamerInfo::Factory()->NewInfo(const_cast<TClass*>(this));
4663 if (gDebug > 0) {
4664 printf("Creating StreamerInfo for class: %s, version: %d\n", GetName(), fClassVersion);
4665 }
4667 // If we do not have a StreamerInfo for this version and we do not
4668 // have dictionary information nor a proxy, there is nothing to build!
4669 sinfo->Build(silent);
4670 }
4671 } else {
4672 if (!sinfo->IsCompiled()) {
4673 // Streamer info has not been compiled, but exists.
4674 // Therefore it was read in from a file and we have to do schema evolution?
4675 // Or it didn't have a dictionary before, but does now?
4676 sinfo->BuildOld();
4677 }
4678 }
4679
4680 // Cache the current info if we now have it.
4681 if (version == fClassVersion)
4682 fCurrentInfo = sinfo;
4683
4684 // If the compilation succeeded, remember this StreamerInfo.
4685 if (sinfo->IsCompiled())
4686 fLastReadInfo = sinfo;
4687
4688 return sinfo;
4689}
4690
4691////////////////////////////////////////////////////////////////////////////////
4692/// For the case where the requestor class is emulated and this class is abstract,
4693/// returns a pointer to the TVirtualStreamerInfo object for version with an emulated
4694/// representation whether or not the class is loaded.
4695///
4696/// If the object does not exist, it is created
4697///
4698/// Note: There are two special version numbers:
4699///
4700/// - 0: Use the class version from the currently loaded class library.
4701/// - -1: Assume no class library loaded (emulated class).
4702///
4703/// Warning: If we create a new streamer info, whether or not the build
4704/// optimizes is controlled externally to us by a global variable!
4705/// Don't call us unless you have set that variable properly
4706/// with TStreamer::Optimize()!
4707///
4708
4710{
4711 TVirtualStreamerInfo *sinfo = nullptr;
4712
4713 TString newname(GetName());
4714 newname += "@@emulated";
4715
4717
4718 TClass *emulated = TClass::GetClass(newname);
4719
4720 if (emulated)
4721 sinfo = emulated->GetStreamerInfo(version);
4722
4723 if (!sinfo) {
4724 // The emulated version of the streamerInfo is explicitly requested and has
4725 // not been built yet.
4726
4727 sinfo = (TVirtualStreamerInfo*) fStreamerInfo->At(version);
4728
4729 if (!sinfo && (version != fClassVersion)) {
4730 // When the requested version does not exist we return
4731 // the TVirtualStreamerInfo for the currently loaded class version.
4732 // FIXME: This arguably makes no sense, we should warn and return nothing instead.
4734 }
4735
4736 if (!sinfo) {
4737 // Let's take the first available StreamerInfo as a start
4738 Int_t ninfos = fStreamerInfo->GetEntriesFast() - 1;
4739 for (Int_t i = -1; sinfo == nullptr && i < ninfos; ++i)
4741 }
4742
4743 if (sinfo) {
4744 sinfo = dynamic_cast<TVirtualStreamerInfo *>(sinfo->Clone());
4745 if (sinfo) {
4746 sinfo->SetClass(nullptr);
4747 sinfo->SetName(newname);
4748 sinfo->BuildCheck();
4749 sinfo->BuildOld();
4750 sinfo->GetClass()->AddRule(TString::Format("sourceClass=%s targetClass=%s",GetName(),newname.Data()));
4751 } else {
4752 Error("GetStreamerInfoAbstractEmulated", "could not create TVirtualStreamerInfo");
4753 }
4754 }
4755 }
4756 return sinfo;
4757}
4758
4759////////////////////////////////////////////////////////////////////////////////
4760/// For the case where the requestor class is emulated and this class is abstract,
4761/// returns a pointer to the TVirtualStreamerInfo object for version with an emulated
4762/// representation whether or not the class is loaded.
4763///
4764/// If the object does not exist, it is created
4765///
4766/// Warning: If we create a new streamer info, whether or not the build
4767/// optimizes is controlled externally to us by a global variable!
4768/// Don't call us unless you have set that variable properly
4769/// with TStreamer::Optimize()!
4770///
4771
4773{
4774 TVirtualStreamerInfo *sinfo = nullptr;
4775
4776 TString newname(GetName());
4777 newname += "@@emulated";
4778
4780
4781 TClass *emulated = TClass::GetClass(newname);
4782
4783 if (emulated)
4784 sinfo = emulated->FindStreamerInfo(checksum);
4785
4786 if (!sinfo) {
4787 // The emulated version of the streamerInfo is explicitly requested and has
4788 // not been built yet.
4789
4790 sinfo = (TVirtualStreamerInfo*) FindStreamerInfo(checksum);
4791
4792 if (!sinfo && (checksum != fCheckSum)) {
4793 // When the requested version does not exist we return
4794 // the TVirtualStreamerInfo for the currently loaded class version.
4795 // FIXME: This arguably makes no sense, we should warn and return nothing instead.
4797 }
4798
4799 if (!sinfo) {
4800 // Let's take the first available StreamerInfo as a start
4801 Int_t ninfos = fStreamerInfo->GetEntriesFast() - 1;
4802 for (Int_t i = -1; sinfo == nullptr && i < ninfos; ++i)
4804 }
4805
4806 if (sinfo) {
4807 sinfo = dynamic_cast<TVirtualStreamerInfo*>( sinfo->Clone() );
4808 if (sinfo) {
4809 sinfo->SetClass(nullptr);
4810 sinfo->SetName( newname );
4811 sinfo->BuildCheck();
4812 sinfo->BuildOld();
4813 sinfo->GetClass()->AddRule(TString::Format("sourceClass=%s targetClass=%s",GetName(),newname.Data()));
4814 } else {
4815 Error("GetStreamerInfoAbstractEmulated", "could not create TVirtualStreamerInfo");
4816 }
4817 }
4818 }
4819 return sinfo;
4820}
4821
4822////////////////////////////////////////////////////////////////////////////////
4823/// When the class kIgnoreTObjectStreamer bit is set, the automatically
4824/// generated Streamer will not call TObject::Streamer.
4825/// This option saves the TObject space overhead on the file.
4826/// However, the information (fBits, fUniqueID) of TObject is lost.
4827///
4828/// Note that to be effective for objects streamed object-wise this function
4829/// must be called for the class deriving directly from TObject, eg, assuming
4830/// that BigTrack derives from Track and Track derives from TObject, one must do:
4831/// ~~~ {.cpp}
4832/// Track::Class()->IgnoreTObjectStreamer();
4833/// ~~~
4834/// and not:
4835/// ~~~ {.cpp}
4836/// BigTrack::Class()->IgnoreTObjectStreamer();
4837/// ~~~
4838/// To be effective for object streamed member-wise or split in a TTree,
4839/// this function must be called for the most derived class (i.e. BigTrack).
4840
4842{
4843 // We need to tak the lock since we are test and then setting fBits
4844 // and TStreamerInfo::fBits (and the StreamerInfo state in general)
4845 // which can also be modified by another thread.
4847
4848 if ( doIgnore && TestBit(kIgnoreTObjectStreamer)) return;
4849 if (!doIgnore && !TestBit(kIgnoreTObjectStreamer)) return;
4851 if (sinfo) {
4852 if (sinfo->IsCompiled()) {
4853 // -- Warn the user that what they are doing cannot work.
4854 // Note: The reason is that TVirtualStreamerInfo::Build() examines
4855 // the kIgnoreTObjectStreamer bit and sets the TStreamerElement
4856 // type for the TObject base class streamer element it creates
4857 // to -1 as a flag. Later on the TStreamerInfo::Compile()
4858 // member function sees the flag and does not insert the base
4859 // class element into the compiled streamer info. None of this
4860 // machinery works correctly if we are called after the streamer
4861 // info has already been built and compiled.
4862 Error("IgnoreTObjectStreamer","Must be called before the creation of StreamerInfo");
4863 return;
4864 }
4865 }
4866 if (doIgnore) SetBit (kIgnoreTObjectStreamer);
4868}
4869
4870////////////////////////////////////////////////////////////////////////////////
4871/// Return kTRUE if this class inherits from a class with name "classname".
4872/// note that the function returns kTRUE in case classname is the class itself
4873
4874Bool_t TClass::InheritsFrom(const char *classname) const
4875{
4876 if (strcmp(GetName(), classname) == 0) return kTRUE;
4877
4878 return InheritsFrom(TClass::GetClass(classname,kTRUE,kTRUE));
4879}
4880
4881////////////////////////////////////////////////////////////////////////////////
4882/// Return kTRUE if this class inherits from class cl.
4883/// note that the function returns KTRUE in case cl is the class itself
4884
4886{
4887 if (!cl) return kFALSE;
4888 if (cl == this) return kTRUE;
4889
4890 if (!HasDataMemberInfo()) {
4891 TVirtualStreamerInfo *sinfo = ((TClass *)this)->GetCurrentStreamerInfo();
4892 if (sinfo==nullptr) sinfo = GetStreamerInfo();
4893 TIter next(sinfo->GetElements());
4894 TStreamerElement *element;
4895 while ((element = (TStreamerElement*)next())) {
4896 if (element->IsA() == TStreamerBase::Class()) {
4897 TClass *clbase = element->GetClassPointer();
4898 if (!clbase) return kFALSE; //missing class
4899 if (clbase->InheritsFrom(cl)) return kTRUE;
4900 }
4901 }
4902 return kFALSE;
4903 }
4904 // cast const away (only for member fBase which can be set in GetListOfBases())
4905 if (((TClass *)this)->GetBaseClass(cl)) return kTRUE;
4906 return kFALSE;
4907}
4908
4909////////////////////////////////////////////////////////////////////////////////
4910/// Cast obj of this class type up to baseclass cl if up is true.
4911/// Cast obj of this class type down from baseclass cl if up is false.
4912/// If this class is not a baseclass of cl return 0, else the pointer
4913/// to the cl part of this (up) or to this (down).
4914
4915void *TClass::DynamicCast(const TClass *cl, void *obj, Bool_t up)
4916{
4917 if (cl == this) return obj;
4918
4919 if (!HasDataMemberInfo()) return nullptr;
4920
4921 Int_t off;
4922 if ((off = GetBaseClassOffset(cl, obj)) != -1) {
4923 if (up)
4924 return (void*)((Longptr_t)obj+off);
4925 else
4926 return (void*)((Longptr_t)obj-off);
4927 }
4928 return nullptr;
4929}
4930
4931////////////////////////////////////////////////////////////////////////////////
4932/// Cast obj of this class type up to baseclass cl if up is true.
4933/// Cast obj of this class type down from baseclass cl if up is false.
4934/// If this class is not a baseclass of cl return 0, else the pointer
4935/// to the cl part of this (up) or to this (down).
4936
4937const void *TClass::DynamicCast(const TClass *cl, const void *obj, Bool_t up)
4938{
4939 return DynamicCast(cl,const_cast<void*>(obj),up);
4940}
4941
4942////////////////////////////////////////////////////////////////////////////////
4943/// Return a pointer to a newly allocated object of this class.
4944/// The class must have a default constructor. For meaning of
4945/// defConstructor, see TClass::IsCallingNew().
4946///
4947/// If quiet is true, do no issue a message via Error on case
4948/// of problems, just return 0.
4949///
4950/// The constructor actually called here can be customized by
4951/// using the rootcint pragma:
4952/// ~~~ {.cpp}
4953/// #pragma link C++ ioctortype UserClass;
4954/// ~~~
4955/// For example, with this pragma and a class named MyClass,
4956/// this method will called the first of the following 3
4957/// constructors which exists and is public:
4958/// ~~~ {.cpp}
4959/// MyClass(UserClass*);
4960/// MyClass(TRootIOCtor*);
4961/// MyClass(); // Or a constructor with all its arguments defaulted.
4962/// ~~~
4963///
4964/// When more than one pragma ioctortype is used, the first seen as priority
4965/// For example with:
4966/// ~~~ {.cpp}
4967/// #pragma link C++ ioctortype UserClass1;
4968/// #pragma link C++ ioctortype UserClass2;
4969/// ~~~
4970/// We look in the following order:
4971/// ~~~ {.cpp}
4972/// MyClass(UserClass1*);
4973/// MyClass(UserClass2*);
4974/// MyClass(TRootIOCtor*);
4975/// MyClass(); // Or a constructor with all its arguments defaulted.
4976/// ~~~
4977
4978void *TClass::New(ENewType defConstructor, Bool_t quiet) const
4979{
4980 auto obj = NewObject(defConstructor, quiet);
4981 if (obj.GetPtr() && obj.GetAllocator()) {
4982 // Register the object for special handling in the destructor.
4983 RegisterAddressInRepository("TClass::New", obj.GetPtr(), this);
4984 }
4985 return obj.GetPtr();
4986}
4987
4988// See TClass:New
4989// returns a TClass::ObjectPtr which remembers if the object was allocated
4990// via a TStreamerInfo.
4991
4993{
4994 ObjectPtr p;
4995
4996 if (fNew) {
4997 // We have the new operator wrapper function,
4998 // so there is a dictionary and it was generated
4999 // by rootcint, so there should be a default
5000 // constructor we can call through the wrapper.
5001 {
5002 TClass__GetCallingNewRAII callingNew(defConstructor);
5003 p = fNew(nullptr);
5004 }
5005 if (!p && !quiet) {
5006 //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
5007 Error("New", "cannot create object of class %s", GetName());
5008 }
5009 } else if (HasInterpreterInfo()) {
5010 // We have the dictionary but do not have the
5011 // constructor wrapper, so the dictionary was
5012 // not generated by rootcint. Let's try to
5013 // create the object by having the interpreter
5014 // call the new operator, hopefully the class
5015 // library is loaded and there will be a default
5016 // constructor we can call.
5017 // [This is very unlikely to work, but who knows!]
5018 {
5019 TClass__GetCallingNewRAII callingNew(defConstructor);
5021 }
5022 if (!p && !quiet) {
5023 //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
5024 Error("New", "cannot create object of class %s", GetName());
5025 }
5026 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5027 // There is no dictionary at all, so this is an emulated
5028 // class; however we do have the services of a collection proxy,
5029 // so this is an emulated STL class.
5030 {
5031 TClass__GetCallingNewRAII callingNew(defConstructor);
5033 }
5034 if (!p && !quiet) {
5035 //Error("New", "cannot create object of class %s version %d", GetName(), fClassVersion);
5036 Error("New", "cannot create object of class %s", GetName());
5037 }
5038 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5039 // There is no dictionary at all and we do not have
5040 // the services of a collection proxy available, so
5041 // use the streamer info to approximate calling a
5042 // constructor (basically we just make sure that the
5043 // pointer data members are null, unless they are marked
5044 // as preallocated with the "->" comment, in which case
5045 // we default-construct an object to point at).
5046
5047 // Do not register any TObject's that we create
5048 // as a result of creating this object.
5049 // FIXME: Why do we do this?
5050 // FIXME: Partial Answer: Is this because we may never actually deregister them???
5051
5052 Bool_t statsave = GetObjectStat();
5053 if(statsave) {
5055 }
5057 if (!sinfo) {
5058 if (!quiet)
5059 Error("New", "Cannot construct class '%s' version %d, no streamer info available!", GetName(), fClassVersion);
5060 return nullptr;
5061 }
5062
5063 {
5064 TClass__GetCallingNewRAII callingNew(defConstructor);
5065 p = { sinfo->New(), sinfo};
5066 }
5067
5068 // FIXME: Mistake? See note above at the GetObjectStat() call.
5069 // Allow TObject's to be registered again.
5070 if(statsave) {
5071 SetObjectStat(statsave);
5072 }
5073
5074 if (!p) {
5075 Error("New", "Failed to construct class '%s' using streamer info", GetName());
5076 }
5077
5078 return p;
5079 } else {
5080 Fatal("New", "This cannot happen!");
5081 }
5082
5083 return p;
5084}
5085
5086////////////////////////////////////////////////////////////////////////////////
5087/// Return a pointer to a newly allocated object of this class.
5088/// The class must have a default constructor. For meaning of
5089/// defConstructor, see TClass::IsCallingNew().
5090
5091void *TClass::New(void *arena, ENewType defConstructor) const
5092{
5093 auto obj = NewObject(arena, defConstructor);
5094 if (obj.GetPtr() && obj.GetAllocator()) {
5095 // Register the object for special handling in the destructor.
5096 RegisterAddressInRepository("TClass::New with placement", obj.GetPtr(), this);
5097 }
5098 return obj.GetPtr();
5099}
5100
5101////////////////////////////////////////////////////////////////////////////////
5102/// Return a pointer to a newly allocated object of this class.
5103/// The class must have a default constructor. For meaning of
5104/// defConstructor, see TClass::IsCallingNew().
5105
5106TClass::ObjectPtr TClass::NewObject(void *arena, ENewType defConstructor) const
5107{
5108 ObjectPtr p;
5109
5110 if (fNew) {
5111 // We have the new operator wrapper function,
5112 // so there is a dictionary and it was generated
5113 // by rootcint, so there should be a default
5114 // constructor we can call through the wrapper.
5115 {
5116 TClass__GetCallingNewRAII callingNew(defConstructor);
5117 p = fNew(arena);
5118 }
5119 if (!p) {
5120 Error("New with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
5121 }
5122 } else if (HasInterpreterInfo()) {
5123 // We have the dictionary but do not have the
5124 // constructor wrapper, so the dictionary was
5125 // not generated by rootcint. Let's try to
5126 // create the object by having the interpreter
5127 // call the new operator, hopefully the class
5128 // library is loaded and there will be a default
5129 // constructor we can call.
5130 // [This is very unlikely to work, but who knows!]
5131 {
5132 TClass__GetCallingNewRAII callingNew(defConstructor);
5133 p = gCling->ClassInfo_New(GetClassInfo(),arena);
5134 }
5135 if (!p) {
5136 Error("New with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
5137 }
5138 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5139 // There is no dictionary at all, so this is an emulated
5140 // class; however we do have the services of a collection proxy,
5141 // so this is an emulated STL class.
5142 {
5143 TClass__GetCallingNewRAII callingNew(defConstructor);
5144 p = fCollectionProxy->NewObject(arena);
5145 }
5146 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5147 // There is no dictionary at all and we do not have
5148 // the services of a collection proxy available, so
5149 // use the streamer info to approximate calling a
5150 // constructor (basically we just make sure that the
5151 // pointer data members are null, unless they are marked
5152 // as preallocated with the "->" comment, in which case
5153 // we default-construct an object to point at).
5154
5155 // ???BUG??? ???WHY???
5156 // Do not register any TObject's that we create
5157 // as a result of creating this object.
5158 Bool_t statsave = GetObjectStat();
5159 if(statsave) {
5161 }
5162
5164 if (!sinfo) {
5165 Error("New with placement", "Cannot construct class '%s' version %d at address %p, no streamer info available!", GetName(), fClassVersion, arena);
5166 return nullptr;
5167 }
5168
5169 {
5170 TClass__GetCallingNewRAII callingNew(defConstructor);
5171 p = { sinfo->New(arena), sinfo };
5172 }
5173
5174 // ???BUG???
5175 // Allow TObject's to be registered again.
5176 if(statsave) {
5177 SetObjectStat(statsave);
5178 }
5179
5180 } else {
5181 Error("New with placement", "This cannot happen!");
5182 }
5183
5184 return p;
5185}
5186
5187////////////////////////////////////////////////////////////////////////////////
5188/// Return a pointer to a newly allocated array of objects
5189/// of this class.
5190/// The class must have a default constructor. For meaning of
5191/// defConstructor, see TClass::IsCallingNew().
5192
5193void *TClass::NewArray(Long_t nElements, ENewType defConstructor) const
5194{
5195 auto obj = NewObjectArray(nElements, defConstructor);
5196 if (obj.GetPtr() && obj.GetAllocator()) {
5197 // Register the object for special handling in the destructor.
5198 RegisterAddressInRepository("TClass::NewArray", obj.GetPtr(), this);
5199 }
5200 return obj.GetPtr();
5201}
5202
5203////////////////////////////////////////////////////////////////////////////////
5204/// Return a pointer to a newly allocated array of objects
5205/// of this class.
5206/// The class must have a default constructor. For meaning of
5207/// defConstructor, see TClass::IsCallingNew().
5208
5210{
5211 ObjectPtr p;
5212
5213 if (fNewArray) {
5214 // We have the new operator wrapper function,
5215 // so there is a dictionary and it was generated
5216 // by rootcint, so there should be a default
5217 // constructor we can call through the wrapper.
5218 {
5219 TClass__GetCallingNewRAII callingNew(defConstructor);
5220 p = fNewArray(nElements, nullptr);
5221 }
5222 if (!p) {
5223 Error("NewArray", "cannot create object of class %s version %d", GetName(), fClassVersion);
5224 }
5225 } else if (HasInterpreterInfo()) {
5226 // We have the dictionary but do not have the
5227 // constructor wrapper, so the dictionary was
5228 // not generated by rootcint. Let's try to
5229 // create the object by having the interpreter
5230 // call the new operator, hopefully the class
5231 // library is loaded and there will be a default
5232 // constructor we can call.
5233 // [This is very unlikely to work, but who knows!]
5234 {
5235 TClass__GetCallingNewRAII callingNew(defConstructor);
5236 p = gCling->ClassInfo_New(GetClassInfo(),nElements);
5237 }
5238 if (!p) {
5239 Error("NewArray", "cannot create object of class %s version %d", GetName(), fClassVersion);
5240 }
5241 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5242 // There is no dictionary at all, so this is an emulated
5243 // class; however we do have the services of a collection proxy,
5244 // so this is an emulated STL class.
5245 {
5246 TClass__GetCallingNewRAII callingNew(defConstructor);
5247 p = fCollectionProxy->NewObjectArray(nElements);
5248 }
5249 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5250 // There is no dictionary at all and we do not have
5251 // the services of a collection proxy available, so
5252 // use the streamer info to approximate calling a
5253 // constructor (basically we just make sure that the
5254 // pointer data members are null, unless they are marked
5255 // as preallocated with the "->" comment, in which case
5256 // we default-construct an object to point at).
5257
5258 // ???BUG??? ???WHY???
5259 // Do not register any TObject's that we create
5260 // as a result of creating this object.
5261 Bool_t statsave = GetObjectStat();
5262 if(statsave) {
5264 }
5265
5267 if (!sinfo) {
5268 Error("NewArray", "Cannot construct class '%s' version %d, no streamer info available!", GetName(), fClassVersion);
5269 return nullptr;
5270 }
5271
5272 {
5273 TClass__GetCallingNewRAII callingNew(defConstructor);
5274 p = { sinfo->NewArray(nElements), sinfo };
5275 }
5276
5277 // ???BUG???
5278 // Allow TObject's to be registered again.
5279 if(statsave) {
5280 SetObjectStat(statsave);
5281 }
5282
5283 } else {
5284 Error("NewArray", "This cannot happen!");
5285 }
5286
5287 return p;
5288}
5289
5290////////////////////////////////////////////////////////////////////////////////
5291/// Return a pointer to a newly allocated object of this class.
5292/// The class must have a default constructor. For meaning of
5293/// defConstructor, see TClass::IsCallingNew().
5294
5295void *TClass::NewArray(Long_t nElements, void *arena, ENewType defConstructor) const
5296{
5297 auto obj = NewObjectArray(nElements, arena, defConstructor);
5298 if (obj.GetPtr() && obj.GetAllocator()) {
5299 // Register the object for special handling in the destructor.
5300 RegisterAddressInRepository("TClass::NewArray with placement", obj.GetPtr(), this);
5301 }
5302 return obj.GetPtr();
5303}
5304
5305////////////////////////////////////////////////////////////////////////////////
5306/// Return a pointer to a newly allocated object of this class.
5307/// The class must have a default constructor. For meaning of
5308/// defConstructor, see TClass::IsCallingNew().
5309
5310TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, void *arena, ENewType defConstructor) const
5311{
5312 ObjectPtr p;
5313
5314 if (fNewArray) {
5315 // We have the new operator wrapper function,
5316 // so there is a dictionary and it was generated
5317 // by rootcint, so there should be a default
5318 // constructor we can call through the wrapper.
5319 {
5320 TClass__GetCallingNewRAII callingNew(defConstructor);
5321 p = fNewArray(nElements, arena);
5322 }
5323 if (!p) {
5324 Error("NewArray with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
5325 }
5326 } else if (HasInterpreterInfo()) {
5327 // We have the dictionary but do not have the constructor wrapper,
5328 // so the dictionary was not generated by rootcint (it was made either
5329 // by cint or by some external mechanism). Let's try to create the
5330 // object by having the interpreter call the new operator, either the
5331 // class library is loaded and there is a default constructor we can
5332 // call, or the class is interpreted and we will call the default
5333 // constructor that way, or no default constructor is available and
5334 // we fail.
5335 {
5336 TClass__GetCallingNewRAII callingNew(defConstructor);
5337 p = gCling->ClassInfo_New(GetClassInfo(),nElements, arena);
5338 }
5339 if (!p) {
5340 Error("NewArray with placement", "cannot create object of class %s version %d at address %p", GetName(), fClassVersion, arena);
5341 }
5342 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5343 // There is no dictionary at all, so this is an emulated
5344 // class; however we do have the services of a collection proxy,
5345 // so this is an emulated STL class.
5346 {
5347 TClass__GetCallingNewRAII callingNew(defConstructor);
5348 p = fCollectionProxy->NewObjectArray(nElements, arena);
5349 }
5350 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5351 // There is no dictionary at all and we do not have
5352 // the services of a collection proxy available, so
5353 // use the streamer info to approximate calling a
5354 // constructor (basically we just make sure that the
5355 // pointer data members are null, unless they are marked
5356 // as preallocated with the "->" comment, in which case
5357 // we default-construct an object to point at).
5358
5359 // ???BUG??? ???WHY???
5360 // Do not register any TObject's that we create
5361 // as a result of creating this object.
5362 Bool_t statsave = GetObjectStat();
5363 if(statsave) {
5365 }
5366
5368 if (!sinfo) {
5369 Error("NewArray with placement", "Cannot construct class '%s' version %d at address %p, no streamer info available!", GetName(), fClassVersion, arena);
5370 return nullptr;
5371 }
5372
5373 {
5374 TClass__GetCallingNewRAII callingNew(defConstructor);
5375 p = { sinfo->NewArray(nElements, arena), sinfo };
5376 }
5377
5378 // ???BUG???
5379 // Allow TObject's to be registered again.
5380 if(statsave) {
5381 SetObjectStat(statsave);
5382 }
5383
5385 // We always register emulated objects, we need to always
5386 // use the streamer info to destroy them.
5387 }
5388
5389 return p;
5390 } else {
5391 Error("NewArray with placement", "This cannot happen!");
5392 }
5393
5394 return p;
5395}
5396
5397////////////////////////////////////////////////////////////////////////////////
5398/// Explicitly call destructor for object.
5399
5400void TClass::Destructor(void *obj, Bool_t dtorOnly)
5401{
5402 // Do nothing if passed a null pointer.
5403 if (obj == nullptr) return;
5404
5405 void* p = obj;
5406
5407 if (dtorOnly && fDestructor) {
5408 // We have the destructor wrapper, use it.
5409 fDestructor(p);
5410 } else if ((!dtorOnly) && fDelete) {
5411 // We have the delete wrapper, use it.
5412 fDelete(p);
5413 } else if (HasInterpreterInfo()) {
5414 // We have the dictionary but do not have the
5415 // destruct/delete wrapper, so the dictionary was
5416 // not generated by rootcint (it could have been
5417 // created by cint or by some external mechanism).
5418 // Let's have the interpreter call the destructor,
5419 // either the code will be in a loaded library,
5420 // or it will be interpreted, otherwise we fail
5421 // because there is no destructor code at all.
5422 if (dtorOnly) {
5424 } else {
5426 }
5427 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5428 // There is no dictionary at all, so this is an emulated
5429 // class; however we do have the services of a collection proxy,
5430 // so this is an emulated STL class.
5431 GetCollectionProxy()->Destructor(p, dtorOnly);
5432 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5433 // There is no dictionary at all and we do not have
5434 // the services of a collection proxy available, so
5435 // use the streamer info to approximate calling a
5436 // destructor.
5437
5438 Bool_t inRepo = kTRUE;
5439 Bool_t currentVersion = kFALSE;
5440
5441 // Was this object allocated through TClass?
5442 Version_t objVer = -1;
5443 {
5445 RepoCont_t::iterator iter = fObjectVersionRepository.find(p);
5446 if (iter == fObjectVersionRepository.end()) {
5447 // No, it wasn't, skip special version handling.
5448 //Error("Destructor2", "Attempt to delete unregistered object of class '%s' at address %p!", GetName(), p);
5449 inRepo = kFALSE;
5450 } else {
5451 //objVer = iter->second;
5452 for (; (iter != fObjectVersionRepository.end()) && (iter->first == p); ++iter) {
5453 objVer = iter->second;
5454 if (objVer == fClassVersion) {
5455 currentVersion = kTRUE;
5456 break;
5457 }
5458 }
5459 }
5460 }
5461
5462 if (!inRepo || currentVersion) {
5463 // The object was allocated using code for the same class version
5464 // as is loaded now. We may proceed without worry.
5466 if (si) {
5467 si->Destructor(p, dtorOnly);
5468 } else {
5469 Error("Destructor", "No streamer info available for class '%s' version %d at address %p, cannot destruct emulated object!", GetName(), fClassVersion, p);
5470 Error("Destructor", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
5472 for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
5473 Error("Destructor", "fStreamerInfo->At(%d): %p", i, fStreamerInfo->At(i));
5474 if (fStreamerInfo->At(i) != nullptr) {
5475 Error("Destructor", "Doing Dump() ...");
5477 }
5478 }
5479 }
5480 } else {
5481 // The loaded class version is not the same as the version of the code
5482 // which was used to allocate this object. The best we can do is use
5483 // the TVirtualStreamerInfo to try to free up some of the allocated memory.
5485 if (si) {
5486 si->Destructor(p, dtorOnly);
5487 } else {
5488 Error("Destructor", "No streamer info available for class '%s' version %d, cannot destruct object at addr: %p", GetName(), objVer, p);
5489 Error("Destructor", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
5491 for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
5492 Error("Destructor2", "fStreamerInfo->At(%d): %p", i, fStreamerInfo->At(i));
5493 if (fStreamerInfo->At(i) != nullptr) {
5494 // Do some debugging output.
5495 Error("Destructor2", "Doing Dump() ...");
5497 }
5498 }
5499 }
5500 }
5501
5502 if (inRepo && p) {
5503 UnregisterAddressInRepository("TClass::Destructor",p,this);
5504 }
5505 } else {
5506 Error("Destructor", "This cannot happen! (class %s)", GetName());
5507 }
5508}
5509
5510////////////////////////////////////////////////////////////////////////////////
5511/// Explicitly call destructor for object.
5512
5514{
5515 // Do nothing if passed a null pointer.
5516 if (obj.GetPtr() == nullptr)
5517 return;
5518
5519 if (obj.GetAllocator()) {
5520 obj.GetAllocator()->Destructor(obj.GetPtr(), dtorOnly);
5521 } else {
5522 Destructor(obj.GetPtr(), dtorOnly);
5523 }
5524}
5525
5526////////////////////////////////////////////////////////////////////////////////
5527/// Explicitly call operator delete[] for an array.
5528
5529void TClass::DeleteArray(void *ary, Bool_t dtorOnly)
5530{
5531 // Do nothing if passed a null pointer.
5532 if (ary == nullptr) return;
5533
5534 // Make a copy of the address.
5535 void* p = ary;
5536
5537 if (fDeleteArray) {
5538 if (dtorOnly) {
5539 Error("DeleteArray", "Destructor only is not supported!");
5540 } else {
5541 // We have the array delete wrapper, use it.
5542 fDeleteArray(ary);
5543 }
5544 } else if (HasInterpreterInfo()) {
5545 // We have the dictionary but do not have the
5546 // array delete wrapper, so the dictionary was
5547 // not generated by rootcint. Let's try to
5548 // delete the array by having the interpreter
5549 // call the array delete operator, hopefully
5550 // the class library is loaded and there will be
5551 // a destructor we can call.
5552 gCling->ClassInfo_DeleteArray(GetClassInfo(),ary, dtorOnly);
5553 } else if (!HasInterpreterInfo() && fCollectionProxy) {
5554 // There is no dictionary at all, so this is an emulated
5555 // class; however we do have the services of a collection proxy,
5556 // so this is an emulated STL class.
5557 GetCollectionProxy()->DeleteArray(ary, dtorOnly);
5558 } else if (!HasInterpreterInfo() && !fCollectionProxy) {
5559 // There is no dictionary at all and we do not have
5560 // the services of a collection proxy available, so
5561 // use the streamer info to approximate calling the
5562 // array destructor.
5563
5564 Bool_t inRepo = kTRUE;
5565 Bool_t currentVersion = kFALSE;
5566
5567 // Was this array object allocated through TClass?
5568 Version_t objVer = -1;
5569 {
5571 RepoCont_t::iterator iter = fObjectVersionRepository.find(p);
5572 if (iter == fObjectVersionRepository.end()) {
5573 // No, it wasn't, we cannot know what to do.
5574 //Error("DeleteArray", "Attempt to delete unregistered array object, element type '%s', at address %p!", GetName(), p);
5575 inRepo = kFALSE;
5576 } else {
5577 for (; (iter != fObjectVersionRepository.end()) && (iter->first == p); ++iter) {
5578 objVer = iter->second;
5579 if (objVer == fClassVersion) {
5580 currentVersion = kTRUE;
5581 break;
5582 }
5583 }
5584 }
5585 }
5586
5587 if (!inRepo || currentVersion) {
5588 // The object was allocated using code for the same class version
5589 // as is loaded now. We may proceed without worry.
5591 if (si) {
5592 si->DeleteArray(ary, dtorOnly);
5593 } else {
5594 Error("DeleteArray", "No streamer info available for class '%s' version %d at address %p, cannot destruct object!", GetName(), fClassVersion, ary);
5595 Error("DeleteArray", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
5597 for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
5598 Error("DeleteArray", "fStreamerInfo->At(%d): %p", v, fStreamerInfo->At(i));
5599 if (fStreamerInfo->At(i)) {
5600 Error("DeleteArray", "Doing Dump() ...");
5602 }
5603 }
5604 }
5605 } else {
5606 // The loaded class version is not the same as the version of the code
5607 // which was used to allocate this array. The best we can do is use
5608 // the TVirtualStreamerInfo to try to free up some of the allocated memory.
5610 if (si) {
5611 si->DeleteArray(ary, dtorOnly);
5612 } else {
5613 Error("DeleteArray", "No streamer info available for class '%s' version %d at address %p, cannot destruct object!", GetName(), objVer, ary);
5614 Error("DeleteArray", "length of fStreamerInfo is %d", fStreamerInfo->GetSize());
5616 for (Int_t v = 0; v < fStreamerInfo->GetSize(); ++v, ++i) {
5617 Error("DeleteArray", "fStreamerInfo->At(%d): %p", v, fStreamerInfo->At(i));
5618 if (fStreamerInfo->At(i)) {
5619 // Print some debugging info.
5620 Error("DeleteArray", "Doing Dump() ...");
5622 }
5623 }
5624 }
5625 }
5626
5627 // Deregister the object for special handling in the destructor.
5628 if (inRepo && p) {
5629 UnregisterAddressInRepository("TClass::DeleteArray",p,this);
5630 }
5631 } else {
5632 Error("DeleteArray", "This cannot happen! (class '%s')", GetName());
5633 }
5634}
5635
5636////////////////////////////////////////////////////////////////////////////////
5637/// Explicitly call operator delete[] for an array.
5638
5640{
5641 // Do nothing if passed a null pointer.
5642 if (obj.GetPtr() == nullptr) return;
5643
5644 if (obj.GetAllocator()) {
5645 obj.GetAllocator()->DeleteArray(obj.GetPtr(), dtorOnly);
5646 } else {
5647 DeleteArray(obj.GetPtr(), dtorOnly);
5648 }
5649}
5650
5651////////////////////////////////////////////////////////////////////////////////
5652/// Set the splitability of this class:
5653/// - -1: Use the default calculation
5654/// - 0: Disallow splitting
5655/// - 1: Always allow splitting.
5656/// - 2: Disallow splitting of the class and splitting of any it's derived classes.
5657
5659{
5660 fCanSplit = splitmode;
5661}
5662
5663////////////////////////////////////////////////////////////////////////////////
5664/// Private function. Set the class version for the 'class' represented by
5665/// this TClass object. See the public interface:
5666/// ROOT::ResetClassVersion
5667/// defined in TClassTable.cxx
5668///
5669/// Note on class version numbers:
5670/// - If no class number has been specified, TClass::GetVersion will return -1
5671/// - The Class Version 0 request the whole object to be transient
5672/// - The Class Version 1, unless specified via ClassDef indicates that the
5673/// I/O should use the TClass checksum to distinguish the layout of the class
5674
5676{
5677 fClassVersion = version;
5678 fCurrentInfo = nullptr;
5679}
5680
5681////////////////////////////////////////////////////////////////////////////////
5682/// Determine and set pointer to current TVirtualStreamerInfo
5683
5685{
5686 if(!fCurrentInfo.load()) {
5689 }
5690 return fCurrentInfo;
5691}
5692
5693////////////////////////////////////////////////////////////////////////////////
5694/// Set pointer to current TVirtualStreamerInfo
5695
5697{
5698 fCurrentInfo = info;
5699}
5700
5701////////////////////////////////////////////////////////////////////////////////
5702/// Return size of object of this class.
5703
5705{
5706 if (fSizeof!=-1) return fSizeof;
5709 return GetStreamerInfo()->GetSize();
5710}
5711
5712////////////////////////////////////////////////////////////////////////////////
5713/// Load class description from I/O buffer and return class object.
5714
5716{
5717 UInt_t maxsize = 256;
5718 char *s = new char[maxsize];
5719
5720 Int_t pos = b.Length();
5721
5722 b.ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end.
5723 while (strlen(s) == (maxsize - 1)) {
5724 // The classname is too large, try again with a large buffer.
5725 b.SetBufferOffset(pos);
5726 maxsize = 2*maxsize;
5727 delete [] s;
5728 s = new char[maxsize];
5729 b.ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end.
5730 }
5731
5732 TClass *cl = TClass::GetClass(s, kTRUE);
5733 if (!cl)
5734 ::Error("TClass::Load", "dictionary of class %s not found", s);
5735
5736 delete [] s;
5737 return cl;
5738}
5739
5740////////////////////////////////////////////////////////////////////////////////
5741/// Helper function used by TClass::GetClass().
5742/// This function attempts to load the dictionary for 'classname'
5743/// either from the TClassTable or from the list of generator.
5744/// If silent is 'true', do not warn about missing dictionary for the class.
5745/// (typically used for class that are used only for transient members)
5746///
5747/// The 'requestedname' is expected to be already normalized.
5748
5749TClass *TClass::LoadClass(const char *requestedname, Bool_t silent)
5750{
5751 // This function does not (and should not) attempt to check in the
5752 // list of loaded classes or in the typedef.
5753
5755
5756 TClass *result = LoadClassDefault(requestedname, silent);
5757
5758 if (result) return result;
5759 else return LoadClassCustom(requestedname,silent);
5760}
5761
5762////////////////////////////////////////////////////////////////////////////////
5763/// Helper function used by TClass::GetClass().
5764/// This function attempts to load the dictionary for 'classname' from
5765/// the TClassTable or the autoloader.
5766/// If silent is 'true', do not warn about missing dictionary for the class.
5767/// (typically used for class that are used only for transient members)
5768///
5769/// The 'requestedname' is expected to be already normalized.
5770
5771TClass *TClass::LoadClassDefault(const char *requestedname, Bool_t /* silent */)
5772{
5773 // This function does not (and should not) attempt to check in the
5774 // list of loaded classes or in the typedef.
5775
5776 DictFuncPtr_t dict = TClassTable::GetDictNorm(requestedname);
5777
5778 if (!dict) {
5779 if (gInterpreter->AutoLoad(requestedname,kTRUE)) {
5780 dict = TClassTable::GetDictNorm(requestedname);
5781 }
5782 }
5783
5784 if (dict) {
5785 TClass *ncl = (dict)();
5786 if (ncl) ncl->PostLoadCheck();
5787 return ncl;
5788 }
5789 return nullptr;
5790}
5791
5792////////////////////////////////////////////////////////////////////////////////
5793/// Helper function used by TClass::GetClass().
5794/// This function attempts to load the dictionary for 'classname'
5795/// from the list of generator.
5796/// If silent is 'true', do not warn about missing dictionary for the class.
5797/// (typically used for class that are used only for transient members)
5798///
5799/// The 'requestedname' is expected to be already normalized.
5800
5801TClass *TClass::LoadClassCustom(const char *requestedname, Bool_t silent)
5802{
5803 // This function does not (and should not) attempt to check in the
5804 // list of loaded classes or in the typedef.
5805
5806 TIter next(gROOT->GetListOfClassGenerators());
5807 TClassGenerator *gen;
5808 while ((gen = (TClassGenerator*) next())) {
5809 TClass *cl = gen->GetClass(requestedname, kTRUE, silent);
5810 if (cl) {
5811 cl->PostLoadCheck();
5812 return cl;
5813 }
5814 }
5815 return nullptr;
5816}
5817
5818////////////////////////////////////////////////////////////////////////////////
5819/// Try to load the ClassInfo if available. This function may require parsing
5820/// the header file and/or loading data from the clang pcm. If further calls to
5821/// this function cannot affect the value of fClassInfo, fCanLoadClassInfo is set
5822/// to false.
5823
5825{
5827
5828 // Return if another thread already loaded the info
5829 // while we were waiting for the lock
5831 return;
5832
5833 bool autoParse = !gInterpreter->IsAutoParsingSuspended();
5834
5835 if (autoParse)
5836 gInterpreter->AutoParse(GetName());
5837
5838 if (!fClassInfo)
5839 gInterpreter->SetClassInfo(const_cast<TClass *>(this));
5840
5841 if (autoParse && !fClassInfo) {
5842 if (fImplFileLine == -1 && fClassVersion == 0) {
5843 // We have a 'transient' class with a ClassDefInline and apparently no interpreter
5844 // information. Since it is transient, it is more than likely that the lack
5845 // will be harmles.
5846 } else {
5847 ::Error("TClass::LoadClassInfo", "no interpreter information for class %s is available"
5848 " even though it has a TClass initialization routine.",
5849 fName.Data());
5850 }
5851 return;
5852 }
5853
5854 fCanLoadClassInfo = false;
5855}
5856
5857////////////////////////////////////////////////////////////////////////////////
5858/// Store class description on I/O buffer.
5859
5861{
5862 b.WriteString(GetName());
5863}
5864
5865////////////////////////////////////////////////////////////////////////////////
5866/// Global function called by a class' static Dictionary() method
5867/// (see the ClassDef macro).
5868
5870 const std::type_info &info, TVirtualIsAProxy *isa,
5871 const char *dfil, const char *ifil,
5872 Int_t dl, Int_t il)
5873{
5874 // When called via TMapFile (e.g. Update()) make sure that the dictionary
5875 // gets allocated on the heap and not in the mapped file.
5876 TMmallocDescTemp setreset;
5877 return new TClass(cname, id, info, isa, dfil, ifil, dl, il);
5878}
5879
5880////////////////////////////////////////////////////////////////////////////////
5881/// Global function called by a class' static Dictionary() method
5882/// (see the ClassDef macro).
5883
5885 const char *dfil, const char *ifil,
5886 Int_t dl, Int_t il)
5887{
5888 // When called via TMapFile (e.g. Update()) make sure that the dictionary
5889 // gets allocated on the heap and not in the mapped file.
5890 TMmallocDescTemp setreset;
5891 return new TClass(cname, id, dfil, ifil, dl, il);
5892}
5893
5894////////////////////////////////////////////////////////////////////////////////
5895/// Static method returning the defConstructor flag passed to TClass::New().
5896/// New type is either:
5897/// - TClass::kRealNew - when called via plain new
5898/// - TClass::kClassNew - when called via TClass::New()
5899/// - TClass::kDummyNew - when called via TClass::New() but object is a dummy,
5900/// in which case the object ctor might take short cuts
5901
5903{
5904 return TClass__GetCallingNew();
5905}
5906
5907////////////////////////////////////////////////////////////////////////////////
5908/// Return true if the shared library of this class is currently in the a
5909/// process's memory. Return false, after the shared library has been
5910/// unloaded or if this is an 'emulated' class created from a file's StreamerInfo.
5911
5913{
5914 return fState == kHasTClassInit;
5915}
5916
5917////////////////////////////////////////////////////////////////////////////////
5918/// Returns true if this class inherits from TObject and if the start of
5919/// the TObject parts is at the very beginning of the objects.
5920/// Concretely this means that the following code is proper for this class:
5921/// ~~~ {.cpp}
5922/// ThisClass *ptr;
5923/// void *void_ptr = (void)ptr;
5924/// TObject *obj = (TObject*)void_ptr;
5925/// ~~~
5926/// This code would be wrong if 'ThisClass' did not inherit 'first' from
5927/// TObject.
5928
5930{
5931 if (fProperty==(-1)) Property();
5932 return TestBit(kStartWithTObject);
5933}
5934
5935////////////////////////////////////////////////////////////////////////////////
5936/// Return kTRUE is the class inherits from TObject.
5937
5939{
5940 if (fProperty==(-1)) Property();
5941 return TestBit(kIsTObject);
5942}
5943
5944////////////////////////////////////////////////////////////////////////////////
5945/// Return kTRUE is the class is Foreign (the class does not have a Streamer method).
5946
5948{
5949 if (fProperty==(-1)) Property();
5950 // If the property are not set and the class is a pair, hard code that
5951 // it is a unversioned/Foreign class.
5952 return TestBit(kIsForeign);
5953}
5954
5955////////////////////////////////////////////////////////////////////////////////
5956/// Do the initialization that can only be done after the CINT dictionary has
5957/// been fully populated and can not be delayed efficiently.
5958
5960{
5961 // In the case of a Foreign class (loaded class without a Streamer function)
5962 // we reset fClassVersion to be -1 so that the current TVirtualStreamerInfo will not
5963 // be confused with a previously loaded streamerInfo.
5964
5965 if (IsLoaded() && HasInterpreterInfo() && fClassVersion==1 /*&& fStreamerInfo
5966 && fStreamerInfo->At(1)*/ && IsForeign() )
5967 {
5968 SetClassVersion(-1);
5969 }
5970 // Note: We are careful to check the class version first because checking
5971 // for foreign can trigger an AutoParse.
5972 else if (IsLoaded() && HasDataMemberInfo() && fStreamerInfo && ((fClassVersion > 1) || !IsForeign()))
5973 {
5975
5977 // Here we need to check whether this TVirtualStreamerInfo (which presumably has been
5978 // loaded from a file) is consistent with the definition in the library we just loaded.
5979 // BuildCheck is not appropriate here since it check a streamerinfo against the
5980 // 'current streamerinfo' which, at time point, would be the same as 'info'!
5981 if (info && GetListOfDataMembers() && !GetCollectionProxy()
5982 && (info->GetCheckSum()!=GetCheckSum() && !info->CompareContent(this,nullptr,kFALSE,kFALSE, nullptr) && !(MatchLegacyCheckSum(info->GetCheckSum()))))
5983 {
5984 Bool_t warn = ! TestBit(kWarned);
5985 if (warn && info->GetOldVersion()<=2) {
5986 // Names of STL base classes was modified in vers==3. Allocators removed
5987 //
5988 TIter nextBC(GetListOfBases());
5989 TBaseClass *bc;
5990 while ((bc=(TBaseClass*)nextBC()))
5991 {if (TClassEdit::IsSTLCont(bc->GetName())) warn = kFALSE;}
5992 }
5993
5994 if (warn) {
5995 if (info->GetOnFileClassVersion()==1 && fClassVersion>1) {
5996 Warning("PostLoadCheck","\n\
5997 The class %s transitioned from not having a specified class version\n\
5998 to having a specified class version (the current class version is %d).\n\
5999 However too many different non-versioned layouts of the class have\n\
6000 already been loaded so far. To work around this problem you can\n\
6001 load fewer 'old' file in the same ROOT session or load the C++ library\n\
6002 describing the class %s before opening the files or increase the version\n\
6003 number of the class for example ClassDef(%s,%d).\n\
6004 Do not try to write objects with the current class definition,\n\
6005 the files might not be readable.\n",
6007 } else {
6008 Warning("PostLoadCheck","\n\
6009 The StreamerInfo version %d for the class %s which was read\n\
6010 from a file previously opened has the same version as the active class\n\
6011 but a different checksum. You should update the version to ClassDef(%s,%d).\n\
6012 Do not try to write objects with the current class definition,\n\
6013 the files will not be readable.\n"
6015 }
6016 info->CompareContent(this,nullptr,kTRUE,kTRUE,nullptr);
6017 SetBit(kWarned);
6018 }
6019 }
6020 }
6021 if (fCollectionProxy) {
6022 // Update the related pair's TClass if it has already been created.
6023 size_t noffset = 0;
6024 if (strncmp(GetName(), "map<", 4) == 0)
6025 noffset = 3;
6026 else if (strncmp(GetName(), "multimap<", 9) == 0)
6027 noffset = 8;
6028 else if (strncmp(GetName(), "unordered_map<", 14) == 0)
6029 noffset = 13;
6030 else if (strncmp(GetName(), "unordered_multimap<", 19) == 0)
6031 noffset = 18;
6032 if (noffset) {
6033 std::string pairname("pair");
6034 pairname.append(GetName() + noffset);
6035 auto pcl = TClass::GetClass(pairname.c_str(), false, false);
6036 if ( pcl && !pcl->IsLoaded() && !pcl->IsSyntheticPair() )
6037 {
6039
6041 TIter nextClass(gROOT->GetListOfClasses());
6042 while (auto acl = (TClass*)nextClass()) {
6043 if (acl == this) continue;
6044 if (acl->fCollectionProxy && acl->fCollectionProxy->GetValueClass() == pcl) {
6045 acl->fCollectionProxy->Reset();
6046 }
6047 }
6048
6049 TIter next(pcl->GetStreamerInfos());
6050 while (auto info = (TVirtualStreamerInfo*)next()) {
6051 if (info->IsBuilt()) {
6052 info->Clear("build");
6053 info->BuildOld();
6054 }
6055 }
6057 }
6058 }
6059 }
6060}
6061
6062////////////////////////////////////////////////////////////////////////////////
6063/// Returns the properties of the TClass as a bit field stored as a `Long_t` value.
6064///
6065/// The bit values used for the return value are defined in the enum EProperty (in TDictionary.h)
6066///
6067/// Also sets `TObject::fBits` and `fStreamerType` to cache information about the
6068/// class. The bits stored in `TObject::fBits` are
6069/// ~~~ {.cpp}
6070/// kIsTObject : the class inherits from TObject
6071/// kStartWithTObject: TObject is the left-most class in the inheritance tree
6072/// kIsForeign : the class doe not have a Streamer method
6073/// ~~~
6074/// The value of `fStreamerType` are
6075/// ~~~ {.cpp}
6076/// kTObject : the class inherits from TObject
6077/// kForeign : the class does not have a Streamer method
6078/// kInstrumented: the class does have a Streamer method
6079/// kExternal: the class has a free standing way of streaming itself
6080/// kEmulatedStreamer: the class is missing its shared library.
6081/// ~~~
6082///
6083/// Implementation note: the data member fProperty has the value -1
6084/// until it is initialized.
6085
6087{
6088 // Check if we can return without taking the lock,
6089 // this is valid since fProperty is atomic and set as
6090 // the last operation before return.
6091 if (fProperty!=(-1)) return fProperty;
6092
6094
6095 // Check if another thread set fProperty while we
6096 // were waiting.
6097 if (fProperty!=(-1)) return fProperty;
6098
6099 // Avoid asking about the class when it is still building
6100 if (TestBit(kLoading)) return fProperty;
6101
6102 // When called via TMapFile (e.g. Update()) make sure that the dictionary
6103 // gets allocated on the heap and not in the mapped file.
6104 TMmallocDescTemp setreset;
6105
6106 TClass *kl = const_cast<TClass*>(this);
6107
6110
6112 kl->SetBit(kIsTObject);
6113
6114 // Is it DIRECT inheritance from TObject?
6116 if (delta==0) kl->SetBit(kStartWithTObject);
6117
6118 kl->fStreamerType = kTObject;
6120 }
6121
6122 if (HasInterpreterInfo()) {
6123
6124 // This code used to use ClassInfo_Has|IsValidMethod but since v6
6125 // they return true if the routine is defined in the class or any of
6126 // its parent. We explicitly want to know whether the function is
6127 // defined locally.
6128 if (!const_cast<TClass*>(this)->GetClassMethodWithPrototype("Streamer","TBuffer&",kFALSE)) {
6129
6130 kl->SetBit(kIsForeign);
6131 kl->fStreamerType = kForeign;
6133
6134 } else if ( kl->fStreamerType == TClass::kDefault ) {
6135 if (kl->fConvStreamerFunc) {
6138 } else if (kl->fStreamerFunc) {
6141 } else {
6142 // We have an automatic streamer using the StreamerInfo .. no need to go through the
6143 // Streamer method function itself.
6146 }
6147 }
6148
6149 if (fStreamer) {
6152 }
6153
6154 if (const_cast<TClass *>(this)->GetClassMethodWithPrototype("Hash", "", kTRUE)) {
6156 }
6157
6158 if (GetClassInfo()) {
6159 // In the case where the TClass for one of ROOT's core class
6160 // (eg TClonesArray for map<int,TClonesArray*>) is requested
6161 // during the execution of rootcling, we could end up in a situation
6162 // where we should have the information (since TClonesArray has
6163 // a dictionary as part of libCore) but do not because the user
6164 // only include a forward declaration of TClonesArray and we do not
6165 // forcefully load the header file either (because the autoparsing
6166 // is intentionally disabled).
6168 // Must set this last since other threads may read fProperty
6169 // and think all test bits have been properly set.
6171 }
6172 } else {
6173
6174 if (fStreamer) {
6177 }
6178
6180 kl->SetStreamerImpl();
6181 // fProperty was *not* set so that it can be forced to be recalculated
6182 // next time.
6183 return 0;
6184 }
6185
6186 return fProperty;
6187}
6188
6189////////////////////////////////////////////////////////////////////////////////
6190/// Internal routine to set calculate the class properties that can only be
6191/// known at run-time, for example whether the Hash member function and the
6192/// destructor are consistent.
6193
6195{
6196 // For now, no need to lock this routines as fRuntimeProperties is
6197 // the only atomic set here and this is done at the end
6198 // and there is no downside if the execution is done twice.
6199
6200 // Note SetRuntimeProperties is set to const as it is technically
6201 // thread-safe.
6202
6203 UChar_t properties = static_cast<UChar_t>(ERuntimeProperties::kSet);
6204
6206 properties |= static_cast<UChar_t>(ERuntimeProperties::kConsistentHash);
6207
6208 const_cast<TClass *>(this)->fRuntimeProperties = properties;
6209}
6210
6211////////////////////////////////////////////////////////////////////////////////
6212/// Internal routine to set fStreamerImpl based on the value of
6213/// fStreamerType.
6214
6216{
6217 switch (fStreamerType) {
6221 case kInstrumented: {
6225 break;
6226 }
6227
6228 case kEmulatedStreamer: // intentional fall through
6229 case kForeign|kEmulatedStreamer: // intentional fall through
6234 default:
6235 Error("SetStreamerImpl","Unexpected value of fStreamerType: %d",fStreamerType);
6236 }
6237}
6238
6239
6240////////////////////////////////////////////////////////////////////////////////
6241/// Create the collection proxy object (and the streamer object) from
6242/// using the information in the TCollectionProxyInfo.
6243
6245{
6247
6248 delete fCollectionProxy;
6249
6250 // We can not use GetStreamerInfo() instead of TVirtualStreamerInfo::Factory()
6251 // because GetStreamerInfo call TStreamerInfo::Build which need to have fCollectionProxy
6252 // set correctly.
6253
6256
6257 AdoptStreamer(TVirtualStreamerInfo::Factory()->GenExplicitClassStreamer(info,this));
6258
6260 // Numeric Collections have implicit conversions:
6262 }
6263 fCanSplit = -1;
6264}
6265
6266////////////////////////////////////////////////////////////////////////////////
6267/// Change (i.e. set) the title of the TNamed.
6268
6269void TClass::SetContextMenuTitle(const char *title)
6270{
6271 fContextMenuTitle = title;
6272}
6273
6274////////////////////////////////////////////////////////////////////////////////
6275/// This function installs a global IsA function for this class.
6276/// The global IsA function will be used if there is no local IsA function (fIsA)
6277///
6278/// A global IsA function has the signature:
6279///
6280/// ~~~ {.cpp}
6281/// TClass *func( TClass *cl, const void *obj);
6282/// ~~~
6283///
6284/// 'cl' is a pointer to the TClass object that corresponds to the
6285/// 'pointer type' used to retrieve the value 'obj'
6286///
6287/// For example with:
6288/// ~~~ {.cpp}
6289/// TNamed * m = new TNamed("example","test");
6290/// TObject* o = m
6291/// ~~~
6292/// and
6293/// the global IsA function would be called with TObject::Class() as
6294/// the first parameter and the exact numerical value in the pointer
6295/// 'o'.
6296///
6297/// In other word, inside the global IsA function. it is safe to C-style
6298/// cast the value of 'obj' into a pointer to the class described by 'cl'.
6299
6301{
6302 fGlobalIsA = func;
6303}
6304
6305////////////////////////////////////////////////////////////////////////////////
6306/// Call this method to indicate that the shared library containing this
6307/// class's code has been removed (unloaded) from the process's memory
6308
6310{
6311 if (TestBit(kUnloaded) && !TestBit(kUnloading)) {
6312 // Don't redo the work.
6313 return;
6314 }
6316
6317 //R__ASSERT(fState == kLoaded);
6318 if (fState != kLoaded) {
6319 Fatal("SetUnloaded","The TClass for %s is being unloaded when in state %d\n",
6320 GetName(),(int)fState);
6321 }
6322
6324
6325 // Make sure SetClassInfo, re-calculated the state.
6327
6328 delete fIsA; fIsA = nullptr;
6329 // Disable the autoloader while calling SetClassInfo, to prevent
6330 // the library from being reloaded!
6331 {
6334 gInterpreter->SetClassInfo(this,kTRUE);
6335 }
6336 fDeclFileName = nullptr;
6337 fDeclFileLine = 0;
6338 fImplFileName = nullptr;
6339 fImplFileLine = 0;
6340 fTypeInfo = nullptr;
6341
6342 if (fMethod.load()) {
6343 (*fMethod).Unload();
6344 }
6345 if (fData.load()) {
6346 (*fData).Unload();
6347 }
6348 if (fUsingData.load()) {
6349 (*fUsingData).Unload();
6350 }
6351 if (fEnums.load()) {
6352 (*fEnums).Unload();
6353 }
6354
6355 if (fState <= kForwardDeclared && !fStreamerInfo->IsEmpty()) {
6356 fState = kEmulated;
6357 }
6358
6361}
6362
6363////////////////////////////////////////////////////////////////////////////////
6364/// Info is a string describing the names and types of attributes
6365/// written by the class Streamer function.
6366/// If info is an empty string (when called by TObject::StreamerInfo)
6367/// the default Streamer info string is build. This corresponds to
6368/// the case of an automatically generated Streamer.
6369/// In case of user defined Streamer function, it is the user responsibility
6370/// to implement a StreamerInfo function (override TObject::StreamerInfo).
6371/// The user must call IsA()->SetStreamerInfo(info) from this function.
6372
6373TVirtualStreamerInfo *TClass::SetStreamerInfo(Int_t /*version*/, const char * /*info*/)
6374{
6375 // info is specified, nothing to do, except that we should verify
6376 // that it contains a valid descriptor.
6377
6378/*
6379 TDataMember *dm;
6380 Int_t nch = info ? strlen(info) : 0;
6381 Bool_t update = kTRUE;
6382 if (nch != 0) {
6383 //decode strings like "TObject;TAttLine;fA;fB;Int_t i,j,k;"
6384 char *save, *temp, *blank, *colon, *comma;
6385 save = new char[10000];
6386 temp = save;
6387 strlcpy(temp,info,10000);
6388 //remove heading and trailing blanks
6389 while (*temp == ' ') temp++;
6390 while (save[nch-1] == ' ') {nch--; save[nch] = 0;}
6391 if (nch == 0) {delete [] save; return;}
6392 if (save[nch-1] != ';') {save[nch] = ';'; save[nch+1] = 0;}
6393 //remove blanks around , or ;
6394 while ((blank = strstr(temp,"; "))) strcpy(blank+1,blank+2);
6395 while ((blank = strstr(temp," ;"))) strcpy(blank, blank+1);
6396 while ((blank = strstr(temp,", "))) strcpy(blank+1,blank+2);
6397 while ((blank = strstr(temp," ,"))) strcpy(blank, blank+1);
6398 while ((blank = strstr(temp," "))) strcpy(blank, blank+1);
6399 //loop on tokens separated by ;
6400 char *final = new char[1000];
6401 char token[100];
6402 while ((colon=strchr(temp,';'))) {
6403 *colon = 0;
6404 strlcpy(token,temp,100);
6405 blank = strchr(token,' ');
6406 if (blank) {
6407 *blank = 0;
6408 if (!gROOT->GetType(token)) {
6409 Error("SetStreamerInfo","Illegal type: %s in %s",token,info);
6410 return;
6411 }
6412 while (blank) {
6413 strlcat(final,token,1000);
6414 strlcat(final," ",1000);
6415 comma = strchr(blank+1,','); if (comma) *comma=0;
6416 strlcat(final,blank+1,1000);
6417 strlcat(final,";",1000);
6418 blank = comma;
6419 }
6420
6421 } else {
6422 if (TClass::GetClass(token,update)) {
6423 //a class name
6424 strlcat(final,token,1000); strlcat(final,";",1000);
6425 } else {
6426 //a data member name
6427 dm = (TDataMember*)GetListOfDataMembers()->FindObject(token);
6428 if (dm) {
6429 strlcat(final,dm->GetFullTypeName(),1000);
6430 strlcat(final," ",1000);
6431 strlcat(final,token,1000); strlcat(final,";",1000);
6432 } else {
6433 Error("SetStreamerInfo","Illegal name: %s in %s",token,info);
6434 return;
6435 }
6436 }
6437 update = kFALSE;
6438 }
6439 temp = colon+1;
6440 if (*temp == 0) break;
6441 }
6442 //// fStreamerInfo = final;
6443 delete [] final;
6444 delete [] save;
6445 return;
6446 }
6447
6448 //info is empty. Let's build the default Streamer descriptor
6449
6450 char *temp = new char[10000];
6451 temp[0] = 0;
6452 char local[100];
6453
6454 //add list of base classes
6455 TIter nextb(GetListOfBases());
6456 TBaseClass *base;
6457 while ((base = (TBaseClass*) nextb())) {
6458 snprintf(local,100,"%s;",base->GetName());
6459 strlcat(temp,local,10000);
6460 }
6461
6462 //add list of data members and types
6463 TIter nextd(GetListOfDataMembers());
6464 while ((dm = (TDataMember *) nextd())) {
6465 if (dm->IsEnum()) continue;
6466 if (!dm->IsPersistent()) continue;
6467 Long_t property = dm->Property();
6468 if (property & kIsStatic) continue;
6469 TClass *acl = TClass::GetClass(dm->GetTypeName(),update);
6470 update = kFALSE;
6471 if (acl) {
6472 if (acl->GetClassVersion() == 0) continue;
6473 }
6474
6475 // dm->GetArrayIndex() returns an empty string if it does not
6476 // applies
6477 const char * index = dm->GetArrayIndex();
6478 if (strlen(index)==0)
6479 snprintf(local,100,"%s %s;",dm->GetFullTypeName(),dm->GetName());
6480 else
6481 snprintf(local,100,"%s %s[%s];",dm->GetFullTypeName(),dm->GetName(),index);
6482 strlcat(temp,local,10000);
6483 }
6484 //fStreamerInfo = temp;
6485 delete [] temp;
6486*/
6487 return nullptr;
6488}
6489
6490////////////////////////////////////////////////////////////////////////////////
6491/// Return true if the checksum passed as argument is one of the checksum
6492/// value produced by the older checksum calculation algorithm.
6493
6495{
6496 for(UInt_t i = 1; i < kLatestCheckSum; ++i) {
6497 if ( checksum == GetCheckSum( (ECheckSum) i ) ) return kTRUE;
6498 }
6499 return kFALSE;
6500}
6501
6502////////////////////////////////////////////////////////////////////////////////
6503/// Call GetCheckSum with validity check.
6504
6506{
6507 bool isvalid;
6508 return GetCheckSum(code,isvalid);
6509}
6510
6511////////////////////////////////////////////////////////////////////////////////
6512/// Return GetCheckSum(kCurrentCheckSum,isvalid);
6513
6515{
6516 return GetCheckSum(kCurrentCheckSum,isvalid);
6517}
6518
6519////////////////////////////////////////////////////////////////////////////////
6520/// Compute and/or return the class check sum.
6521///
6522/// isvalid is set to false, if the function is unable to calculate the
6523/// checksum.
6524///
6525/// The class ckecksum is used by the automatic schema evolution algorithm
6526/// to uniquely identify a class version.
6527/// The check sum is built from the names/types of base classes and
6528/// data members.
6529/// Original algorithm from Victor Perevovchikov (perev@bnl.gov).
6530///
6531/// The valid range of code is determined by ECheckSum.
6532///
6533/// - kNoEnum: data members of type enum are not counted in the checksum
6534/// - kNoRange: return the checksum of data members and base classes, not including the ranges and array size found in comments.
6535/// - kWithTypeDef: use the sugared type name in the calculation.
6536///
6537/// This is needed for backward compatibility.
6538///
6539/// WARNING: this function must be kept in sync with TStreamerInfo::GetCheckSum.
6540/// They are both used to handle backward compatibility and should both return the same values.
6541/// TStreamerInfo uses the information in TStreamerElement while TClass uses the information
6542/// from TClass::GetListOfBases and TClass::GetListOfDataMembers.
6543
6545{
6546 // fCheckSum is an atomic variable. Also once it has
6547 // transition from a zero Value it never changes. If two
6548 // thread reach past this if statement and calculated the
6549 // 'kLastestCheckSum', they will by definition obtain the
6550 // same value, so technically we could simply have:
6551 // if (fCheckSum && code == kCurrentCheckSum) return fCheckSum;
6552 // However save a little bit of barrier time by calling load()
6553 // only once.
6554
6555 isvalid = kTRUE;
6556
6557 UInt_t currentChecksum = fCheckSum.load();
6558 if (currentChecksum && code == kCurrentCheckSum) return currentChecksum;
6559
6561
6562 // kCurrentCheckSum (0) is the default parameter value and should be kept
6563 // for backward compatibility, too be able to use the inequality checks,
6564 // we need to set the code to the largest value.
6565 if (code == kCurrentCheckSum) code = kLatestCheckSum;
6566
6567 UInt_t id = 0;
6568
6569 int il;
6570 TString name = GetName();
6571 TString type;
6572 il = name.Length();
6573 for (int i=0; i<il; i++) id = id*3+name[i];
6574
6575 // Here we skip he base classes in case this is a pair or STL collection,
6576 // otherwise, on some STL implementations, it can happen that pair has
6577 // base classes which are an internal implementation detail.
6578 TList *tlb = ((TClass*)this)->GetListOfBases();
6579 if (tlb && !GetCollectionProxy() && !TClassEdit::IsStdPair(GetName())) {
6580 // Loop over bases if not a proxied collection or a pair
6581
6582 TIter nextBase(tlb);
6583
6584 TBaseClass *tbc=nullptr;
6585 while((tbc=(TBaseClass*)nextBase())) {
6586 name = tbc->GetName();
6588 if (isSTL)
6590 il = name.Length();
6591 for (int i=0; i<il; i++) id = id*3+name[i];
6592 if (code > kNoBaseCheckSum && !isSTL) {
6593 if (tbc->GetClassPointer() == nullptr) {
6594 Error("GetCheckSum","Calculating the checksum for (%s) requires the base class (%s) meta information to be available!",
6595 GetName(),tbc->GetName());
6596 isvalid = kFALSE;
6597 return 0;
6598 } else
6599 id = id*3 + tbc->GetClassPointer()->GetCheckSum();
6600 }
6601 }/*EndBaseLoop*/
6602 }
6603 TList *tlm = ((TClass*)this)->GetListOfDataMembers();
6604 if (tlm) { // Loop over members
6605 TIter nextMemb(tlm);
6606 TDataMember *tdm=nullptr;
6607 Long_t prop = 0;
6608 while((tdm=(TDataMember*)nextMemb())) {
6609 if (!tdm->IsPersistent()) continue;
6610 // combine properties
6611 prop = (tdm->Property());
6612 TDataType* tdt = tdm->GetDataType();
6613 if (tdt) prop |= tdt->Property();
6614
6615 if ( prop&kIsStatic) continue;
6616 name = tdm->GetName(); il = name.Length();
6617 if ( (code > kNoEnum) && code != kReflex && code != kReflexNoComment && prop&kIsEnum)
6618 id = id*3 + 1;
6619
6620 int i;
6621 for (i=0; i<il; i++) id = id*3+name[i];
6622
6623 if (code > kWithTypeDef || code == kReflexNoComment) {
6624 type = tdm->GetTrueTypeName();
6625 // GetTrueTypeName uses GetFullyQualifiedName which already drops
6626 // the default template parameter, so we no longer need to do this.
6627 //if (TClassEdit::IsSTLCont(type))
6628 // type = TClassEdit::ShortType( type, TClassEdit::kDropStlDefault );
6629 if (code == kReflex || code == kReflexNoComment) {
6630 if (prop&kIsEnum) {
6631 type = "int";
6632 } else {
6633 type.ReplaceAll("ULong64_t","unsigned long long");
6634 type.ReplaceAll("Long64_t","long long");
6635 type.ReplaceAll("<signed char","<char");
6636 type.ReplaceAll(",signed char",",char");
6637 if (type=="signed char") type = "char";
6638 }
6639 }
6640 } else {
6641 type = tdm->GetFullTypeName();
6642 // GetFullTypeName uses GetFullyQualifiedName which already drops
6643 // the default template parameter, so we no longer need to do this.
6644 //if (TClassEdit::IsSTLCont(type))
6645 // type = TClassEdit::ShortType( type, TClassEdit::kDropStlDefault );
6646 }
6647
6648 il = type.Length();
6649 for (i=0; i<il; i++) id = id*3+type[i];
6650
6651 int dim = tdm->GetArrayDim();
6652 if (prop&kIsArray) {
6653 for (int ii=0;ii<dim;ii++) id = id*3+tdm->GetMaxIndex(ii);
6654 }
6655 if (code > kNoRange) {
6656 const char *left;
6657 if (code > TClass::kNoRangeCheck)
6659 else
6660 left = strstr(tdm->GetTitle(),"[");
6661 if (left) {
6662 const char *right = strstr(left,"]");
6663 if (right) {
6664 ++left;
6665 while (left != right) {
6666 id = id*3 + *left;
6667 ++left;
6668 }
6669 }
6670 }
6671 }
6672 }/*EndMembLoop*/
6673 }
6674 // This should be moved to Initialization time however the last time
6675 // we tried this cause problem, in particular in the end-of-process operation.
6676 if (code==kLatestCheckSum) fCheckSum = id;
6677 return id;
6678}
6679
6680////////////////////////////////////////////////////////////////////////////////
6681/// Adopt the Reference proxy pointer to indicate that this class
6682/// represents a reference.
6683/// When a new proxy is adopted, the old one is deleted.
6684
6686{
6688
6689 if ( fRefProxy ) {
6690 fRefProxy->Release();
6691 }
6692 fRefProxy = proxy;
6693 if ( fRefProxy ) {
6694 fRefProxy->SetClass(this);
6695 }
6696 fCanSplit = -1;
6697}
6698
6699////////////////////////////////////////////////////////////////////////////////
6700/// Adopt the TMemberStreamer pointer to by p and use it to Stream non basic
6701/// member name.
6702
6704{
6705 if (fRealData) {
6706
6708
6709 TIter next(fRealData);
6710 TRealData *rd;
6711 while ((rd = (TRealData*)next())) {
6712 if (strcmp(rd->GetName(),name) == 0) {
6713 // If there is a TStreamerElement that took a pointer to the
6714 // streamer we should inform it!
6715 rd->AdoptStreamer(p);
6716 return;
6717 }
6718 }
6719 }
6720
6721 Error("AdoptMemberStreamer","Cannot adope member streamer for %s::%s",GetName(), name);
6722 delete p;
6723
6724// NOTE: This alternative was proposed but not is not used for now,
6725// One of the major difference with the code above is that the code below
6726// did not require the RealData to have been built
6727// if (!fData) return;
6728// const char *n = name;
6729// while (*n=='*') n++;
6730// TString ts(n);
6731// int i = ts.Index("[");
6732// if (i>=0) ts.Remove(i,999);
6733// TDataMember *dm = (TDataMember*)fData->FindObject(ts.Data());
6734// if (!dm) {
6735// Warning("SetStreamer","Can not find member %s::%s",GetName(),name);
6736// return;
6737// }
6738// dm->SetStreamer(p);
6739}
6740
6741////////////////////////////////////////////////////////////////////////////////
6742/// Install a new member streamer (p will be copied).
6743
6745{
6747}
6748
6749////////////////////////////////////////////////////////////////////////////////
6750/// Function called by the Streamer functions to deserialize information
6751/// from buffer b into object at p.
6752/// This function assumes that the class version and the byte count information
6753/// have been read.
6754/// - version is the version number of the class
6755/// - start is the starting position in the buffer b
6756/// - count is the number of bytes for this object in the buffer
6757
6758Int_t TClass::ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count)
6759{
6760 return b.ReadClassBuffer(this,pointer,version,start,count);
6761}
6762
6763////////////////////////////////////////////////////////////////////////////////
6764/// Function called by the Streamer functions to deserialize information
6765/// from buffer b into object at p.
6766
6768{
6769 return b.ReadClassBuffer(this,pointer);
6770}
6771
6772////////////////////////////////////////////////////////////////////////////////
6773/// Function called by the Streamer functions to serialize object at p
6774/// to buffer b. The optional argument info may be specified to give an
6775/// alternative StreamerInfo instead of using the default StreamerInfo
6776/// automatically built from the class definition.
6777/// For more information, see class TVirtualStreamerInfo.
6778
6779Int_t TClass::WriteBuffer(TBuffer &b, void *pointer, const char * /*info*/)
6780{
6781 b.WriteClassBuffer(this,pointer);
6782 return 0;
6783}
6784
6785////////////////////////////////////////////////////////////////////////////////
6786///There is special streamer for the class
6787
6788void TClass::StreamerExternal(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class)
6789{
6790 // case kExternal:
6791 // case kExternal|kEmulatedStreamer:
6792
6793 TClassStreamer *streamer = gThreadTsd ? pThis->GetStreamer() : pThis->fStreamer;
6794 streamer->Stream(b,object,onfile_class);
6795}
6796
6797////////////////////////////////////////////////////////////////////////////////
6798/// Case of TObjects
6799
6800void TClass::StreamerTObject(const TClass* pThis, void *object, TBuffer &b, const TClass * /* onfile_class */)
6801{
6802 // case kTObject:
6803
6804 if (!pThis->fIsOffsetStreamerSet) {
6805 pThis->CalculateStreamerOffset();
6806 }
6807 TObject *tobj = (TObject*)((Longptr_t)object + pThis->fOffsetStreamer);
6808 tobj->Streamer(b);
6809}
6810
6811////////////////////////////////////////////////////////////////////////////////
6812/// Case of TObjects when fIsOffsetStreamerSet is known to have been set.
6813
6814void TClass::StreamerTObjectInitialized(const TClass* pThis, void *object, TBuffer &b, const TClass * /* onfile_class */)
6815{
6816 TObject *tobj = (TObject*)((Longptr_t)object + pThis->fOffsetStreamer);
6817 tobj->Streamer(b);
6818}
6819
6820////////////////////////////////////////////////////////////////////////////////
6821/// Case of TObjects when we do not have the library defining the class.
6822
6823void TClass::StreamerTObjectEmulated(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class)
6824{
6825 // case kTObject|kEmulatedStreamer :
6826 if (b.IsReading()) {
6827 b.ReadClassEmulated(pThis, object, onfile_class);
6828 } else {
6829 b.WriteClassBuffer(pThis, object);
6830 }
6831}
6832
6833////////////////////////////////////////////////////////////////////////////////
6834/// Case of instrumented class with a library
6835
6836void TClass::StreamerInstrumented(const TClass* pThis, void *object, TBuffer &b, const TClass * /* onfile_class */)
6837{
6838 // case kInstrumented:
6839 pThis->fStreamerFunc(b,object);
6840}
6841
6842////////////////////////////////////////////////////////////////////////////////
6843/// Case of instrumented class with a library
6844
6845void TClass::ConvStreamerInstrumented(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class)
6846{
6847 // case kInstrumented:
6848 pThis->fConvStreamerFunc(b,object,onfile_class);
6849}
6850
6851////////////////////////////////////////////////////////////////////////////////
6852/// Case of where we should directly use the StreamerInfo.
6853/// - case kForeign:
6854/// - case kForeign|kEmulatedStreamer:
6855/// - case kInstrumented|kEmulatedStreamer:
6856/// - case kEmulatedStreamer:
6857
6858void TClass::StreamerStreamerInfo(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class)
6859{
6860 if (b.IsReading()) {
6861 b.ReadClassBuffer(pThis, object, onfile_class);
6862 //ReadBuffer (b, object);
6863 } else {
6864 //WriteBuffer(b, object);
6865 b.WriteClassBuffer(pThis, object);
6866 }
6867}
6868
6869////////////////////////////////////////////////////////////////////////////////
6870/// Default streaming in cases where either we have no way to know what to do
6871/// or if Property() has not yet been called.
6872
6873void TClass::StreamerDefault(const TClass* pThis, void *object, TBuffer &b, const TClass *onfile_class)
6874{
6875 if (pThis->fProperty==(-1)) {
6876 pThis->Property();
6877 }
6878
6879 // We could get here because after this thread started StreamerDefault
6880 // *and* before check fProperty, another thread might have call Property
6881 // and this fProperty when we read it, is not -1 and fStreamerImpl is
6882 // supposed to be set properly (no longer pointing to the default).
6883 if (pThis->fStreamerImpl.load() == &TClass::StreamerDefault) {
6884 pThis->Fatal("StreamerDefault", "fStreamerImpl not properly initialized (%d)", pThis->fStreamerType);
6885 } else {
6886 (*pThis->fStreamerImpl)(pThis,object,b,onfile_class);
6887 }
6888}
6889
6890////////////////////////////////////////////////////////////////////////////////
6891/// Adopt a TClassStreamer object. Ownership is transfered to this TClass
6892/// object.
6893
6895{
6896// // This code can be used to quickly test the STL Emulation layer
6897// Int_t k = TClassEdit::IsSTLCont(GetName());
6898// if (k==1||k==-1) { delete str; return; }
6899
6901
6902 if (fStreamer) delete fStreamer;
6903 if (str) {
6905 fStreamer = str;
6907 } else if (fStreamer) {
6908 // Case where there was a custom streamer and it is hereby removed,
6909 // we need to reset fStreamerType
6910 fStreamer = str;
6912 if (fProperty != -1) {
6913 fProperty = -1;
6914 Property();
6915 }
6916 }
6917}
6918
6919////////////////////////////////////////////////////////////////////////////////
6920/// Set a wrapper/accessor function around this class custom streamer.
6921
6923{
6925 if (fProperty != -1 && !fConvStreamerFunc &&
6926 ( (fStreamerFunc == nullptr && strm != nullptr) || (fStreamerFunc != nullptr && strm == nullptr) ) )
6927 {
6928 fStreamerFunc = strm;
6929
6930 // Since initialization has already been done, make sure to tweak it
6931 // for the new state.
6935 }
6936 } else {
6937 fStreamerFunc = strm;
6938 }
6939 fCanSplit = -1;
6940}
6941
6942////////////////////////////////////////////////////////////////////////////////
6943/// Set a wrapper/accessor function around this class custom conversion streamer.
6944
6946{
6948 if (fProperty != -1 &&
6949 ( (fConvStreamerFunc == nullptr && strm != nullptr) || (fConvStreamerFunc != nullptr && strm == nullptr) ) )
6950 {
6951 fConvStreamerFunc = strm;
6952
6953 // Since initialization has already been done, make sure to tweak it
6954 // for the new state.
6958 }
6959 } else {
6960 fConvStreamerFunc = strm;
6961 }
6962 fCanSplit = -1;
6963}
6964
6965
6966////////////////////////////////////////////////////////////////////////////////
6967/// Install a new wrapper around 'Merge'.
6968
6970{
6971 fMerge = newMerge;
6972}
6973
6974////////////////////////////////////////////////////////////////////////////////
6975/// Install a new wrapper around 'ResetAfterMerge'.
6976
6978{
6979 fResetAfterMerge = newReset;
6980}
6981
6982////////////////////////////////////////////////////////////////////////////////
6983/// Install a new wrapper around 'new'.
6984
6986{
6987 fNew = newFunc;
6988}
6989
6990////////////////////////////////////////////////////////////////////////////////
6991/// Install a new wrapper around 'new []'.
6992
6994{
6995 fNewArray = newArrayFunc;
6996}
6997
6998////////////////////////////////////////////////////////////////////////////////
6999/// Install a new wrapper around 'delete'.
7000
7002{
7003 fDelete = deleteFunc;
7004}
7005
7006////////////////////////////////////////////////////////////////////////////////
7007/// Install a new wrapper around 'delete []'.
7008
7010{
7011 fDeleteArray = deleteArrayFunc;
7012}
7013
7014////////////////////////////////////////////////////////////////////////////////
7015/// Install a new wrapper around the destructor.
7016
7018{
7019 fDestructor = destructorFunc;
7020}
7021
7022////////////////////////////////////////////////////////////////////////////////
7023/// Install a new wrapper around the directory auto add function.
7024/// The function autoAddFunc has the signature void (*)(void *obj, TDirectory dir)
7025/// and should register 'obj' to the directory if dir is not null
7026/// and unregister 'obj' from its current directory if dir is null
7027
7029{
7030 fDirAutoAdd = autoAddFunc;
7031}
7032
7033////////////////////////////////////////////////////////////////////////////////
7034/// Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum
7035
7037{
7039 if (guess && guess->GetCheckSum() == checksum) {
7040 return guess;
7041 } else {
7042 if (fCheckSum == checksum)
7043 return GetStreamerInfo(0, isTransient);
7044
7046
7047 Int_t ninfos = fStreamerInfo->GetEntriesFast()-1;
7048 for (Int_t i=-1;i<ninfos;++i) {
7049 // TClass::fStreamerInfos has a lower bound not equal to 0,
7050 // so we have to use At and should not use UncheckedAt
7052 if (info && info->GetCheckSum() == checksum) {
7053 // R__ASSERT(i==info->GetClassVersion() || (i==-1&&info->GetClassVersion()==1));
7054 info->BuildOld();
7055 if (info->IsCompiled()) fLastReadInfo = info;
7056 return info;
7057 }
7058 }
7059 return nullptr;
7060 }
7061}
7062
7063////////////////////////////////////////////////////////////////////////////////
7064/// Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum
7065
7067{
7069 Int_t ninfos = arr->GetEntriesFast()-1;
7070 for (Int_t i=-1;i<ninfos;i++) {
7071 // TClass::fStreamerInfos has a lower bound not equal to 0,
7072 // so we have to use At and should not use UncheckedAt
7074 if (!info) continue;
7075 if (info->GetCheckSum() == checksum) {
7076 R__ASSERT(i==info->GetClassVersion() || (i==-1&&info->GetClassVersion()==1));
7077 return info;
7078 }
7079 }
7080 return nullptr;
7081}
7082
7083////////////////////////////////////////////////////////////////////////////////
7084/// Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this class, if any.
7085
7086TVirtualStreamerInfo *TClass::GetConversionStreamerInfo( const char* classname, Int_t version ) const
7087{
7088 TClass *cl = TClass::GetClass( classname );
7089 if( !cl )
7090 return nullptr;
7091 return GetConversionStreamerInfo( cl, version );
7092}
7093
7094////////////////////////////////////////////////////////////////////////////////
7095/// Return a Conversion StreamerInfo from the class represented by cl for version number 'version' to this class, if any.
7096
7098{
7099 //----------------------------------------------------------------------------
7100 // Check if the classname was specified correctly
7101 /////////////////////////////////////////////////////////////////////////////
7102
7103 if( !cl )
7104 return nullptr;
7105
7106 if( cl == this )
7107 return GetStreamerInfo( version );
7108
7109 //----------------------------------------------------------------------------
7110 // Check if we already have it
7111 /////////////////////////////////////////////////////////////////////////////
7112
7113 TObjArray* arr = nullptr;
7114 if (fConversionStreamerInfo.load()) {
7115 std::map<std::string, TObjArray*>::iterator it;
7117
7118 it = (*fConversionStreamerInfo).find( cl->GetName() );
7119
7120 if( it != (*fConversionStreamerInfo).end() ) {
7121 arr = it->second;
7122 }
7123
7124 if( arr && version >= -1 && version < arr->GetSize() && arr->At( version ) )
7125 return (TVirtualStreamerInfo*) arr->At( version );
7126 }
7127
7129
7130 //----------------------------------------------------------------------------
7131 // We don't have the streamer info so find it in other class
7132 /////////////////////////////////////////////////////////////////////////////
7133
7134 const TObjArray *clSI = cl->GetStreamerInfos();
7135 TVirtualStreamerInfo* info = nullptr;
7136 if( version >= -1 && version < clSI->GetSize() )
7137 info = (TVirtualStreamerInfo*)clSI->At( version );
7138
7139 if (!info && cl->GetCollectionProxy()) {
7140 info = cl->GetStreamerInfo(); // instantiate the StreamerInfo for STL collections.
7141 }
7142
7143 if( !info )
7144 return nullptr;
7145
7146 //----------------------------------------------------------------------------
7147 // We have the right info so we need to clone it to create new object with
7148 // non artificial streamer elements and we should build it for current class
7149 /////////////////////////////////////////////////////////////////////////////
7150
7151 info = (TVirtualStreamerInfo*)info->Clone();
7152
7153 // When cloning the StreamerInfo we record (and thus restore)
7154 // the absolute value of the version, let's restore the sign.
7155 if (version == -1)
7156 info->SetClassVersion(-1);
7157
7158 if( !info->BuildFor( this ) ) {
7159 delete info;
7160 return nullptr;
7161 }
7162
7163 if (!info->IsCompiled()) {
7164 // Streamer info has not been compiled, but exists.
7165 // Therefore it was read in from a file and we have to do schema evolution?
7166 // Or it didn't have a dictionary before, but does now?
7167 info->BuildOld();
7168 }
7169
7170 //----------------------------------------------------------------------------
7171 // Cache this streamer info
7172 /////////////////////////////////////////////////////////////////////////////
7173
7174 if (!arr) {
7175 arr = new TObjArray(version+10, -1);
7176 if (!fConversionStreamerInfo.load()) {
7177 fConversionStreamerInfo = new std::map<std::string, TObjArray*>();
7178 }
7179 (*fConversionStreamerInfo)[cl->GetName()] = arr;
7180 }
7181 if (arr->At(info->GetClassVersion())) {
7182 Error("GetConversionStreamerInfo", "Conversion StreamerInfo from %s to %s version %d has already been created",
7183 this->GetName(), info->GetName(), info->GetClassVersion());
7184 delete arr->At(info->GetClassVersion());
7185 }
7186 arr->AddAtAndExpand( info, info->GetClassVersion() );
7187 return info;
7188}
7189
7190////////////////////////////////////////////////////////////////////////////////
7191/// Return a Conversion StreamerInfo from the class 'classname' for the layout represented by 'checksum' to this class, if any.
7192
7193TVirtualStreamerInfo *TClass::FindConversionStreamerInfo( const char* classname, UInt_t checksum ) const
7194{
7195 TClass *cl = TClass::GetClass( classname );
7196 if( !cl )
7197 return nullptr;
7198 return FindConversionStreamerInfo( cl, checksum );
7199}
7200
7201////////////////////////////////////////////////////////////////////////////////
7202/// Return a Conversion StreamerInfo from the class represented by cl for the layout represented by 'checksum' to this class, if any.
7203
7205{
7206 //---------------------------------------------------------------------------
7207 // Check if the classname was specified correctly
7208 /////////////////////////////////////////////////////////////////////////////
7209
7210 if( !cl )
7211 return nullptr;
7212
7213 if( cl == this )
7214 return FindStreamerInfo( checksum );
7215
7216 //----------------------------------------------------------------------------
7217 // Check if we already have it
7218 /////////////////////////////////////////////////////////////////////////////
7219
7220 TObjArray* arr = nullptr;
7221 TVirtualStreamerInfo* info = nullptr;
7222 if (fConversionStreamerInfo.load()) {
7223 std::map<std::string, TObjArray*>::iterator it;
7224
7226
7227 it = (*fConversionStreamerInfo).find( cl->GetName() );
7228
7229 if( it != (*fConversionStreamerInfo).end() ) {
7230 arr = it->second;
7231 }
7232 if (arr) {
7233 info = FindStreamerInfo( arr, checksum );
7234 }
7235 }
7236
7237 if( info )
7238 return info;
7239
7241
7242 //----------------------------------------------------------------------------
7243 // Get it from the foreign class
7244 /////////////////////////////////////////////////////////////////////////////
7245
7246 info = cl->FindStreamerInfo( checksum );
7247
7248 if( !info )
7249 return nullptr;
7250
7251 //----------------------------------------------------------------------------
7252 // We have the right info so we need to clone it to create new object with
7253 // non artificial streamer elements and we should build it for current class
7254 /////////////////////////////////////////////////////////////////////////////
7255
7256 int version = info->GetClassVersion();
7257 info = (TVirtualStreamerInfo*)info->Clone();
7258
7259 // When cloning the StreamerInfo we record (and thus restore)
7260 // the absolute value of the version, let's restore the sign.
7261 if (version == -1)
7262 info->SetClassVersion(-1);
7263
7264 if( !info->BuildFor( this ) ) {
7265 delete info;
7266 return nullptr;
7267 }
7268
7269 if (!info->IsCompiled()) {
7270 // Streamer info has not been compiled, but exists.
7271 // Therefore it was read in from a file and we have to do schema evolution?
7272 // Or it didn't have a dictionary before, but does now?
7273 info->BuildOld();
7274 }
7275
7276 //----------------------------------------------------------------------------
7277 // Cache this streamer info
7278 /////////////////////////////////////////////////////////////////////////////
7279
7280 if (!arr) {
7281 arr = new TObjArray(16, -2);
7282 if (!fConversionStreamerInfo.load()) {
7283 fConversionStreamerInfo = new std::map<std::string, TObjArray*>();
7284 }
7285 (*fConversionStreamerInfo)[cl->GetName()] = arr;
7286 }
7287 arr->AddAtAndExpand( info, info->GetClassVersion() );
7288
7289 return info;
7290}
7291
7292////////////////////////////////////////////////////////////////////////////////
7293/// Register the StreamerInfo in the given slot, change the State of the
7294/// TClass as appropriate.
7295
7297{
7298 if (info) {
7300 Int_t slot = info->GetClassVersion();
7302 && fStreamerInfo->At(slot) != nullptr
7303 && fStreamerInfo->At(slot) != info) {
7304 Error("RegisterStreamerInfo",
7305 "Register StreamerInfo for %s on non-empty slot (%d).",
7306 GetName(),slot);
7307 }
7308 fStreamerInfo->AddAtAndExpand(info, slot);
7309 if (fState <= kForwardDeclared) {
7310 fState = kEmulated;
7311 if (fCheckSum==0 && slot==fClassVersion) fCheckSum = info->GetCheckSum();
7312 }
7313 }
7314}
7315
7316////////////////////////////////////////////////////////////////////////////////
7317/// Remove and delete the StreamerInfo in the given slot.
7318/// Update the slot accordingly.
7319
7321{
7322 if (fStreamerInfo->GetSize() >= slot) {
7326 if (fLastReadInfo.load() == info)
7327 fLastReadInfo = nullptr;
7328 if (fCurrentInfo.load() == info)
7329 fCurrentInfo = nullptr;
7330 delete info;
7331 if (fState == kEmulated && fStreamerInfo->GetEntries() == 0) {
7333 }
7334 }
7335}
7336
7337////////////////////////////////////////////////////////////////////////////////
7338/// Return true is the Hash/RecursiveRemove setup is consistent, i.e. when all
7339/// classes in the class hierarchy that overload TObject::Hash do call
7340/// ROOT::CallRecursiveRemoveIfNeeded in their destructor.
7341/// i.e. it is safe to call the Hash virtual function during the RecursiveRemove operation.
7342/// This routines is used for a small subset of the class for which we need
7343/// the answer before gROOT is properly initialized.
7344
7346{
7347 // Hand selection of correct classes, those classes should be
7348 // cross-checked in testHashRecursiveRemove.cxx
7349 static const char *handVerified[] = {
7350 "TEnvRec", "TDataType", "TObjArray", "TList", "THashList",
7351 "TClass", "TCling", "TInterpreter", "TMethod", "ROOT::Internal::TCheckHashRecursiveRemoveConsistency",
7352 "TCheckHashRecursiveRemoveConsistency", "TGWindow",
7353 "TDirectory", "TDirectoryFile", "TObject", "TH1",
7354 "TQClass", "TGlobal" };
7355
7356 if (cname && cname[0]) {
7357 for (auto cursor : handVerified) {
7358 if (strcmp(cname, cursor) == 0)
7359 return true;
7360 }
7361 }
7362 return false;
7363}
7364
7365////////////////////////////////////////////////////////////////////////////////
7366/// Return true is the Hash/RecursiveRemove setup is consistent, i.e. when all
7367/// classes in the class hierarchy that overload TObject::Hash do call
7368/// ROOT::CallRecursiveRemoveIfNeeded in their destructor.
7369/// i.e. it is safe to call the Hash virtual function during the RecursiveRemove operation.
7370
7372{
7373 return clRef.HasConsistentHashMember();
7374}
7375
7376////////////////////////////////////////////////////////////////////////////////
7377/// Return true if we have access to a constructor usable for I/O. This is
7378/// typically the default constructor but can also be a constructor specifically
7379/// marked for I/O (for example a constructor taking a TRootIOCtor* as an
7380/// argument). In other words, if this routine returns true, TClass::New is
7381/// guarantee to succeed.
7382/// To know if the class described by this TClass has a default constructor
7383/// (public or not), use
7384/// \code{.cpp}
7385/// cl->GetProperty() & kClassHasDefaultCtor
7386/// \endcode
7387/// To know if the class described by this TClass has a public default
7388/// constructor use:
7389/// \code{.cpp}
7390/// gInterpreter->ClassInfo_HasDefaultConstructor(aClass->GetClassInfo());
7391/// \endcode
7392
7394{
7395
7396 if (fNew) return kTRUE;
7397
7398 if (HasInterpreterInfo()) {
7401 }
7402 if (fCollectionProxy) {
7403 return kTRUE;
7404 }
7405 if (fCurrentInfo.load()) {
7406 // Emulated class, we know how to construct them via the TStreamerInfo
7407 return kTRUE;
7408 }
7409 return kFALSE;
7410}
7411
7412////////////////////////////////////////////////////////////////////////////////
7413/// Returns true if this class has an definition and/or overload of the
7414/// member function Hash.
7415///
7416/// For example to test if the class overload TObject::Hash use
7417/// ~~~ {.cpp}
7418/// if (cl->IsTObject() && cl->HasLocalHashMember())
7419/// ~~~
7420
7422{
7423 if (fProperty == (-1))
7424 Property();
7426}
7427
7428////////////////////////////////////////////////////////////////////////////////
7429/// Return the wrapper around Merge.
7430
7432{
7433 return fMerge;
7434}
7435
7436////////////////////////////////////////////////////////////////////////////////
7437/// Return the wrapper around Merge.
7438
7440{
7441 return fResetAfterMerge;
7442}
7443
7444////////////////////////////////////////////////////////////////////////////////
7445/// Return the wrapper around new ThisClass().
7446
7448{
7449 return fNew;
7450}
7451
7452////////////////////////////////////////////////////////////////////////////////
7453/// Return the wrapper around new ThisClass[].
7454
7456{
7457 return fNewArray;
7458}
7459
7460////////////////////////////////////////////////////////////////////////////////
7461/// Return the wrapper around delete ThiObject.
7462
7464{
7465 return fDelete;
7466}
7467
7468////////////////////////////////////////////////////////////////////////////////
7469/// Return the wrapper around delete [] ThiObject.
7470
7472{
7473 return fDeleteArray;
7474}
7475
7476////////////////////////////////////////////////////////////////////////////////
7477/// Return the wrapper around the destructor
7478
7480{
7481 return fDestructor;
7482}
7483
7484////////////////////////////////////////////////////////////////////////////////
7485/// Return the wrapper around the directory auto add function.
7486
7488{
7489 return fDirAutoAdd;
7490}
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
#define c(i)
Definition RSha256.hxx:101
#define a(i)
Definition RSha256.hxx:99
#define e(i)
Definition RSha256.hxx:103
RooAbsTestStatistic * create(const char *name, const char *title, RooAbsReal &real, RooAbsData &adata, const RooArgSet &projDeps, RooAbsTestStatistic::Configuration const &cfg) override
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
long Longptr_t
Definition RtypesCore.h:82
short Version_t
Definition RtypesCore.h:65
unsigned char UChar_t
Definition RtypesCore.h:38
unsigned long ULong_t
Definition RtypesCore.h:55
long Long_t
Definition RtypesCore.h:54
unsigned int UInt_t
Definition RtypesCore.h:46
unsigned long ULongptr_t
Definition RtypesCore.h:83
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:124
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
TClass *(* DictFuncPtr_t)()
Definition Rtypes.h:80
#define ClassImp(name)
Definition Rtypes.h:377
void(* MemberStreamerFunc_t)(TBuffer &, void *, Int_t)
Definition Rtypes.h:74
TClass *(* IsAGlobalFunc_t)(const TClass *, const void *obj)
Definition Rtypes.h:96
void(* ClassStreamerFunc_t)(TBuffer &, void *)
Definition Rtypes.h:72
void(* ClassConvStreamerFunc_t)(TBuffer &, void *, const TClass *)
Definition Rtypes.h:73
R__EXTERN TClassTable * gClassTable
Definition TClassTable.h:97
TVirtualMutex * gInterpreterMutex
Definition TClass.cxx:132
TClass::ENewType & TClass__GetCallingNew()
Definition TClass.cxx:267
static bool IsFromRootCling()
Definition TClass.cxx:174
ROOT::TMapDeclIdToTClass DeclIdMap_t
Definition TClass.h:79
ROOT::TMapTypeToTClass IdMap_t
Definition TClass.h:78
void(* tcling_callfunc_Wrapper_t)(void *, int, void **, void *)
const Bool_t kIterBackward
Definition TCollection.h:43
EDataType
Definition TDataType.h:28
@ kNoType_t
Definition TDataType.h:33
@ kUInt_t
Definition TDataType.h:30
@ kIsPointer
Definition TDictionary.h:78
@ kIsClass
Definition TDictionary.h:65
@ kIsEnum
Definition TDictionary.h:68
@ kIsFundamental
Definition TDictionary.h:70
@ kIsAbstract
Definition TDictionary.h:71
@ kIsArray
Definition TDictionary.h:79
@ kIsStatic
Definition TDictionary.h:80
@ kIsStruct
Definition TDictionary.h:66
@ kIsUnion
Definition TDictionary.h:67
@ kIsNamespace
Definition TDictionary.h:95
@ kIsVirtualBase
Definition TDictionary.h:89
#define R__ASSERT(e)
Definition TError.h:118
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t cursor
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 filename
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 char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
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 cname
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char mode
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t property
Option_t Option_t TPoint TPoint const char text
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
R__EXTERN TInterpreter * gCling
#define gInterpreter
@ kMenuToggle
Definition TMethod.h:34
@ kMenuNoMenu
Definition TMethod.h:32
Int_t gDebug
Definition TROOT.cxx:597
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:407
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2481
@ kDefault
Definition TSystem.h:229
R__EXTERN TSystem * gSystem
Definition TSystem.h:560
R__EXTERN void **(* gThreadTsd)(void *, Int_t)
#define R__LOCKGUARD2(mutex)
#define R__LOCKGUARD(mutex)
#define gPad
#define R__WRITE_LOCKGUARD(mutex)
#define R__READ_LOCKGUARD(mutex)
const char * proto
Definition civetweb.c:17536
#define free
Definition civetweb.c:1539
#define snprintf
Definition civetweb.c:1540
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 SetClass(TClass *cls)
Set the TClass associated with this rule set.
A spin mutex-as-code-guard class.
DeclIdMap_t::key_type key_type
Definition TClass.cxx:437
DeclIdMap_t::size_type size_type
Definition TClass.cxx:441
multimap< TDictionary::DeclId_t, TClass * > DeclIdMap_t
Definition TClass.cxx:436
size_type CountElementsWithKey(const key_type &key)
Definition TClass.cxx:453
std::pair< const_iterator, const_iterator > equal_range
Definition TClass.cxx:440
equal_range Find(const key_type &key) const
Definition TClass.cxx:457
void Remove(const key_type &key)
Definition TClass.cxx:462
DeclIdMap_t::const_iterator const_iterator
Definition TClass.cxx:439
DeclIdMap_t::mapped_type mapped_type
Definition TClass.cxx:438
void Add(const key_type &key, mapped_type obj)
Definition TClass.cxx:447
mapped_type Find(const key_type &key) const
Definition TClass.cxx:390
IdMap_t::size_type size_type
Definition TClass.cxx:373
IdMap_t::mapped_type mapped_type
Definition TClass.cxx:378
IdMap_t::const_iterator const_iterator
Definition TClass.cxx:372
std::map< std::string, TClass * > IdMap_t
Definition TClass.cxx:370
IdMap_t::key_type key_type
Definition TClass.cxx:371
void Remove(const key_type &key)
Definition TClass.cxx:398
void Add(const key_type &key, mapped_type &obj)
Definition TClass.cxx:385
Bool_t SetFromRule(const char *rule)
Set the content fot this object from the rule See TClass::AddRule for details on the syntax.
const char * GetTargetString() const
Get the target data members of this rule as a simple string (i.e. the in memory data member).
const char * GetVersion() const
Get the version string.
const char * GetTargetClass() const
Get the targte class of this rule (i.e. the in memory class).
static TClass * Class()
TBrowser * fBrowser
Definition TClass.cxx:904
Bool_t IsTreatingNonAccessibleTypes() override
Definition TClass.cxx:914
TAutoInspector(TBrowser *b)
Definition TClass.cxx:906
virtual ~TAutoInspector()
Definition TClass.cxx:911
void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override
This method is called from ShowMembers() via AutoBrowse().
Definition TClass.cxx:920
Each class (see TClass) has a linked list of its base class(es).
Definition TBaseClass.h:33
Int_t GetDelta()
Get offset from "this" to part of base class.
ROOT::ESTLType IsSTLContainer()
Return which type (if any) of STL container the data member is.
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
TClass * GetClassPointer(Bool_t load=kTRUE)
Get pointer to the base class TClass.
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
Buffer base class used for serializing objects.
Definition TBuffer.h:43
void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override
This method is called from ShowMembers() via BuildRealdata().
Definition TClass.cxx:771
TClass * fRealDataClass
Definition TClass.cxx:755
void * fRealDataObject
Definition TClass.cxx:754
TBuildRealData(void *obj, TClass *cl)
Definition TClass.cxx:758
Objects following this interface can be passed onto the TROOT object to implement a user customized w...
virtual TClass * GetClass(const char *classname, Bool_t load)=0
Describes one element of the context menu associated to a class The menu item may describe.
virtual void SetToggle(Bool_t toggle=kTRUE)
TClassRef is used to implement a permanent reference to a TClass object.
Definition TClassRef.h:28
virtual void Stream(TBuffer &b, void *objp, const TClass *onfileClass)
virtual TClassStreamer * Generate() const
static DictFuncPtr_t GetDict(const char *cname)
Given the class name returns the Dictionary() function of a class (uses hash of name).
static TProtoClass * GetProtoNorm(const char *cname)
Given the class normalized name returns the TClassProto object for the class.
static DictFuncPtr_t GetDictNorm(const char *cname)
Given the normalized class name returns the Dictionary() function of a class (uses hash of name).
InsertTClassInRegistryRAII(TClass::EState &state, const char *name, TDeclNameRegistry &emuRegistry)
Definition TClass.cxx:248
Bool_t HasDeclName(const char *name) const
Definition TClass.cxx:223
void AddQualifiedName(const char *name)
Extract this part of the name.
Definition TClass.cxx:196
TDeclNameRegistry(Int_t verbLevel=0)
TDeclNameRegistry class constructor.
Definition TClass.cxx:185
std::atomic_flag fSpinLock
Definition TClass.h:170
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
Bool_t IsSyntheticPair() const
Definition TClass.h:521
RepoCont_t fObjectVersionRepository
Definition TClass.h:344
ShowMembersFunc_t fShowMembers
Definition TClass.h:225
TDataMember * GetDataMember(const char *datamember) const
Return pointer to datamember object with name "datamember".
Definition TClass.cxx:3439
TVirtualIsAProxy * fIsA
Definition TClass.h:229
TList * GetListOfUsingDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of using declarations of a class.
Definition TClass.cxx:3786
void ForceReload(TClass *oldcl)
we found at least one equivalent.
Definition TClass.cxx:1336
ROOT::DelArrFunc_t fDeleteArray
Definition TClass.h:238
Bool_t CanSplit() const
Return true if the data member of this TClass can be saved separately.
Definition TClass.cxx:2319
TClassStreamer * fStreamer
Definition TClass.h:226
void SetDirectoryAutoAdd(ROOT::DirAutoAdd_t dirAutoAddFunc)
Install a new wrapper around the directory auto add function.
Definition TClass.cxx:7028
void * NewArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
Definition TClass.cxx:5193
static TDeclNameRegistry fNoInfoOrEmuOrFwdDeclNameRegistry
Definition TClass.h:328
TListOfFunctionTemplates * fFuncTemplate
Definition TClass.h:206
ClassStreamerFunc_t fStreamerFunc
Definition TClass.h:241
void AdoptReferenceProxy(TVirtualRefProxy *proxy)
Adopt the Reference proxy pointer to indicate that this class represents a reference.
Definition TClass.cxx:6685
TMethod * GetClassMethod(Longptr_t faddr)
Look for a method in this class that has the interface function address faddr.
Definition TClass.cxx:4483
TVirtualStreamerInfo * DetermineCurrentStreamerInfo()
Determine and set pointer to current TVirtualStreamerInfo.
Definition TClass.cxx:5684
void Browse(TBrowser *b) override
This method is called by a browser to get the class information.
Definition TClass.cxx:2010
EState GetState() const
Definition TClass.h:488
ROOT::ESTLType GetCollectionType() const
Return the 'type' of the STL the TClass is representing.
Definition TClass.cxx:2886
void Draw(Option_t *option="") override
Draw detailed class inheritance structure.
Definition TClass.cxx:2487
void AdoptMemberStreamer(const char *name, TMemberStreamer *strm)
Adopt the TMemberStreamer pointer to by p and use it to Stream non basic member name.
Definition TClass.cxx:6703
void ResetInstanceCount()
Definition TClass.h:547
ClassStreamerFunc_t GetStreamerFunc() const
Get a wrapper/accessor function around this class custom streamer (member function).
Definition TClass.cxx:2939
void RemoveStreamerInfo(Int_t slot)
Remove and delete the StreamerInfo in the given slot.
Definition TClass.cxx:7320
void SetCanSplit(Int_t splitmode)
Set the splitability of this class:
Definition TClass.cxx:5658
TList * CreateListOfDataMembers(std::atomic< TListOfDataMembers * > &data, TDictionary::EMemberSelection selection, bool load)
Create the list containing the TDataMembers (of actual data members or members pulled in through usin...
Definition TClass.cxx:3741
TVirtualStreamerInfo * GetStreamerInfoAbstractEmulated(Int_t version=0) const
For the case where the requestor class is emulated and this class is abstract, returns a pointer to t...
Definition TClass.cxx:4709
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition TClass.cxx:4978
void SetMerge(ROOT::MergeFunc_t mergeFunc)
Install a new wrapper around 'Merge'.
Definition TClass.cxx:6969
ConvSIMap_t fConversionStreamerInfo
Definition TClass.h:199
ROOT::DirAutoAdd_t fDirAutoAdd
Definition TClass.h:240
Bool_t HasDataMemberInfo() const
Definition TClass.h:407
TVirtualRefProxy * fRefProxy
cached streamer info used in the last read.
Definition TClass.h:280
TList * GetMenuList() const
Return the list of menu items associated with the class.
Definition TClass.cxx:4341
ROOT::MergeFunc_t fMerge
saved info to call a IsA member function
Definition TClass.h:233
TMethod * GetMethod(const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Find the best method (if there is one) matching the parameters.
Definition TClass.cxx:4411
static TClass * Load(TBuffer &b)
Load class description from I/O buffer and return class object.
Definition TClass.cxx:5715
EState fState
cached of the streaming method to use
Definition TClass.h:277
ROOT::DesFunc_t GetDestructor() const
Return the wrapper around the destructor.
Definition TClass.cxx:7479
TMethod * GetMethodWithPrototype(const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
Definition TClass.cxx:4456
void CopyCollectionProxy(const TVirtualCollectionProxy &)
Replaces the collection proxy for this class.
Definition TClass.cxx:2470
Int_t fStreamerType
saved info to call Streamer
Definition TClass.h:276
TList * fRealData
Definition TClass.h:200
UInt_t fOnHeap
Definition TClass.h:218
void ls(Option_t *opt="") const override
The ls function lists the contents of a class on stdout.
Definition TClass.cxx:4258
std::atomic< TList * > fBase
Definition TClass.h:201
std::atomic< Char_t > fCanSplit
Definition TClass.h:245
Bool_t HasDictionary() const
Check whether a class has a dictionary or not.
Definition TClass.cxx:3906
const TList * GetListOfAllPublicMethods(Bool_t load=kTRUE)
Returns a list of all public methods of this class and its base classes.
Definition TClass.cxx:3845
TList * GetListOfAllPublicDataMembers(Bool_t load=kTRUE)
Returns a list of all public data members of this class and its base classes.
Definition TClass.cxx:3862
static void AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass *cl)
static: Add a TClass* to the map of classes.
Definition TClass.cxx:511
virtual ~TClass()
TClass dtor. Deletes all list that might have been created.
Definition TClass.cxx:1660
Bool_t fIsSyntheticPair
Indicates whether this class can be split or not. Values are -1, 0, 1, 2.
Definition TClass.h:250
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition TClass.cxx:5400
Version_t fClassVersion
Definition TClass.h:221
std::atomic< TVirtualStreamerInfo * > fCurrentInfo
Current 'state' of the class (Emulated,Interpreted,Loaded)
Definition TClass.h:278
TList * GetListOfFunctionTemplates(Bool_t load=kTRUE)
Return TListOfFunctionTemplates for a class.
Definition TClass.cxx:3798
void * DynamicCast(const TClass *base, void *obj, Bool_t up=kTRUE)
Cast obj of this class type up to baseclass cl if up is true.
Definition TClass.cxx:4915
const char * fImplFileName
Definition TClass.h:214
void RegisterStreamerInfo(TVirtualStreamerInfo *info)
Register the StreamerInfo in the given slot, change the State of the TClass as appropriate.
Definition TClass.cxx:7296
std::atomic< UInt_t > fCheckSum
Definition TClass.h:219
void UnregisterAddressInRepository(const char *where, void *location, const TClass *what) const
Definition TClass.cxx:318
std::atomic< TListOfFunctions * > fMethod
Definition TClass.h:207
static void RemoveClassDeclId(TDictionary::DeclId_t id)
Definition TClass.cxx:536
void SetNewArray(ROOT::NewArrFunc_t newArrayFunc)
Install a new wrapper around 'new []'.
Definition TClass.cxx:6993
Bool_t CallShowMembers(const void *obj, TMemberInspector &insp, Bool_t isTransient=kFALSE) const
Call ShowMembers() on the obj of this class type, passing insp and parent.
Definition TClass.cxx:2205
const char * fDeclFileName
Definition TClass.h:213
void SetCollectionProxy(const ROOT::Detail::TCollectionProxyInfo &)
Create the collection proxy object (and the streamer object) from using the information in the TColle...
Definition TClass.cxx:6244
static Bool_t HasDictionarySelection(const char *clname)
Check whether a class has a dictionary or ROOT can load one.
Definition TClass.cxx:3917
void AdoptSchemaRules(ROOT::Detail::TSchemaRuleSet *rules)
Adopt a new set of Data Model Evolution rules.
Definition TClass.cxx:1920
static void StreamerInstrumented(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of instrumented class with a library.
Definition TClass.cxx:6836
TVirtualStreamerInfo * SetStreamerInfo(Int_t version, const char *info="")
Info is a string describing the names and types of attributes written by the class Streamer function.
Definition TClass.cxx:6373
static std::atomic< Int_t > fgClassCount
Definition TClass.h:326
TVirtualStreamerInfo * GetCurrentStreamerInfo()
Definition TClass.h:439
ROOT::DirAutoAdd_t GetDirectoryAutoAdd() const
Return the wrapper around the directory auto add function.
Definition TClass.cxx:7487
void AddImplFile(const char *filename, int line)
Definition TClass.cxx:1952
TCollection * GetListOfMethodOverloads(const char *name) const
Return the collection of functions named "name".
Definition TClass.cxx:3827
std::atomic< TListOfEnums * > fEnums
Definition TClass.h:205
static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char *)
Definition TClass.cxx:3398
TVirtualMutex * fOVRMutex
Definition TClass.h:342
TList * GetListOfEnums(Bool_t load=kTRUE)
Return a list containing the TEnums of a class.
Definition TClass.cxx:3686
Bool_t IsStartingWithTObject() const
Returns true if this class inherits from TObject and if the start of the TObject parts is at the very...
Definition TClass.cxx:5929
TList * GetListOfMethods(Bool_t load=kTRUE)
Return list containing the TMethods of a class.
Definition TClass.cxx:3812
TClass()
Internal, default constructor.
Definition TClass.cxx:1065
Short_t fDeclFileLine
Definition TClass.h:215
Int_t GetNmethods()
Return the number of methods of this class Note that in case the list of methods is not yet created,...
Definition TClass.cxx:4573
std::atomic< Bool_t > fIsOffsetStreamerSet
Indicates whether the ClassInfo is supposed to be available.
Definition TClass.h:261
void IgnoreTObjectStreamer(Bool_t ignore=kTRUE)
When the class kIgnoreTObjectStreamer bit is set, the automatically generated Streamer will not call ...
Definition TClass.cxx:4841
TClassStreamer * GetStreamer() const
Return the Streamer Class allowing streaming (if any).
Definition TClass.cxx:2914
static IdMap_t * GetIdMap()
Definition TClass.cxx:469
void SetDelete(ROOT::DelFunc_t deleteFunc)
Install a new wrapper around 'delete'.
Definition TClass.cxx:7001
static Int_t AutoBrowse(TObject *obj, TBrowser *browser)
Browse external object inherited from TObject.
Definition TClass.cxx:1966
ROOT::NewFunc_t GetNew() const
Return the wrapper around new ThisClass().
Definition TClass.cxx:7447
TClass * GetBaseClass(const char *classname)
Return pointer to the base class "classname".
Definition TClass.cxx:2655
Longptr_t GetDataMemberOffset(const char *membername) const
return offset for member name.
Definition TClass.cxx:3477
Int_t GetNdata()
Return the number of data members of this class Note that in case the list of data members is not yet...
Definition TClass.cxx:4554
void SetDestructor(ROOT::DesFunc_t destructorFunc)
Install a new wrapper around the destructor.
Definition TClass.cxx:7017
virtual void PostLoadCheck()
Do the initialization that can only be done after the CINT dictionary has been fully populated and ca...
Definition TClass.cxx:5959
void LoadClassInfo() const
Try to load the ClassInfo if available.
Definition TClass.cxx:5824
void SetResetAfterMerge(ROOT::ResetAfterMergeFunc_t resetFunc)
Install a new wrapper around 'ResetAfterMerge'.
Definition TClass.cxx:6977
TVirtualStreamerInfo * GetStreamerInfoImpl(Int_t version, Bool_t silent) const
Definition TClass.cxx:4634
Bool_t MatchLegacyCheckSum(UInt_t checksum) const
Return true if the checksum passed as argument is one of the checksum value produced by the older che...
Definition TClass.cxx:6494
TViewPubFunctions * fAllPubMethod
Definition TClass.h:210
Bool_t HasInterpreterInfo() const
Definition TClass.h:410
static void AddClass(TClass *cl)
static: Add a class to the list and map of classes.
Definition TClass.cxx:494
void GetMissingDictionariesForBaseClasses(TCollection &result, TCollection &visited, bool recurse)
Verify the base classes always.
Definition TClass.cxx:3927
ROOT::Detail::TSchemaRuleSet * fSchemaRules
Pointer to reference proxy if this class represents a reference.
Definition TClass.h:281
std::atomic< Long_t > fProperty
Definition TClass.h:255
static void StreamerDefault(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Default streaming in cases where either we have no way to know what to do or if Property() has not ye...
Definition TClass.cxx:6873
void SetUnloaded()
Call this method to indicate that the shared library containing this class's code has been removed (u...
Definition TClass.cxx:6309
ROOT::DelArrFunc_t GetDeleteArray() const
Return the wrapper around delete [] ThiObject.
Definition TClass.cxx:7471
Bool_t HasInterpreterInfoInMemory() const
Definition TClass.h:409
TList * fClassMenuList
Definition TClass.h:211
ClassConvStreamerFunc_t fConvStreamerFunc
Definition TClass.h:242
void BuildRealData(void *pointer=nullptr, Bool_t isTransient=kFALSE)
Build a full list of persistent data members.
Definition TClass.cxx:2031
void SetRuntimeProperties()
Internal routine to set calculate the class properties that can only be known at run-time,...
Definition TClass.cxx:6194
void BuildEmulatedRealData(const char *name, Longptr_t offset, TClass *cl, Bool_t isTransient=kFALSE)
Build the list of real data for an emulated class.
Definition TClass.cxx:2112
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition TClass.cxx:5749
TString fSharedLibs
Definition TClass.h:227
const std::type_info * GetTypeInfo() const
Definition TClass.h:496
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
Definition TClass.cxx:3770
ENewType
Definition TClass.h:107
@ kRealNew
Definition TClass.h:107
void Move(void *arenaFrom, void *arenaTo) const
Register the fact that an object was moved from the memory location 'arenaFrom' to the memory locatio...
Definition TClass.cxx:4327
static DeclIdMap_t * GetDeclIdMap()
Definition TClass.cxx:480
Short_t GetDeclFileLine() const
Definition TClass.h:429
void SetStreamerFunc(ClassStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom streamer.
Definition TClass.cxx:6922
const char * GetImplFileName() const
Definition TClass.h:456
TList * GetListOfRealData() const
Definition TClass.h:453
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
void SetCurrentStreamerInfo(TVirtualStreamerInfo *info)
Set pointer to current TVirtualStreamerInfo.
Definition TClass.cxx:5696
static DictFuncPtr_t GetDict(const char *cname)
Return a pointer to the dictionary loading function generated by rootcint.
Definition TClass.cxx:3422
Longptr_t fOffsetStreamer
Properties that can only be evaluated at run-time.
Definition TClass.h:275
Int_t fSizeof
Definition TClass.h:243
ROOT::NewArrFunc_t GetNewArray() const
Return the wrapper around new ThisClass[].
Definition TClass.cxx:7455
static void StreamerTObjectEmulated(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects when we do not have the library defining the class.
Definition TClass.cxx:6823
ROOT::NewFunc_t fNew
Definition TClass.h:235
@ kLoading
Definition TClass.h:332
@ kUnloading
Definition TClass.h:332
ROOT::ResetAfterMergeFunc_t GetResetAfterMerge() const
Return the wrapper around Merge.
Definition TClass.cxx:7439
TMethod * GetClassMethodWithPrototype(const char *name, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
Definition TClass.cxx:4527
Bool_t CanIgnoreTObjectStreamer()
Definition TClass.h:393
void SetGlobalIsA(IsAGlobalFunc_t)
This function installs a global IsA function for this class.
Definition TClass.cxx:6300
void GetMissingDictionariesForMembers(TCollection &result, TCollection &visited, bool recurse)
Verify the Data Members.
Definition TClass.cxx:3944
TObjArray * fStreamerInfo
Definition TClass.h:198
const ROOT::Detail::TSchemaRuleSet * GetSchemaRules() const
Return the set of the schema rules if any.
Definition TClass.cxx:1932
TObject * Clone(const char *newname="") const override
Create a Clone of this TClass object using a different name but using the same 'dictionary'.
Definition TClass.cxx:2406
TVirtualCollectionProxy * fCollectionProxy
Definition TClass.h:220
static ENewType IsCallingNew()
Static method returning the defConstructor flag passed to TClass::New().
Definition TClass.cxx:5902
TList * GetListOfBases()
Return list containing the TBaseClass(es) of a class.
Definition TClass.cxx:3636
void Store(TBuffer &b) const
Store class description on I/O buffer.
Definition TClass.cxx:5860
void InterpretedShowMembers(void *obj, TMemberInspector &insp, Bool_t isTransient)
Do a ShowMembers() traversal of all members and base classes' members using the reflection informatio...
Definition TClass.cxx:2242
static THashTable * fgClassTypedefHash
Definition TClass.h:338
void Init(const char *name, Version_t cversion, const std::type_info *info, TVirtualIsAProxy *isa, const char *dfil, const char *ifil, Int_t dl, Int_t il, ClassInfo_t *classInfo, Bool_t silent)
Initialize a TClass object.
Definition TClass.cxx:1369
std::atomic< TListOfDataMembers * > fData
Definition TClass.h:202
static void StreamerStreamerInfo(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of where we should directly use the StreamerInfo.
Definition TClass.cxx:6858
const TObjArray * GetStreamerInfos() const
Definition TClass.h:492
void SetClassVersion(Version_t version)
Private function.
Definition TClass.cxx:5675
char * EscapeChars(const char *text) const
Introduce an escape character (@) in front of a special chars.
Definition TClass.cxx:2568
const std::type_info * fTypeInfo
Definition TClass.h:224
std::atomic< TVirtualStreamerInfo * > fLastReadInfo
cached current streamer info.
Definition TClass.h:279
static void StreamerTObject(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects.
Definition TClass.cxx:6800
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition TClass.cxx:5912
@ kDefault
Definition TClass.h:334
@ kEmulatedStreamer
Definition TClass.h:334
@ kExternal
Definition TClass.h:334
@ kForeign
Definition TClass.h:334
@ kInstrumented
Definition TClass.h:334
@ kTObject
Definition TClass.h:334
static Bool_t AddRule(const char *rule)
Add a schema evolution customization rule.
Definition TClass.cxx:1890
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition TClass.cxx:5938
static void RemoveClass(TClass *cl)
static: Remove a class from the list and map of classes
Definition TClass.cxx:520
Bool_t HasLocalHashMember() const
Returns true if this class has an definition and/or overload of the member function Hash.
Definition TClass.cxx:7421
void DeleteArray(void *ary, Bool_t dtorOnly=kFALSE)
Explicitly call operator delete[] for an array.
Definition TClass.cxx:5529
ClassConvStreamerFunc_t GetConvStreamerFunc() const
Get a wrapper/accessor function around this class custom conversion streamer (member function).
Definition TClass.cxx:2947
Bool_t IsForeign() const
Return kTRUE is the class is Foreign (the class does not have a Streamer method).
Definition TClass.cxx:5947
ClassInfo_t * GetClassInfo() const
Definition TClass.h:433
ROOT::DelFunc_t fDelete
Definition TClass.h:237
TViewPubDataMembers * fAllPubData
Definition TClass.h:209
ClassInfo_t * fClassInfo
Definition TClass.h:222
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
Bool_t HasConsistentHashMember()
Return 'true' if we can guarantee that if this class (or any class in this class inheritance hierarch...
Definition TClass.h:501
void AdoptStreamer(TClassStreamer *strm)
Adopt a TClassStreamer object.
Definition TClass.cxx:6894
TClass * GetBaseDataMember(const char *datamember)
Return pointer to (base) class that contains datamember.
Definition TClass.cxx:2827
ECheckSum
Definition TClass.h:108
@ kLatestCheckSum
Definition TClass.h:117
@ kNoRange
Definition TClass.h:112
@ kCurrentCheckSum
Definition TClass.h:109
@ kNoBaseCheckSum
Definition TClass.h:116
@ kReflex
Definition TClass.h:114
@ kReflexNoComment
Definition TClass.h:111
@ kWithTypeDef
Definition TClass.h:113
@ kNoRangeCheck
Definition TClass.h:115
@ kNoEnum
Definition TClass.h:110
void Dump() const override
Dump contents of object on stdout.
Definition TClass.h:398
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition TClass.cxx:4874
Int_t GetBaseClassOffset(const TClass *toBase, void *address=nullptr, bool isDerivedObject=true)
Definition TClass.cxx:2791
ObjectPtr NewObjectArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
Definition TClass.cxx:5209
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2897
void ResetCaches()
To clean out all caches.
Definition TClass.cxx:4215
std::atomic< Bool_t > fVersionUsed
saved remember if fOffsetStreamer has been set.
Definition TClass.h:262
Long_t ClassProperty() const
Return the C++ property of this class, eg.
Definition TClass.cxx:2396
void SetStreamerImpl()
Internal routine to set fStreamerImpl based on the value of fStreamerType.
Definition TClass.cxx:6215
const char * GetSharedLibs()
Get the list of shared libraries containing the code for class cls.
Definition TClass.cxx:3623
void CalculateStreamerOffset() const
Calculate the offset between an object of this class to its base class TObject.
Definition TClass.cxx:2183
void GetMissingDictionariesForPairElements(TCollection &result, TCollection &visited, bool recurse)
Definition TClass.cxx:3973
void ReplaceWith(TClass *newcl) const
Definition TClass.cxx:4142
void RegisterAddressInRepository(const char *where, void *location, const TClass *what) const
Definition TClass.cxx:290
Long_t Property() const override
Returns the properties of the TClass as a bit field stored as a Long_t value.
Definition TClass.cxx:6086
Bool_t HasDefaultConstructor(Bool_t testio=kFALSE) const
Return true if we have access to a constructor usable for I/O.
Definition TClass.cxx:7393
void GetMenuItems(TList *listitems)
Returns list of methods accessible by context menu.
Definition TClass.cxx:3874
void SetNew(ROOT::NewFunc_t newFunc)
Install a new wrapper around 'new'.
Definition TClass.cxx:6985
std::atomic< TMethodCall * > fIsAMethod
Definition TClass.h:231
static Int_t ReadRules()
Read the class.rules files from the default location:.
Definition TClass.cxx:1820
Bool_t CanSplitBaseAllow()
Pointer to the function implementing streaming for this class.
Definition TClass.cxx:2247
void MoveAddressInRepository(const char *where, void *oldadd, void *newadd, const TClass *what) const
Definition TClass.cxx:337
std::atomic< StreamerImpl_t > fStreamerImpl
Definition TClass.h:287
void SetContextMenuTitle(const char *title)
Change (i.e. set) the title of the TNamed.
Definition TClass.cxx:6269
void SetMemberStreamer(const char *name, MemberStreamerFunc_t strm)
Install a new member streamer (p will be copied).
Definition TClass.cxx:6744
std::atomic< TClass ** > fPersistentRef
Definition TClass.h:194
IsAGlobalFunc_t fGlobalIsA
pointer to the class's IsA proxy.
Definition TClass.h:230
TVirtualStreamerInfo * GetConversionStreamerInfo(const char *onfile_classname, Int_t version) const
Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this clas...
Definition TClass.cxx:7086
Short_t GetImplFileLine() const
Definition TClass.h:457
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition TClass.cxx:4384
std::atomic< UChar_t > fRuntimeProperties
Definition TClass.h:273
@ kInterpreted
Definition TClass.h:126
@ kHasTClassInit
Definition TClass.h:127
@ kEmulated
Definition TClass.h:125
@ kNoInfo
Definition TClass.h:122
@ kLoaded
Definition TClass.h:130
@ kForwardDeclared
Definition TClass.h:124
@ kNamespaceForMeta
Definition TClass.h:131
TVirtualStreamerInfo * FindConversionStreamerInfo(const char *onfile_classname, UInt_t checksum) const
Return a Conversion StreamerInfo from the class 'classname' for the layout represented by 'checksum' ...
Definition TClass.cxx:7193
Int_t GetBaseClassOffsetRecurse(const TClass *toBase)
Return data member offset to the base class "cl".
Definition TClass.cxx:2705
ROOT::DelFunc_t GetDelete() const
Return the wrapper around delete ThiObject.
Definition TClass.cxx:7463
static TClass * LoadClassDefault(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition TClass.cxx:5771
void SetClassSize(Int_t sizof)
Definition TClass.h:307
TMethod * FindClassOrBaseMethodWithId(DeclId_t faddr)
Find a method with decl id in this class or its bases.
Definition TClass.cxx:4440
static void StreamerExternal(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
There is special streamer for the class.
Definition TClass.cxx:6788
Long_t fClassProperty
Property See TClass::Property() for details.
Definition TClass.h:256
TString fContextMenuTitle
Definition TClass.h:223
static void StreamerTObjectInitialized(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of TObjects when fIsOffsetStreamerSet is known to have been set.
Definition TClass.cxx:6814
static void ConvStreamerInstrumented(const TClass *pThis, void *object, TBuffer &b, const TClass *onfile_class)
Case of instrumented class with a library.
Definition TClass.cxx:6845
std::atomic< Bool_t > fCanLoadClassInfo
Whether info was loaded from a root pcm.
Definition TClass.h:260
void SetConvStreamerFunc(ClassConvStreamerFunc_t strm)
Set a wrapper/accessor function around this class custom conversion streamer.
Definition TClass.cxx:6945
TVirtualStreamerInfo * FindStreamerInfo(TObjArray *arr, UInt_t checksum) const
Find the TVirtualStreamerInfo in the StreamerInfos corresponding to checksum.
Definition TClass.cxx:7066
void GetMissingDictionaries(THashTable &result, bool recurse=false)
Get the classes that have a missing dictionary starting from this one.
Definition TClass.cxx:4087
void MakeCustomMenuList()
Makes a customizable version of the popup menu list, i.e.
Definition TClass.cxx:4283
TVirtualStreamerInfo * FindStreamerInfoAbstractEmulated(UInt_t checksum) const
For the case where the requestor class is emulated and this class is abstract, returns a pointer to t...
Definition TClass.cxx:4772
TMethod * GetMethodAny(const char *method)
Return pointer to method without looking at parameters.
Definition TClass.cxx:4374
TVirtualIsAProxy * GetIsAProxy() const
Return the proxy implementing the IsA functionality.
Definition TClass.cxx:2955
ROOT::MergeFunc_t GetMerge() const
Return the wrapper around Merge.
Definition TClass.cxx:7431
ROOT::ResetAfterMergeFunc_t fResetAfterMerge
Definition TClass.h:234
Bool_t IsFolder() const override
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition TClass.h:517
UInt_t fInstanceCount
Definition TClass.h:217
std::atomic< Bool_t > fHasRootPcmInfo
C++ Property of the class (is abstract, has virtual table, etc.)
Definition TClass.h:259
TClass * GetActualClass(const void *object) const
Return a pointer to the real class of the object.
Definition TClass.cxx:2607
ROOT::DesFunc_t fDestructor
Definition TClass.h:239
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
Definition TClass.cxx:3463
ObjectPtr NewObject(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Definition TClass.cxx:4992
TRealData * GetRealData(const char *name) const
Return pointer to TRealData element with name "name".
Definition TClass.cxx:3503
void SetDeleteArray(ROOT::DelArrFunc_t deleteArrayFunc)
Install a new wrapper around 'delete []'.
Definition TClass.cxx:7009
Bool_t fHasCustomStreamerMember
The class has a Streamer method and it is implemented by the user or an older (not StreamerInfo based...
Definition TClass.h:253
TFunctionTemplate * GetFunctionTemplate(const char *name)
Definition TClass.cxx:3607
void ResetClassInfo()
Make sure that the current ClassInfo is up to date.
Definition TClass.cxx:4180
ROOT::NewArrFunc_t fNewArray
Definition TClass.h:236
Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count)
Function called by the Streamer functions to deserialize information from buffer b into object at p.
Definition TClass.cxx:6758
void GetMissingDictionariesWithRecursionCheck(TCollection &result, TCollection &visited, bool recurse)
From the second level of recursion onwards it is different state check.
Definition TClass.cxx:3990
bool IsClassStructOrUnion() const
Definition TClass.h:354
@ kHasLocalHashMember
Definition TClass.h:96
@ kHasNameMapNode
Definition TClass.h:105
@ kIgnoreTObjectStreamer
Definition TClass.h:97
@ kUnloaded
Definition TClass.h:98
@ kWarned
Definition TClass.h:104
@ kStartWithTObject
Definition TClass.h:103
@ kIsTObject
Definition TClass.h:100
@ kIsForeign
Definition TClass.h:101
std::atomic< TListOfDataMembers * > fUsingData
Definition TClass.h:203
TListOfFunctions * GetMethodList()
Return (create an empty one if needed) the list of functions.
Definition TClass.cxx:4355
void ResetMenuList()
Resets the menu list to it's standard value.
Definition TClass.cxx:4243
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
Int_t WriteBuffer(TBuffer &b, void *pointer, const char *info="")
Function called by the Streamer functions to serialize object at p to buffer b.
Definition TClass.cxx:6779
static TClass * LoadClassCustom(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition TClass.cxx:5801
Short_t fImplFileLine
Definition TClass.h:216
static TClass * Class()
Collection abstract base class.
Definition TCollection.h:65
static TClass * Class()
void ls(Option_t *option="") const override
List (ls) all objects in this collection.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual void Add(TObject *obj)=0
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
All ROOT classes may have RTTI (run time type identification) support added.
Definition TDataMember.h:31
Int_t GetMaxIndex(Int_t dim) const
Return maximum index for array dimension "dim".
const char * GetTrueTypeName() const
Get the desugared type name of this data member, including const and volatile qualifiers.
Bool_t IsPersistent() const
Definition TDataMember.h:91
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
Int_t GetArrayDim() const
Return number of array dimensions.
Bool_t IsBasic() const
Return true if data member is a basic type, e.g. char, int, long...
Bool_t IsaPointer() const
Return true if data member is a pointer.
TDataType * GetDataType() const
Definition TDataMember.h:76
const char * GetTypeName() const
Get the decayed type name of this data member, removing const and volatile qualifiers,...
const char * GetFullTypeName() const
Get the concrete type name of this data member, including const and volatile qualifiers.
Basic data type descriptor (datatype information is obtained from CINT).
Definition TDataType.h:44
Int_t GetType() const
Definition TDataType.h:68
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
const char * AsString(void *buf) const
Return string containing value in buffer formatted according to the basic data type.
TString GetTypeName()
Get basic type of typedef, e,g.: "class TDirectory*" -> "TDirectory".
static TDataType * GetDataType(EDataType type)
Given a EDataType type, get the TDataType* that represents it.
static void GetDateTime(UInt_t datetime, Int_t &date, Int_t &time)
Static function that returns the date and time.
Definition TDatime.cxx:431
This class defines an abstract interface that must be implemented by all classes that contain diction...
EMemberSelection
Kinds of members to include in lists.
const void * DeclId_t
void Inspect(TClass *cl, const char *parent, const char *name, const void *addr, Bool_t isTransient) override
Print value of member mname.
Definition TClass.cxx:574
TDumpMembers(bool noAddr)
Definition TClass.cxx:557
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
Definition TEnum.cxx:175
@ kNone
Definition TEnum.h:48
This class stores a (key,value) pair using an external hash.
Definition TExMap.h:33
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition TExMap.cxx:174
void AddAt(UInt_t slot, ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table.
Definition TExMap.cxx:117
Dictionary for function template This class describes one single function template.
Global functions class (global functions are obtained from CINT).
Definition TFunction.h:30
Int_t GetNargs() const
Number of function arguments.
THashTable implements a hash table to store TObject's.
Definition THashTable.h:35
void Add(TObject *obj) override
Add object to the hash table.
const TList * GetListForObject(const char *name) const
Return the TList corresponding to object's name based hash value.
TObject * Remove(TObject *obj) override
Remove object from the hashtable.
virtual Bool_t ClassInfo_HasMethod(ClassInfo_t *, const char *) const
virtual const char * DataMemberInfo_Name(DataMemberInfo_t *) const
virtual const char * DataMemberInfo_TypeName(DataMemberInfo_t *) const
virtual int DataMemberInfo_TypeSize(DataMemberInfo_t *) const
virtual void * ClassInfo_New(ClassInfo_t *) const
virtual Bool_t ClassInfo_IsValid(ClassInfo_t *) const
virtual Int_t AutoParse(const char *cls)=0
virtual void ClassInfo_Delete(ClassInfo_t *) const
virtual void ClassInfo_DeleteArray(ClassInfo_t *, void *, bool) const
virtual Long_t ClassInfo_Property(ClassInfo_t *) const
virtual int ClassInfo_Size(ClassInfo_t *) const
virtual const char * ClassInfo_FullName(ClassInfo_t *) const
virtual int SetClassAutoLoading(int) const
virtual const char * ClassInfo_Title(ClassInfo_t *) const
virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *) const
virtual int DataMemberInfo_Next(DataMemberInfo_t *) const
virtual DataMemberInfo_t * DataMemberInfo_Factory(ClassInfo_t *, TDictionary::EMemberSelection) 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
TDictionary::DeclId_t DeclId_t
virtual Bool_t ClassInfo_HasDefaultConstructor(ClassInfo_t *, Bool_t=kFALSE) const
virtual Long_t ClassInfo_ClassProperty(ClassInfo_t *) const
virtual Longptr_t ClassInfo_GetBaseOffset(ClassInfo_t *, ClassInfo_t *, void *=nullptr, bool=true) const
virtual void ClassInfo_Destruct(ClassInfo_t *, void *) const
TIsAProxy implementation class.
Definition TIsAProxy.h:27
void Reset()
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
static TClass * Class()
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TObject * FindObject(const char *name) const override
Specialize FindObject to do search for the a function just by name or create it if its not already in...
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
void Delete(Option_t *option="") override
Delete all TFunction object files.
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
virtual TList * GetListForObject(const char *name) const
Return the set of overloads for this name, collecting all available ones.
TObject * FindObject(const TObject *obj) const override
Find object using its hash value (returned by its Hash() member).
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
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:822
void AddLast(TObject *obj) override
Add object at the end of the list.
Definition TList.cxx:152
virtual TObjLink * FirstLink() const
Definition TList.h:102
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:470
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition TList.cxx:100
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...
Definition TMap.h:40
Abstract base class for accessing the data-members of a class.
virtual void Inspect(TClass *cl, const char *parent, const char *name, const void *addr)
Each ROOT method (see TMethod) has a linked list of its arguments.
Definition TMethodArg.h:36
const char * GetFullTypeName() const
Get full type description of method argument, e.g.: "class TDirectory*".
Each ROOT class (see TClass) has a linked list of methods.
Definition TMethod.h:38
TClass * GetClass() const
Definition TMethod.h:55
EMenuItemKind IsMenuItem() const
Definition TMethod.h:56
virtual TList * GetListOfMethodArgs()
Returns methodarg list and additionally updates fDataMember in TMethod by calling FindDataMember();.
Definition TMethod.cxx:307
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition TNamed.cxx:74
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
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 fName
Definition TNamed.h:32
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140
void ls(Option_t *option="") const override
List TNamed name and title.
Definition TNamed.cxx:113
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.
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
Int_t GetEntries() const override
Return the number of objects in array (i.e.
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
TObject * UncheckedAt(Int_t i) const
Definition TObjArray.h:84
TObject * RemoveAt(Int_t idx) override
Remove object at index idx.
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
Int_t GetLast() const override
Return index of last object in array.
Int_t LowerBound() const
Definition TObjArray.h:91
void Add(TObject *obj) override
Definition TObjArray.h:68
Collectable string class.
Definition TObjString.h:28
Mother of all ROOT objects.
Definition TObject.h:41
static void SetObjectStat(Bool_t stat)
Turn on/off tracking of objects in the TObjectTable.
Definition TObject.cxx:1068
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
virtual void Browse(TBrowser *b)
Browse object. May be overridden for another default action.
Definition TObject.cxx:198
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:199
virtual void Streamer(TBuffer &)
Stream an object of class TObject.
Definition TObject.cxx:888
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:973
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:403
static TClass * Class()
R__ALWAYS_INLINE Bool_t IsZombie() const
Definition TObject.h:153
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
static Bool_t GetObjectStat()
Get status of object stat flag.
Definition TObject.cxx:1061
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:987
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:1015
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition TObject.cxx:791
virtual TClass * IsA() const
Definition TObject.h:243
void MakeZombie()
Definition TObject.h:53
void ResetBit(UInt_t f)
Definition TObject.h:198
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:961
Class used by TMap to store (key,value) pairs.
Definition TMap.h:102
Persistent version of a TClass.
Definition TProtoClass.h:38
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition TROOT.cxx:3031
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
void AdoptStreamer(TMemberStreamer *p)
Definition TRealData.cxx:67
Long_t GetThisOffset() const
Definition TRealData.h:55
void SetIsObject(Bool_t isObject)
Definition TRealData.h:57
static TClass * Class()
static TClass * Class()
TClass * GetClassPointer() const override
Returns a pointer to the TClass of this element.
static TClass * Class()
Int_t GetType() const
virtual const char * GetFullName() const
Return element name including dimensions, if any Note that this function stores the name into a stati...
virtual TClass * GetClassPointer() const
Returns a pointer to the TClass of this element.
Int_t GetArrayDim() const
virtual Bool_t IsaPointer() const
const char * GetTypeName() const
TClass * IsA() const override
Int_t GetOffset() const
virtual Bool_t IsBase() const
Return kTRUE if the element represent a base class.
static TClass * Class()
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:421
TString & Replace(Ssiz_t pos, Ssiz_t n, const char *s)
Definition TString.h:694
const char * Data() const
Definition TString.h:380
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:704
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:627
Bool_t IsNull() const
Definition TString.h:418
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition TString.cxx:670
TString & Remove(Ssiz_t pos)
Definition TString.h:685
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2356
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2334
static TClass * Class()
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:636
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1068
View implementing the TList interface and giving access all the TDictionary describing public data me...
void Load()
Load all the DataMembers known to the interpreter for the scope 'fClass' and all its bases classes.
void Delete(Option_t *option="") override
Delete is not allowed in this class.
View implementing the TList interface and giving access all the TFunction describing public methods i...
void Load()
Load all the functions known to the interpreter for the scope 'fClass' and all its bases classes.
void Delete(Option_t *option="") override
Delete is not allowed in this class.
RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++...
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 UInt_t Sizeof() const =0
Return the sizeof() of the collection object.
virtual TClass::ObjectPtr NewObjectArray(Int_t nElements) const
Construct an array of nElements container objects and return the base address of the array.
virtual void Destructor(void *p, Bool_t dtorOnly=kFALSE) const
Execute the container destructor.
virtual void DeleteArray(void *p, Bool_t dtorOnly=kFALSE) const
Execute the container array destructor.
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 TClass::ObjectPtr NewObject() const
Construct a new container object and return its address.
virtual void * At(UInt_t idx)=0
Return the address of the value at index idx
virtual UInt_t Size() const =0
Return the current number of elements in the container.
virtual TVirtualCollectionProxy * Generate() const =0
Returns a clean object of the actual class that derives from TVirtualCollectionProxy.
virtual Bool_t Reset()
Reset the information gathered from StreamerInfos and value's TClass.
virtual Bool_t HasPointers() const =0
Return true if the content is of type 'pointer to'.
virtual void SetClass(TClass *cl)=0
This class implements a mutex interface.
small helper class to store/restore gPad context in TPad methods
Definition TVirtualPad.h:61
auto GetSaved() const
Definition TVirtualPad.h:69
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
virtual TVirtualPad * cd(Int_t subpadnumber=0)=0
virtual void DrawClassObject(const TObject *obj, Option_t *option="")=0
virtual void Release()=0
virtual void SetClass(TClass *classptr)=0
virtual TVirtualRefProxy * Clone() const =0
Abstract Interface class describing Streamer information for one class.
virtual TVirtualStreamerInfo * GenerateInfoForPair(const std::string &pairclassname, bool silent, size_t hint_pair_offset, size_t hint_pair_size)=0
Generate the TClass and TStreamerInfo for the requested pair.
virtual void DeleteArray(void *p, Bool_t dtorOnly=kFALSE)=0
virtual void Clear(Option_t *="") override=0
Set name and title to empty strings ("").
virtual void SetClassVersion(Int_t vers)=0
virtual TClassStreamer * GenEmulatedClassStreamer(const char *class_name, Bool_t silent)=0
virtual TVirtualStreamerInfo * NewInfo(TClass *cl)=0
virtual TClass * GetActualClass(const void *obj) const =0
virtual UInt_t GetCheckSum() const =0
virtual Int_t GetOffset(const char *) const =0
static const char * GetElementCounterStart(const char *dmTitle)
Given a comment/title declaring an array counter, for example:
virtual void Build(Bool_t isTransient=kFALSE)=0
virtual void BuildCheck(TFile *file=nullptr, Bool_t load=kTRUE)=0
virtual Bool_t BuildFor(const TClass *cl)=0
virtual TVirtualCollectionProxy * GenExplicitProxy(const ::ROOT::Detail::TCollectionProxyInfo &info, TClass *cl)=0
virtual void * NewArray(Long_t nElements, void *ary=nullptr)=0
virtual TVirtualCollectionProxy * GenEmulatedProxy(const char *class_name, Bool_t silent)=0
virtual void SetClass(TClass *cl)=0
virtual TObjArray * GetElements() const =0
virtual Int_t GetSize() const =0
virtual void BuildOld()=0
static TVirtualStreamerInfo * Factory()
Static function returning a pointer to a new TVirtualStreamerInfo object.
virtual void * New(void *obj=nullptr)=0
virtual Version_t GetOldVersion() const =0
virtual Int_t GetOnFileClassVersion() const =0
virtual void Destructor(void *p, Bool_t dtorOnly=kFALSE)=0
virtual Bool_t CompareContent(TClass *cl, TVirtualStreamerInfo *info, Bool_t warn, Bool_t complete, TFile *file)=0
virtual Int_t GetClassVersion() const =0
virtual void Update(const TClass *oldClass, TClass *newClass)=0
virtual TClass * GetClass() const =0
TLine * line
return c1
Definition legend1.C:41
R__EXTERN void * gMmallocDesc
Definition TStorage.h:143
Bool_t HasConsistentHashMember(TClass &clRef)
Return true is the Hash/RecursiveRemove setup is consistent, i.e.
Definition TClass.cxx:7371
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
void(* DirAutoAdd_t)(void *, TDirectory *)
Definition Rtypes.h:114
R__EXTERN TVirtualRWMutex * gCoreMutex
void(* ResetAfterMergeFunc_t)(void *, TFileMergeInfo *)
Definition Rtypes.h:116
@ kClassThreadSlot
void(* DesFunc_t)(void *)
Definition Rtypes.h:113
TClass * CreateClass(const char *cname, Version_t id, const std::type_info &info, TVirtualIsAProxy *isa, const char *dfil, const char *ifil, Int_t dl, Int_t il)
Global function called by a class' static Dictionary() method (see the ClassDef macro).
Definition TClass.cxx:5869
void(* DelFunc_t)(void *)
Definition Rtypes.h:111
ESTLType
Definition ESTLType.h:28
@ kNotSTL
Definition ESTLType.h:29
void *(* NewArrFunc_t)(Long_t size, void *arena)
Definition Rtypes.h:110
void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector &)
Indirect call to the implementation of ShowMember allowing [forward] declaration with out a full defi...
Definition TClass.cxx:546
EFunctionMatchMode
@ kExactMatch
void(* DelArrFunc_t)(void *)
Definition Rtypes.h:112
void *(* NewFunc_t)(void *)
Definition Rtypes.h:109
Long64_t(* MergeFunc_t)(void *, TCollection *, TFileMergeInfo *)
Definition Rtypes.h:115
bool IsStdPairBase(std::string_view name)
Definition TClassEdit.h:196
std::string ResolveTypedef(const char *tname, bool resolveAll=false)
bool IsStdArray(std::string_view name)
Definition TClassEdit.h:189
bool IsStdClass(const char *type)
return true if the class belongs to the std namespace
bool IsStdPair(std::string_view name)
Definition TClassEdit.h:191
bool IsInterpreterDetail(const char *type)
Return true if the type is one the interpreter details which are only forward declared (ClassInfo_t e...
char * DemangleTypeIdName(const std::type_info &ti, int &errorCode)
Demangle in a portable way the type id name.
ROOT::ESTLType IsSTLCont(std::string_view type)
type : type name: vector<list<classA,allocator>,allocator> result: 0 : not stl container code of cont...
std::string ShortType(const char *typeDesc, int mode)
Return the absolute type of typeDesc.
bool IsArtificial(std::string_view name)
Definition TClassEdit.h:159
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
@ kDropStlDefault
Definition TClassEdit.h:82
bool IsSTLBitset(const char *type)
Return true is the name is std::bitset<number> or bitset<number>
UInt_t Find(std::list< std::pair< const Node< T > *, Float_t > > &nlist, const Node< T > *node, const T &event, UInt_t nfind)
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:198
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.
Definition first.py:1
static const char * what
Definition stlLoader.cc:6
bool IsTemplate()
Check if the type is a template.
std::vector< std::string > fElements
Definition TClassEdit.h:141
TVirtualStreamerInfo * GetAllocator() const
Definition TClass.h:149
void * GetPtr() const
Definition TClass.h:147
TClass::ENewType & fCurrentValue
Definition TClass.cxx:274
TClass__GetCallingNewRAII(TClass::ENewType newvalue)
Definition TClass.cxx:277
TClass::ENewType fOldValue
Definition TClass.cxx:275
TMarker m
Definition textangle.C:8
TLine l
Definition textangle.C:4