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
13A collection of TFunction objects designed for fast access given a
14DeclId_t and for keep track of TFunction that were described
15unloaded 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
31TListOfFunctions::TListOfFunctions(TClass *cl) : fClass(cl),fIds(nullptr),fUnloaded(nullptr),fLastLoadMarker(0)
32{
33 fIds = new TExMap;
34 fUnloaded = new THashList;
35}
36
37////////////////////////////////////////////////////////////////////////////////
38/// Destructor.
39
41{
43 delete fIds;
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{
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
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
162void 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(nullptr,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() : nullptr;
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 nullptr;
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 nullptr;
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 nullptr;
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 nullptr;
273 } else {
274 if (!gInterpreter->ClassInfo_Contains(nullptr,id)) return nullptr;
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 nullptr;
352}
353
354////////////////////////////////////////////////////////////////////////////////
355/// Remove object via its objlink from the list.
356
358{
359 if (!lnk) return nullptr;
360
361 TObject *obj = lnk->GetObject();
362
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() == nullptr) 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
548Iterator for TListOfFunctions.
549*/
550
552
553////////////////////////////////////////////////////////////////////////////////
554
556 TListIter(l,dir) {}
557
558////////////////////////////////////////////////////////////////////////////////
559
561{
563 return TListIter::Next();
564}
565
Cppyy::TCppType_t fClass
#define f(i)
Definition: RSha256.hxx:104
int Int_t
Definition: RtypesCore.h:45
bool Bool_t
Definition: RtypesCore.h:63
long long Long64_t
Definition: RtypesCore.h:80
unsigned long long ULong64_t
Definition: RtypesCore.h:81
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:364
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:44
#define gInterpreter
Definition: TInterpreter.h:562
#define R__LOCKGUARD(mutex)
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
ClassInfo_t * GetClassInfo() const
Definition: TClass.h:430
void SetName(const char *name)
Definition: TCollection.h:206
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:184
const void * DeclId_t
Definition: TDictionary.h:223
This class stores a (key,value) pair using an external hash.
Definition: TExMap.h:33
void Remove(ULong64_t hash, Long64_t key)
Remove entry with specified key from the TExMap.
Definition: TExMap.cxx:216
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
Long64_t GetValue(ULong64_t hash, Long64_t key)
Return the value belonging to specified key and hash value.
Definition: TExMap.cxx:173
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:30
virtual const char * GetMangledName() const
Returns the mangled name as defined by CINT, or 0 in case of error.
Definition: TFunction.cxx:237
virtual bool Update(MethodInfo_t *info)
Update the TFunction to reflect the new info.
Definition: TFunction.cxx:279
DeclId_t GetDeclId() const
Definition: TFunction.cxx:199
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
Definition: THashList.cxx:310
void AddBefore(const TObject *before, TObject *obj)
Insert object before object before in the list.
Definition: THashList.cxx:121
void AddAt(TObject *obj, Int_t idx)
Insert object at location idx in the list.
Definition: THashList.cxx:165
THashList(const THashList &)=delete
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:378
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
void Clear(Option_t *option="")
Remove all objects from the list.
Definition: THashList.cxx:189
void AddFirst(TObject *obj)
Add object at the beginning of the list.
Definition: THashList.cxx:69
void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: THashList.cxx:207
void AddAfter(const TObject *after, TObject *obj)
Insert object after object after in the list.
Definition: THashList.cxx:143
void AddLast(TObject *obj)
Add object at the end of the list.
Definition: THashList.cxx:95
void Add(TObject *obj)
Add object to the hash table.
Definition: THashTable.cxx:92
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashTable.cxx:238
TDictionary::DeclId_t DeclId_t
Definition: TInterpreter.h:290
Iterator abstract base class.
Definition: TIterator.h:30
Iterator of linked list.
Definition: TList.h:200
TObject * Next()
Return next object in the list. Returns 0 when no more objects in list.
Definition: TList.cxx:1111
Iterator for TListOfFunctions.
TObject * Next()
Return next object in the list. Returns 0 when no more objects in list.
TListOfFunctionsIter(const TListOfFunctions *l, Bool_t dir=kIterForward)
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
THashList * fUnloaded
virtual Int_t GetLast() const
Returns index of last object in collection.
void MapObject(TObject *obj)
Add pair<id, object> to the map of functions and their ids.
virtual TObject * Before(const TObject *obj) const
Returns the object before object obj.
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
virtual TIterator * MakeIterator(Bool_t dir=kIterForward) const
Return a list iterator.
void AddAfter(const TObject *after, TObject *obj)
Insert object after object after in the list.
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
virtual TObject * FindObject(const TObject *obj) const
Find object using its hash value (returned by its Hash() member).
TObject * Remove(TObject *obj)
Remove object from the list.
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
TListOfFunctions(const TListOfFunctions &)=delete
void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
void AddLast(TObject *obj)
Add object at the end of the list.
void AddAt(TObject *obj, Int_t idx)
Insert object at location idx in the list.
void AddBefore(const TObject *before, TObject *obj)
Insert object before object before in the list.
TList * GetListForObjectNonConst(const char *name)
Return the set of overloads for this name, collecting all available ones.
~TListOfFunctions()
Destructor.
void UnmapObject(TObject *obj)
Remove a pair<id, object> from the map of functions and their ids.
TFunction * Find(DeclId_t id) const
Return the TMethod or TFunction describing the function corresponding to the Decl 'id'.
virtual TObject * Last() const
Return the last object in the list. Returns 0 when list is empty.
THashTable fOverloads
virtual TList * GetListForObject(const char *name) const
Return the set of overloads for this name, collecting all available ones.
TDictionary::DeclId_t DeclId_t
void Unload()
Mark 'all func' as being unloaded.
virtual void Delete(Option_t *option="")
Delete all TFunction object files.
virtual TObject ** GetObjectRef(const TObject *obj) const
Return address of pointer to obj.
virtual TObjLink * LastLink() const
virtual TObject * After(const TObject *obj) const
Returns the object after object obj.
virtual TObjLink * FirstLink() const
ULong64_t fLastLoadMarker
virtual void Clear(Option_t *option)
Remove all objects from the list.
void AddFirst(TObject *obj)
Add object at the beginning of the list.
A doubly linked list.
Definition: TList.h:44
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObject * After(const TObject *obj) const
Returns the object after object obj.
Definition: TList.cxx:330
virtual TObjLink * LastLink() const
Definition: TList.h:111
virtual TObject ** GetObjectRef(const TObject *obj) const
Return address of pointer to obj.
Definition: TList.cxx:671
virtual TObjLink * FirstLink() const
Definition: TList.h:108
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
virtual TObject * Last() const
Return the last object in the list. Returns 0 when list is empty.
Definition: TList.cxx:693
virtual TObject * Before(const TObject *obj) const
Returns the object before object obj.
Definition: TList.cxx:371
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:659
TList()
Definition: TList.h:78
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:38
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void Clear(Option_t *="")
Definition: TObject.h:115
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
virtual Int_t GetLast() const
Returns index of last object in collection.
Basic string class.
Definition: TString.h:136
auto * m
Definition: textangle.C:8
auto * l
Definition: textangle.C:4