Logo ROOT  
Reference Guide
TListOfFunctions.cxx
Go to the documentation of this file.
1 // @(#)root/cont
2 // Author: Philippe Canal Aug 2013
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2013, 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 TListOfFunctions
13 A collection of TFunction objects designed for fast access given a
14 DeclId_t and for keep track of TFunction that were described
15 unloaded function.
16 */
17 
18 #include "TListOfFunctions.h"
19 #include "TClass.h"
20 #include "TExMap.h"
21 #include "TFunction.h"
22 #include "TMethod.h"
23 #include "TInterpreter.h"
24 #include "TVirtualMutex.h"
25 
27 
28 ////////////////////////////////////////////////////////////////////////////////
29 /// Constructor.
30 
31 TListOfFunctions::TListOfFunctions(TClass *cl) : fClass(cl),fIds(0),fUnloaded(0),fLastLoadMarker(0)
32 {
33  fIds = new TExMap;
34  fUnloaded = new THashList;
35 }
36 
37 ////////////////////////////////////////////////////////////////////////////////
38 /// Destructor.
39 
41 {
43  delete fIds;
44  fUnloaded->Delete();
45  delete fUnloaded;
46 }
47 
48 ////////////////////////////////////////////////////////////////////////////////
49 /// Add pair<id, object> to the map of functions and their ids.
50 
52 {
53  TFunction *f = dynamic_cast<TFunction*>(obj);
54  if (f) {
55  fIds->Add((Long64_t)f->GetDeclId(),(Long64_t)f);
56  }
57 }
58 
59 ////////////////////////////////////////////////////////////////////////////////
60 /// Add object at the beginning of the list.
61 
63 {
65  MapObject(obj);
66 }
67 
68 ////////////////////////////////////////////////////////////////////////////////
69 /// Add object at the beginning of the list and also store option.
70 /// Storing an option is useful when one wants to change the behaviour
71 /// of an object a little without having to create a complete new
72 /// copy of the object. This feature is used, for example, by the Draw()
73 /// method. It allows the same object to be drawn in different ways.
74 
76 {
77  THashList::AddFirst(obj,opt);
78  MapObject(obj);
79 }
80 
81 ////////////////////////////////////////////////////////////////////////////////
82 /// Add object at the end of the list.
83 
85 {
86  THashList::AddLast(obj);
87  MapObject(obj);
88 }
89 
90 ////////////////////////////////////////////////////////////////////////////////
91 /// Add object at the end of the list and also store option.
92 /// Storing an option is useful when one wants to change the behaviour
93 /// of an object a little without having to create a complete new
94 /// copy of the object. This feature is used, for example, by the Draw()
95 /// method. It allows the same object to be drawn in different ways.
96 
98 {
99  THashList::AddLast(obj, opt);
100  MapObject(obj);
101 }
102 
103 ////////////////////////////////////////////////////////////////////////////////
104 /// Insert object at location idx in the list.
105 
107 {
108  THashList::AddAt(obj, idx);
109  MapObject(obj);
110 }
111 
112 ////////////////////////////////////////////////////////////////////////////////
113 /// Insert object after object after in the list.
114 
116 {
117  THashList::AddAfter(after, obj);
118  MapObject(obj);
119 }
120 
121 ////////////////////////////////////////////////////////////////////////////////
122 /// Insert object after object after in the list.
123 
125 {
126  THashList::AddAfter(after, obj);
127  MapObject(obj);
128 }
129 
130 ////////////////////////////////////////////////////////////////////////////////
131 /// Insert object before object before in the list.
132 
133 void TListOfFunctions::AddBefore(const TObject *before, TObject *obj)
134 {
135  THashList::AddBefore(before, obj);
136  MapObject(obj);
137 }
138 
139 ////////////////////////////////////////////////////////////////////////////////
140 /// Insert object before object before in the list.
141 
143 {
144  THashList::AddBefore(before, obj);
145  MapObject(obj);
146 }
147 
148 ////////////////////////////////////////////////////////////////////////////////
149 /// Remove all objects from the list. Does not delete the objects unless
150 /// the THashList is the owner (set via SetOwner()).
151 
153 {
154  fUnloaded->Clear(option);
155  fIds->Clear();
156  THashList::Clear(option);
157 }
158 
159 ////////////////////////////////////////////////////////////////////////////////
160 /// Delete all TFunction object files.
161 
162 void TListOfFunctions::Delete(Option_t *option /* ="" */)
163 {
164  fUnloaded->Delete(option);
165  fIds->Clear();
166  THashList::Delete(option);
167 }
168 
169 ////////////////////////////////////////////////////////////////////////////////
170 /// Specialize FindObject to do search for the
171 /// a function just by name or create it if its not already in the list
172 
174 {
177  if (!result) {
178 
180  if (fClass) decl = gInterpreter->GetFunction(fClass->GetClassInfo(),name);
181  else decl = gInterpreter->GetFunction(0,name);
182  if (decl) result = const_cast<TListOfFunctions*>(this)->Get(decl);
183  }
184  return result;
185 }
186 
187 ////////////////////////////////////////////////////////////////////////////////
188 /// Return the set of overloads for this name, collecting all available ones.
189 /// Can construct and insert new TFunction-s.
190 
192 {
194 
195  TList* overloads = (TList*)fOverloads.FindObject(name);
196  TExMap overloadsSet;
197  Bool_t wasEmpty = true;
198  if (!overloads) {
199  overloads = new TList();
200  overloads->SetName(name);
201  fOverloads.Add(overloads);
202  } else {
203  TIter iOverload(overloads);
204  while (TFunction* over = (TFunction*)iOverload()) {
205  wasEmpty = false;
206  overloadsSet.Add((Long64_t)(ULong64_t)over->GetDeclId(),
207  (Long64_t)(ULong64_t)over);
208  }
209  }
210 
211  // Update if needed.
212  std::vector<DeclId_t> overloadDecls;
213  ClassInfo_t* ci = fClass ? fClass->GetClassInfo() : 0;
214  gInterpreter->GetFunctionOverloads(ci, name, overloadDecls);
215  for (std::vector<DeclId_t>::const_iterator iD = overloadDecls.begin(),
216  eD = overloadDecls.end(); iD != eD; ++iD) {
217  TFunction* over = Get(*iD);
218  if (wasEmpty || !overloadsSet.GetValue((Long64_t)(ULong64_t)over->GetDeclId())) {
219  overloads->Add(over);
220  }
221  }
222 
223  return overloads;
224 }
225 
226 ////////////////////////////////////////////////////////////////////////////////
227 /// Return the set of overloads for this name, collecting all available ones.
228 /// Can construct and insert new TFunction-s.
229 
231 {
232  return const_cast<TListOfFunctions*>(this)->GetListForObjectNonConst(name);
233 }
234 
235 ////////////////////////////////////////////////////////////////////////////////
236 /// Return the set of overloads for function obj, collecting all available ones.
237 /// Can construct and insert new TFunction-s.
238 
240 {
241  if (!obj) return 0;
242  return const_cast<TListOfFunctions*>(this)
244 }
245 
246 ////////////////////////////////////////////////////////////////////////////////
247 /// Return the TMethod or TFunction describing the function corresponding
248 /// to the Decl 'id'. Return NULL if not found.
249 
251 {
252  if (!id) return 0;
253 
255  return (TFunction*)fIds->GetValue((Long64_t)id);
256 }
257 
258 ////////////////////////////////////////////////////////////////////////////////
259 /// Return (after creating it if necessary) the TMethod or TFunction
260 /// describing the function corresponding to the Decl 'id'.
261 
263 {
264  if (!id) return 0;
265 
267  //need the Find and possible Add to be one atomic operation
268  TFunction *f = Find(id);
269  if (f) return f;
270 
271  if (fClass) {
272  if (!gInterpreter->ClassInfo_Contains(fClass->GetClassInfo(),id)) return 0;
273  } else {
274  if (!gInterpreter->ClassInfo_Contains(0,id)) return 0;
275  }
276 
277  MethodInfo_t *m = gInterpreter->MethodInfo_Factory(id);
278 
279  // Let's see if this is a reload ...
280  const char *name = gInterpreter->MethodInfo_Name(m);
281  if (const TList* bucketForMethod = fUnloaded->GetListForObject(name)) {
282  TString mangledName( gInterpreter->MethodInfo_GetMangledName(m) );
283  TIter next(bucketForMethod);
284  TFunction *uf;
285  while ((uf = (TFunction *) next())) {
286  if (uf->GetMangledName() == mangledName) {
287  // Reuse
288  fUnloaded->Remove(uf);
289 
290  uf->Update(m);
291  f = uf;
292  break;
293  }
294  }
295  }
296  if (!f) {
297  if (fClass) f = new TMethod(m, fClass);
298  else f = new TFunction(m);
299  }
300  // Calling 'just' THahList::Add would turn around and call
301  // TListOfFunctions::AddLast which should *also* do the fIds->Add.
303  fIds->Add((Long64_t)id,(Long64_t)f);
304 
305  return f;
306 }
307 
308 ////////////////////////////////////////////////////////////////////////////////
309 /// Remove a pair<id, object> from the map of functions and their ids.
310 
312 {
313  TFunction *f = dynamic_cast<TFunction*>(obj);
314  if (f) {
315  fIds->Remove((Long64_t)f->GetDeclId());
316  }
317 }
318 
319 ////////////////////////////////////////////////////////////////////////////////
320 /// Remove object from this collection and recursively remove the object
321 /// from all other objects (and collections).
322 /// This function overrides TCollection::RecursiveRemove that calls
323 /// the Remove function. THashList::Remove cannot be called because
324 /// it uses the hash value of the hash table. This hash value
325 /// is not available anymore when RecursiveRemove is called from
326 /// the TObject destructor.
327 
329 {
330  if (!obj) return;
331 
334  UnmapObject(obj);
335 
336 }
337 
338 ////////////////////////////////////////////////////////////////////////////////
339 /// Remove object from the list.
340 
342 {
343  Bool_t found;
344 
345  found = THashList::Remove(obj);
346  if (!found) {
347  found = fUnloaded->Remove(obj);
348  }
349  UnmapObject(obj);
350  if (found) return obj;
351  else return 0;
352 }
353 
354 ////////////////////////////////////////////////////////////////////////////////
355 /// Remove object via its objlink from the list.
356 
358 {
359  if (!lnk) return 0;
360 
361  TObject *obj = lnk->GetObject();
362 
363  THashList::Remove(lnk);
364  fUnloaded->Remove(obj);
365 
366  UnmapObject(obj);
367  return obj;
368 }
369 
370 ////////////////////////////////////////////////////////////////////////////////
371 /// Load all the functions known to the interpreter for the scope 'fClass'
372 /// into this collection.
373 
375 {
376  if (fClass && fClass->GetClassInfo() == 0) return;
377 
379 
380  ULong64_t currentTransaction = gInterpreter->GetInterpreterStateMarker();
381  if (currentTransaction == fLastLoadMarker) {
382  return;
383  }
384  fLastLoadMarker = currentTransaction;
385 
386  ClassInfo_t *info;
387  if (fClass) info = fClass->GetClassInfo();
388  else info = gInterpreter->ClassInfo_Factory();
389 
390  MethodInfo_t *t = gInterpreter->MethodInfo_Factory(info);
391  while (gInterpreter->MethodInfo_Next(t)) {
392  if (gInterpreter->MethodInfo_IsValid(t)) {
393  TDictionary::DeclId_t mid = gInterpreter->GetDeclId(t);
394  // Get will check if there is already there or create a new one
395  // (or re-use a previously unloaded version).
396  Get(mid);
397  }
398  }
399  gInterpreter->MethodInfo_Delete(t);
400  if (!fClass) gInterpreter->ClassInfo_Delete(info);
401 }
402 
403 ////////////////////////////////////////////////////////////////////////////////
404 /// Mark 'all func' as being unloaded.
405 /// After the unload, the function can no longer be found directly,
406 /// until the decl can be found again in the interpreter (in which
407 /// the func object will be reused.
408 
410 {
411  TObjLink *lnk = FirstLink();
412  while (lnk) {
413  TFunction *func = (TFunction*)lnk->GetObject();
414 
415  fIds->Remove((Long64_t)func->GetDeclId());
416  fUnloaded->Add(func);
417 
418  lnk = lnk->Next();
419  }
420 
422 }
423 
424 ////////////////////////////////////////////////////////////////////////////////
425 /// Mark 'func' as being unloaded.
426 /// After the unload, the function can no longer be found directly,
427 /// until the decl can be found again in the interpreter (in which
428 /// the func object will be reused.
429 
431 {
432  if (THashList::Remove(func)) {
433  // We contains the object, let remove it from the other internal
434  // list and move it to the list of unloaded objects.
435 
436  fIds->Remove((Long64_t)func->GetDeclId());
437  fUnloaded->Add(func);
438  }
439 }
440 
441 ////////////////////////////////////////////////////////////////////////////////
442 
444 {
446  return THashList::FindObject(obj);
447 }
448 
449 ////////////////////////////////////////////////////////////////////////////////
450 
452 {
454  return new TListOfFunctionsIter(this,dir);
455 }
456 
457 ////////////////////////////////////////////////////////////////////////////////
458 
460 {
462  return THashList::At(idx);
463 }
464 
465 ////////////////////////////////////////////////////////////////////////////////
466 
468 {
470  return THashList::After(obj);
471 }
472 
473 ////////////////////////////////////////////////////////////////////////////////
474 
476 {
478  return THashList::Before(obj);
479 }
480 
481 ////////////////////////////////////////////////////////////////////////////////
482 
484 {
486  return THashList::First();
487 }
488 
489 ////////////////////////////////////////////////////////////////////////////////
490 
492 {
494  return THashList::FirstLink();
495 }
496 
497 ////////////////////////////////////////////////////////////////////////////////
498 
500 {
502  return THashList::GetObjectRef(obj);
503 }
504 
505 ////////////////////////////////////////////////////////////////////////////////
506 
508 {
510  return THashList::Last();
511 }
512 
513 ////////////////////////////////////////////////////////////////////////////////
514 
516 {
518  return THashList::LastLink();
519 }
520 
521 
522 ////////////////////////////////////////////////////////////////////////////////
523 
525 {
527  return THashList::GetLast();
528 }
529 
530 ////////////////////////////////////////////////////////////////////////////////
531 
533 {
535  return THashList::IndexOf(obj);
536 }
537 
538 
539 ////////////////////////////////////////////////////////////////////////////////
540 
542 {
544  return THashList::GetSize();
545 }
546 
547 /** \class TListOfFunctionsIter
548 Iterator for TListOfFunctions.
549 */
550 
552 
553 ////////////////////////////////////////////////////////////////////////////////
554 
556  TListIter(l,dir) {}
557 
558 ////////////////////////////////////////////////////////////////////////////////
559 
561 {
563  return TListIter::Next();
564 }
565 
THashList::THashList
THashList(const THashList &)
TListOfFunctions::RecursiveRemove
void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
Definition: TListOfFunctions.cxx:328
l
auto * l
Definition: textangle.C:4
m
auto * m
Definition: textangle.C:8
TList::LastLink
virtual TObjLink * LastLink() const
Definition: TList.h:111
TListOfFunctions
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
Definition: TListOfFunctions.h:35
TList::GetObjectRef
virtual TObject ** GetObjectRef(const TObject *obj) const
Return address of pointer to obj.
Definition: TList.cxx:671
f
#define f(i)
Definition: RSha256.hxx:104
Option_t
const char Option_t
Definition: RtypesCore.h:66
TListOfFunctions::~TListOfFunctions
~TListOfFunctions()
Destructor.
Definition: TListOfFunctions.cxx:40
THashTable::Add
void Add(TObject *obj)
Add object to the hash table.
Definition: THashTable.cxx:92
THashList::AddAfter
void AddAfter(const TObject *after, TObject *obj)
Insert object after object after in the list.
Definition: THashList.cxx:143
TListOfFunctionsIter
Iterator for TListOfFunctions.
Definition: TListOfFunctions.h:114
TFunction.h
TListOfFunctions::AddAt
void AddAt(TObject *obj, Int_t idx)
Insert object at location idx in the list.
Definition: TListOfFunctions.cxx:106
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
THashList::GetListForObject
const TList * GetListForObject(const char *name) const
Return the THashTable's list (bucket) in which obj can be found based on its hash; see THashTable::Ge...
Definition: THashList.cxx:283
TMethod.h
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TListOfFunctions::Unload
void Unload()
Mark 'all func' as being unloaded.
Definition: TListOfFunctions.cxx:409
TListOfFunctions::fClass
TClass * fClass
Definition: TListOfFunctions.h:38
gInterpreter
#define gInterpreter
Definition: TInterpreter.h:560
TListOfFunctions::GetObjectRef
virtual TObject ** GetObjectRef(const TObject *obj) const
Return address of pointer to obj.
Definition: TListOfFunctions.cxx:499
TListOfFunctions::GetListForObjectNonConst
TList * GetListForObjectNonConst(const char *name)
Return the set of overloads for this name, collecting all available ones.
Definition: TListOfFunctions.cxx:191
TListOfFunctions::MapObject
void MapObject(TObject *obj)
Add pair<id, object> to the map of functions and their ids.
Definition: TListOfFunctions.cxx:51
TInterpreter::DeclId_t
TDictionary::DeclId_t DeclId_t
Definition: TInterpreter.h:288
TClass.h
TList::Last
virtual TObject * Last() const
Return the last object in the list. Returns 0 when list is empty.
Definition: TList.cxx:693
TFunction::GetDeclId
DeclId_t GetDeclId() const
Definition: TFunction.cxx:199
TExMap::GetValue
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition: TExMap.cxx:173
TString
Basic string class.
Definition: TString.h:136
TListOfFunctions::FirstLink
virtual TObjLink * FirstLink() const
Definition: TListOfFunctions.cxx:491
TListOfFunctions::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TListOfFunctions.cxx:541
bool
TIterator
Iterator abstract base class.
Definition: TIterator.h:30
TListIter
Iterator of linked list.
Definition: TList.h:200
TSeqCollection::IndexOf
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
Definition: TSeqCollection.cxx:30
TListOfFunctions.h
TListOfFunctions::At
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition: TListOfFunctions.cxx:459
TListOfFunctionsIter::Next
TObject * Next()
Return next object in the list. Returns 0 when no more objects in list.
Definition: TListOfFunctions.cxx:560
TListIter::Next
TObject * Next()
Return next object in the list. Returns 0 when no more objects in list.
Definition: TList.cxx:1113
TList::First
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:659
TListOfFunctions::Clear
virtual void Clear(Option_t *option)
Remove all objects from the list.
Definition: TListOfFunctions.cxx:152
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TListOfFunctions::Remove
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TListOfFunctions.cxx:341
TList::At
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition: TList.cxx:357
TList::After
virtual TObject * After(const TObject *obj) const
Returns the object after object obj.
Definition: TList.cxx:330
THashList::AddBefore
void AddBefore(const TObject *before, TObject *obj)
Insert object before object before in the list.
Definition: THashList.cxx:121
TListOfFunctionsIter::TListOfFunctionsIter
TListOfFunctionsIter(const TListOfFunctions *l, Bool_t dir=kIterForward)
Definition: TListOfFunctions.cxx:555
TList::FirstLink
virtual TObjLink * FirstLink() const
Definition: TList.h:108
TListOfFunctions::AddBefore
void AddBefore(const TObject *before, TObject *obj)
Insert object before object before in the list.
Definition: TListOfFunctions.cxx:133
gInterpreterMutex
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:44
TListOfFunctions::fLastLoadMarker
ULong64_t fLastLoadMarker
Definition: TListOfFunctions.h:43
TListOfFunctions::MakeIterator
virtual TIterator * MakeIterator(Bool_t dir=kIterForward) const
Return a list iterator.
Definition: TListOfFunctions.cxx:451
TListOfFunctions::First
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TListOfFunctions.cxx:483
TList::Before
virtual TObject * Before(const TObject *obj) const
Returns the object before object obj.
Definition: TList.cxx:371
THashList::FindObject
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
TListOfFunctions::fIds
TExMap * fIds
Definition: TListOfFunctions.h:40
TDictionary::DeclId_t
const void * DeclId_t
Definition: TDictionary.h:223
THashTable::FindObject
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashTable.cxx:238
TListOfFunctions::Delete
virtual void Delete(Option_t *option="")
Delete all TFunction object files.
Definition: TListOfFunctions.cxx:162
THashList::AddLast
void AddLast(TObject *obj)
Add object at the end of the list.
Definition: THashList.cxx:95
TListOfFunctions::LastLink
virtual TObjLink * LastLink() const
Definition: TListOfFunctions.cxx:515
TListOfFunctions::GetListForObject
virtual TList * GetListForObject(const char *name) const
Return the set of overloads for this name, collecting all available ones.
Definition: TListOfFunctions.cxx:230
TListOfFunctions::Find
TFunction * Find(DeclId_t id) const
Return the TMethod or TFunction describing the function corresponding to the Decl 'id'.
Definition: TListOfFunctions.cxx:250
TListOfFunctions::GetLast
virtual Int_t GetLast() const
Returns index of last object in collection.
Definition: TListOfFunctions.cxx:524
TMethod
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:38
TListOfFunctions::fUnloaded
THashList * fUnloaded
Definition: TListOfFunctions.h:41
TList::TList
TList()
Definition: TList.h:78
R__LOCKGUARD
#define R__LOCKGUARD(mutex)
Definition: TVirtualMutex.h:104
TListOfFunctions::Last
virtual TObject * Last() const
Return the last object in the list. Returns 0 when list is empty.
Definition: TListOfFunctions.cxx:507
TClass::GetClassInfo
ClassInfo_t * GetClassInfo() const
Definition: TClass.h:394
TListOfFunctions::UnmapObject
void UnmapObject(TObject *obj)
Remove a pair<id, object> from the map of functions and their ids.
Definition: TListOfFunctions.cxx:311
THashList::Remove
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:378
TVirtualMutex.h
fClass
Cppyy::TCppType_t fClass
Definition: DeclareConverters.h:259
TListOfFunctions::DeclId_t
TDictionary::DeclId_t DeclId_t
Definition: TListOfFunctions.h:53
THashList::Delete
void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: THashList.cxx:207
TListOfFunctions::Load
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
Definition: TListOfFunctions.cxx:374
TListOfFunctions::Get
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
Definition: TListOfFunctions.cxx:262
TListOfFunctions::IndexOf
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
Definition: TListOfFunctions.cxx:532
TListOfFunctions::AddAfter
void AddAfter(const TObject *after, TObject *obj)
Insert object after object after in the list.
Definition: TListOfFunctions.cxx:115
ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:74
TFunction::GetMangledName
virtual const char * GetMangledName() const
Returns the mangled name as defined by CINT, or 0 in case of error.
Definition: TFunction.cxx:237
TFunction::Update
virtual bool Update(MethodInfo_t *info)
Update the TFunction to reflect the new info.
Definition: TFunction.cxx:279
TListOfFunctions::FindObject
virtual TObject * FindObject(const TObject *obj) const
Find object using its hash value (returned by its Hash() member).
Definition: TListOfFunctions.cxx:443
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TInterpreter.h
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
THashList::Clear
void Clear(Option_t *option="")
Remove all objects from the list.
Definition: THashList.cxx:189
TCollection::SetName
void SetName(const char *name)
Definition: TCollection.h:204
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TListOfFunctions::TListOfFunctions
TListOfFunctions(const TListOfFunctions &)
name
char name[80]
Definition: TGX11.cxx:110
TExMap::Remove
void Remove(ULong64_t hash, Long64_t key)
Remove entry with specified key from the TExMap.
Definition: TExMap.cxx:216
TListOfFunctions::AddLast
void AddLast(TObject *obj)
Add object at the end of the list.
Definition: TListOfFunctions.cxx:84
THashList::AddAt
void AddAt(TObject *obj, Int_t idx)
Insert object at location idx in the list.
Definition: THashList.cxx:165
TIter
Definition: TCollection.h:233
TExMap
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:33
TListOfFunctions::AddFirst
void AddFirst(TObject *obj)
Add object at the beginning of the list.
Definition: TListOfFunctions.cxx:62
TListOfFunctions::Before
virtual TObject * Before(const TObject *obj) const
Returns the object before object obj.
Definition: TListOfFunctions.cxx:475
TExMap::Add
void Add(ULong64_t hash, Long64_t key, Long64_t value)
Add an (key,value) pair to the table. The key should be unique.
Definition: TExMap.cxx:87
TSeqCollection::GetLast
virtual Int_t GetLast() const
Returns index of last object in collection.
Definition: TSeqCollection.cxx:47
TObject::Clear
virtual void Clear(Option_t *="")
Definition: TObject.h:100
TFunction
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:30
THashList::AddFirst
void AddFirst(TObject *obj)
Add object at the beginning of the list.
Definition: THashList.cxx:69
TList
A doubly linked list.
Definition: TList.h:44
TListOfFunctions::fOverloads
THashTable fOverloads
Definition: TListOfFunctions.h:42
TExMap.h
int
THashList::RecursiveRemove
void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
Definition: THashList.cxx:310
TListOfFunctions::After
virtual TObject * After(const TObject *obj) const
Returns the object after object obj.
Definition: TListOfFunctions.cxx:467