|
ROOT
Reference Guide |
|
Go to the documentation of this file.
62 TClassRec(TClassRec *next) :
63 fName(0), fId(0), fDict(0), fInfo(0), fProto(0), fNext(next)
77 const std::type_info *fInfo;
84 TClassAlt(
const char*alternate,
const char *normName, TClassAlt *next) :
85 fName(alternate), fNormName(normName), fNext(next)
93 const char *fNormName;
94 std::unique_ptr<TClassAlt> fNext;
97 #define R__USE_STD_MAP
98 class TMapTypeToClassRec {
99 #if defined R__USE_STD_MAP
103 typedef std::map<std::string, TClassRec*>
IdMap_t;
104 typedef IdMap_t::key_type key_type;
105 typedef IdMap_t::const_iterator const_iterator;
106 typedef IdMap_t::size_type size_type;
109 typedef TClassRec* mapped_type;
111 typedef IdMap_t::mapped_type mapped_type;
118 void Add(
const key_type &key, mapped_type &obj) {
122 mapped_type
Find(
const key_type &key)
const {
124 IdMap_t::const_iterator iter = fMap.find(key);
126 if (iter != fMap.end()) cl = iter->second;
130 void Remove(
const key_type &key) { fMap.erase(key); }
133 Info(
"TMapTypeToClassRec::Print",
"printing the typeinfo map in TClassTable");
134 for (const_iterator iter = fMap.begin(); iter != fMap.end(); ++iter) {
135 printf(
"Key: %40s 0x%lx\n", iter->first.c_str(), (
unsigned long)iter->second);
142 #ifdef R__COMPLETE_MEM_TERMINATION
143 ~TMapTypeToClassRec() {
152 void Add(
const char *key, TClassRec *&obj)
160 TClassRec *
Find(
const char *key)
const {
163 if (
a)
return (TClassRec*)
a->Value();
167 void Remove(
const char *key) {
176 Info(
"TMapTypeToClassRec::Print",
"printing the typeinfo map in TClassTable");
181 TClassRec *data = (TClassRec*)fMap.
GetValue(key);
183 printf(
" class: %s %d\n",data->fName,data->fId);
185 printf(
" no class: \n");
194 auto p =
reinterpret_cast<const unsigned char*
>(
name );
197 while (*p) slot = slot<<1 ^ *p++;
205 static std::vector<std::unique_ptr<TClassRec>> delayedAddClass;
206 return delayedAddClass;
211 static std::vector<std::pair<const char *, const char *>> delayedAddClassAlternate;
212 return delayedAddClassAlternate;
224 fgTable =
new TClassRec* [fgSize];
225 fgAlternate =
new TClassAlt* [fgSize];
227 memset(fgTable, 0, fgSize*
sizeof(TClassRec*));
228 memset(fgAlternate, 0, fgSize*
sizeof(TClassAlt*));
237 AddAlternate(
r.first,
r.second);
250 for (
UInt_t i = 0; i < fgSize; i++) {
253 delete [] fgTable; fgTable = 0;
254 delete [] fgSortedTable; fgSortedTable = 0;
255 delete fgIdMap; fgIdMap = 0;
282 if (fgTally == 0 || !fgTable)
287 int n = 0, ninit = 0, nl = 0;
289 int nch = strlen(option);
292 Printf(
"\nDefined classes");
293 Printf(
"class version bits initialized");
294 Printf(
"================================================================");
295 for (
UInt_t i = 0; i < fgTally; i++) {
296 TClassRec *
r = fgSortedTable[i];
300 if (nch && strcmp(option,
r->fName) &&
s.Index(re) ==
kNPOS)
continue;
308 Printf(
"----------------------------------------------------------------");
309 Printf(
"Listed Classes: %4d Total classes: %4d initialized: %4d",nl,
n, ninit);
310 Printf(
"================================================================\n");
324 if (index < fgTally) {
325 TClassRec *
r = fgSortedTable[index];
326 if (
r)
return r->fName;
336 namespace ROOT {
class TForNamespace {}; }
348 if (!cname || *cname == 0)
349 ::Fatal(
"TClassTable::Add()",
"Failed to deduce type for '%s'", info.name());
352 TClassRec *
r = FindElementImpl(cname,
kTRUE);
353 if (
r->fName &&
r->fInfo) {
354 if ( strcmp(
r->fInfo->name(),
typeid(ROOT::TForNamespace).name())==0
355 && strcmp(info.name(),
typeid(ROOT::TForNamespace).name())==0 ) {
362 ::Warning(
"TClassTable::Add",
"class %s already in TClassTable", cname);
382 if (!
r->fName)
r->fName =
StrDup(cname);
388 fgIdMap->Add(info.name(),
r);
403 const char *cname =
proto->GetName();
406 TClassRec *
r = FindElementImpl(cname,
kTRUE);
408 if (
r->fProto)
delete r->fProto;
412 proto->FillTClass(oldcl);
422 ::Warning(
"TClassTable::Add(TProtoClass*)",
"Called for existing class without a prior call add the dictionary function.");
445 for (
const TClassAlt *
a = fgAlternate[slot];
a;
a =
a->fNext.get()) {
446 if (strcmp(alternate,
a->fName)==0) {
447 if (strcmp(normName,
a->fNormName) != 0) {
448 fprintf(stderr,
"Error in TClassTable::AddAlternate: "
449 "Second registration of %s with a different normalized name (old: '%s', new: '%s')\n",
450 alternate,
a->fNormName, normName);
456 fgAlternate[slot] =
new TClassAlt(alternate,normName,fgAlternate[slot]);
463 if (!CheckClassTableInit())
return kFALSE;
468 for (TClassRec *
r = fgTable[slot];
r;
r =
r->fNext)
469 if (strcmp(cname,
r->fName)==0)
return kTRUE;
472 for (
const TClassAlt *
a = fgAlternate[slot];
a;
a =
a->fNext.get()) {
473 if (strcmp(cname,
a->fName)==0) {
474 normname =
a->fNormName;
488 if (!CheckClassTableInit())
return;
494 for (
r = fgTable[slot];
r;
r =
r->fNext) {
495 if (!strcmp(
r->fName, cname)) {
497 prev->fNext =
r->fNext;
499 fgTable[slot] =
r->fNext;
500 fgIdMap->Remove(
r->fInfo->name());
520 for (TClassRec *
r = fgTable[slot];
r;
r =
r->fNext)
521 if (strcmp(cname,
r->fName)==0)
return r;
523 if (!insert)
return 0;
525 fgTable[slot] =
new TClassRec(fgTable[slot]);
528 return fgTable[slot];
540 if (!CheckClassTableInit())
return nullptr;
544 std::string normalized;
547 return FindElementImpl(normalized.c_str(), insert);
555 TClassRec *
r = FindElement(cname);
556 if (
r)
return r->fId;
565 TClassRec *
r = FindElement(cname);
577 ::Info(
"GetDict",
"searches for %s", cname);
581 TClassRec *
r = FindElement(cname);
582 if (
r)
return r->fDict;
592 if (!CheckClassTableInit())
return nullptr;
595 ::Info(
"GetDict",
"searches for %s at 0x%lx", info.name(), (
Long_t)&info);
599 TClassRec *
r = fgIdMap->Find(info.name());
600 if (
r)
return r->fDict;
610 if (!CheckClassTableInit())
return nullptr;
613 ::Info(
"GetDict",
"searches for %s", cname);
617 TClassRec *
r = FindElementImpl(cname,
kFALSE);
618 if (
r)
return r->fDict;
629 ::Info(
"GetDict",
"searches for %s", cname);
632 if (!CheckClassTableInit())
return nullptr;
635 ::Info(
"GetDict",
"searches for %s", cname);
639 TClassRec *
r = FindElement(cname);
640 if (
r)
return r->fProto;
651 ::Info(
"GetDict",
"searches for %s", cname);
654 if (!CheckClassTableInit())
return nullptr;
660 TClassRec *
r = FindElementImpl(cname,
kFALSE);
661 if (
r)
return r->fProto;
672 return strcmp((*(TClassRec **)
a)->fName, (*(TClassRec **)
b)->fName);
683 if (fgCursor < fgTally) {
684 TClassRec *
r = fgSortedTable[fgCursor++];
696 if (fgTally == 0 || !fgTable)
701 int n = 0, ninit = 0;
703 Printf(
"\nDefined classes");
704 Printf(
"class version bits initialized");
705 Printf(
"================================================================");
707 for (
UInt_t i = 0; i < last; i++) {
708 TClassRec *
r = fgSortedTable[i];
712 if (
gROOT->GetListOfClasses()->FindObject(
r->fName)) {
718 Printf(
"----------------------------------------------------------------");
719 Printf(
"Total classes: %4d initialized: %4d",
n, ninit);
720 Printf(
"================================================================\n");
729 delete [] fgSortedTable;
730 fgSortedTable =
new TClassRec* [fgTally];
733 for (
UInt_t i = 0; i < fgSize; i++)
734 for (TClassRec *
r = fgTable[i];
r;
r =
r->fNext)
735 fgSortedTable[j++] =
r;
737 ::qsort(fgSortedTable, fgTally,
sizeof(TClassRec *), ::
ClassComp);
748 for (
UInt_t i = 0; i < fgSize; i++)
751 delete [] fgTable; fgTable = 0;
752 delete [] fgSortedTable; fgSortedTable = 0;
753 delete fgIdMap; fgIdMap = 0;
764 const std::type_info& info,
769 auto r = std::unique_ptr<TClassRec>(
new TClassRec(
nullptr));
810 if (cname && cname!=(
void*)-1) {
812 if (
r)
r->fId = newid;
817 if (cname!=(
void*)-1)
818 Error(
"ResetClassVersion",
"Version number of %s can not be changed after first usage!",
822 Error(
"SetClassVersion",
"The class version (for %s) must be positive (value %d is ignored)",cl->
GetName(),newid);
824 if (cname==(
void*)-1) {
852 if ((pcname=
gROOT->GetListOfClasses()->FindObject(cname))) {
877 if (loc >= 1) classname.
Remove(loc);
Class used by TMap to store (key,value) pairs.
std::vector< std::unique_ptr< TClassRec > > & GetDelayedAddClass()
static ROOT::TClassAlt ** fgAlternate
void Print(std::ostream &os, const OptionType &opt)
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
void AddClass(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits)
Global function called by the ctor of a class's init class (see the ClassImp macro).
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
const char * Data() const
ROOT::TMapTypeToClassRec IdMap_t
static Version_t GetID(const char *cname)
Returns the ID of a class.
static Bool_t CheckClassTableInit()
Return true fs the table exist.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
bool IsStdClass(const char *type)
return true if the class belongs to the std namespace
TNamed * RegisterClassTemplate(const char *name, const char *file, Int_t line)
Global function to register the implementation file and line of a class template (i....
TObject * GetValue(const char *keyname) const
Returns a pointer to the value associated with keyname as name of the key.
static constexpr double s
UInt_t Find(std::list< std::pair< const Node< T > *, Float_t > > &nlist, const Node< T > *node, const T &event, UInt_t nfind)
static Bool_t Check(const char *cname, std::string &normname)
TClassTable * gClassTable
void SetClassVersion(Version_t version)
Private function.
void Add(TObject *obj)
This function may not be used (but we need to provide it since it is a pure virtual in TCollection).
TClassTable()
TClassTable is a singleton (i.e. only one can exist per application).
static void Add(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits)
Add a class to the class table (this is a static function).
static ROOT::TClassRec ** fgTable
static void AddAlternate(const char *normname, const char *alternate)
static UInt_t ClassTableHash(const char *name, UInt_t size)
Collectable string class.
void RemoveClass(const char *cname)
Global function called by the dtor of a class's init class (see the ClassImp macro).
Persistent version of a TClass.
void AddClassAlternate(const char *normName, const char *alternate)
Global function called by GenerateInitInstance.
void Print(Option_t *option="") const
Print the class table.
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
static void Terminate()
Deletes the class table (this static class function calls the dtor).
TString & Remove(Ssiz_t pos)
The TNamed class is the base class for all named ROOT classes.
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
TObject * FindObject(const char *keyname) const
Check if a (key,value) pair exists with keyname as name of the key.
TObject * Remove(TObject *key)
Remove the (key,value) pair with key from the map.
char * StrDup(const char *str)
Duplicate the string str.
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.
R__EXTERN TROOT * gROOTLocal
static char * Next()
Returns next class from sorted class table.
static void PrintTable()
Print the class table.
static DictFuncPtr_t GetDict(const char *cname)
Given the class name returns the Dictionary() function of a class (uses hash of name).
std::vector< std::pair< const char *, const char * > > & GetDelayedAddClassAlternate()
Regular expression class.
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
void Printf(const char *fmt,...)
virtual void RegisterTClassUpdate(TClass *oldcl, DictFuncPtr_t dict)=0
UInt_t fBits
bit field status word
static void Remove(const char *cname)
Remove a class from the class table.
void SetUnloaded()
Call this method to indicate that the shared library containing this class's code has been removed (u...
This class registers for all classes their name, id and dictionary function in a hash table.
static ROOT::TClassRec * FindElement(const char *cname, Bool_t insert=kFALSE)
Find a class by name in the class table (using hash of name).
static Int_t GetPragmaBits(const char *name)
Returns the pragma bits as specified in the LinkDef.h file.
~TClassTable()
TClassTable singleton is deleted in Terminate().
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
TClass instances represent classes, structs and namespaces in the ROOT type system.
static char * At(UInt_t index)
Returns class at index from sorted class table.
virtual void Add(TObject *obj)
Mother of all ROOT objects.
R__EXTERN TInterpreter * gCling
void ResetClassVersion(TClass *, const char *, Short_t)
Global function to update the version number.
void Add(RHist< DIMENSIONS, PRECISION, STAT_TO... > &to, const RHist< DIMENSIONS, PRECISION, STAT_FROM... > &from)
Add two histograms.
TClass *(* DictFuncPtr_t)()
virtual const char * GetName() const
Returns name of object.
static DictFuncPtr_t GetDictNorm(const char *cname)
Given the normalized class name returns the Dictionary() function of a class (uses hash of name).
static ROOT::TClassRec * FindElementImpl(const char *cname, Bool_t insert)
Find a class by name in the class table (using hash of name).
std::atomic< Bool_t > fVersionUsed
saved remember if fOffsetStreamer has been set.
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
static ROOT::TClassRec ** fgSortedTable
static int ClassComp(const void *a, const void *b)
static TProtoClass * GetProtoNorm(const char *cname)
Given the class normalized name returns the TClassProto object for the class.
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
static void SortTable()
Sort the class table by ascending class ID's.
static TProtoClass * GetProto(const char *cname)
Given the class name returns the TClassProto object for the class.
ROOT::TMapTypeToTClass IdMap_t
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...