Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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#include "TROOT.h"
26
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
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
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
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{
118 MapObject(obj);
119}
120
121////////////////////////////////////////////////////////////////////////////////
122/// Insert object after object after in the list.
123
129
130////////////////////////////////////////////////////////////////////////////////
131/// Insert object before object before in the list.
132
138
139////////////////////////////////////////////////////////////////////////////////
140/// Insert object before object before in the list.
141
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
158
159////////////////////////////////////////////////////////////////////////////////
160/// Delete all TFunction object files.
161
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
197 Bool_t wasEmpty = true;
198 if (!overloads) {
199 overloads = new TList();
200 overloads->SetName(name);
202 } else {
204 while (TFunction* over = (TFunction*)iOverload()) {
205 wasEmpty = false;
206 overloadsSet.Add((Long64_t)(ULong64_t)over->GetDeclId(),
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 (gROOT->TestBit(kInvalidObject)) {
272 // Abort early during tear down.
273 return nullptr;
274 }
275
276 if (fClass) {
277 if (!gInterpreter->ClassInfo_Contains(fClass->GetClassInfo(),id)) return nullptr;
278 } else {
279 if (!gInterpreter->ClassInfo_Contains(nullptr,id)) return nullptr;
280 }
281
282 MethodInfo_t *m = gInterpreter->MethodInfo_Factory(id);
283
284 // Let's see if this is a reload ...
285 const char *name = gInterpreter->MethodInfo_Name(m);
287 TString mangledName( gInterpreter->MethodInfo_GetMangledName(m) );
289 TFunction *uf;
290 while ((uf = (TFunction *) next())) {
291 if (uf->GetMangledName() == mangledName) {
292 // Reuse
294
295 uf->Update(m);
296 f = uf;
297 break;
298 }
299 }
300 }
301 if (!f) {
302 if (fClass) f = new TMethod(m, fClass);
303 else f = new TFunction(m);
304 }
305 // Calling 'just' THahList::Add would turn around and call
306 // TListOfFunctions::AddLast which should *also* do the fIds->Add.
308 fIds->Add((Long64_t)id,(Long64_t)f);
309
310 return f;
311}
312
313////////////////////////////////////////////////////////////////////////////////
314/// Remove a pair<id, object> from the map of functions and their ids.
315
317{
318 TFunction *f = dynamic_cast<TFunction*>(obj);
319 if (f) {
320 fIds->Remove((Long64_t)f->GetDeclId());
321 }
322}
323
324////////////////////////////////////////////////////////////////////////////////
325/// Remove object from this collection and recursively remove the object
326/// from all other objects (and collections).
327/// This function overrides TCollection::RecursiveRemove that calls
328/// the Remove function. THashList::Remove cannot be called because
329/// it uses the hash value of the hash table. This hash value
330/// is not available anymore when RecursiveRemove is called from
331/// the TObject destructor.
332
334{
335 if (!obj) return;
336
339 UnmapObject(obj);
340
341}
342
343////////////////////////////////////////////////////////////////////////////////
344/// Remove object from the list.
345
347{
348 Bool_t found;
349
350 found = THashList::Remove(obj);
351 if (!found) {
352 found = fUnloaded->Remove(obj);
353 }
354 UnmapObject(obj);
355 if (found) return obj;
356 else return nullptr;
357}
358
359////////////////////////////////////////////////////////////////////////////////
360/// Remove object via its objlink from the list.
361
363{
364 if (!lnk) return nullptr;
365
366 TObject *obj = lnk->GetObject();
367
369 fUnloaded->Remove(obj);
370
371 UnmapObject(obj);
372 return obj;
373}
374
375////////////////////////////////////////////////////////////////////////////////
376/// Load all the functions known to the interpreter for the scope 'fClass'
377/// into this collection.
378
380{
381 if (fClass && fClass->GetClassInfo() == nullptr) return;
382
384
385 ULong64_t currentTransaction = gInterpreter->GetInterpreterStateMarker();
387 return;
388 }
390
392 if (fClass) info = fClass->GetClassInfo();
393 else info = gInterpreter->ClassInfo_Factory();
394
395 MethodInfo_t *t = gInterpreter->MethodInfo_Factory(info);
396 while (gInterpreter->MethodInfo_Next(t)) {
397 if (gInterpreter->MethodInfo_IsValid(t)) {
398 TDictionary::DeclId_t mid = gInterpreter->GetDeclId(t);
399 // Get will check if there is already there or create a new one
400 // (or re-use a previously unloaded version).
401 Get(mid);
402 }
403 }
404 gInterpreter->MethodInfo_Delete(t);
405 if (!fClass) gInterpreter->ClassInfo_Delete(info);
406}
407
408////////////////////////////////////////////////////////////////////////////////
409/// Mark 'all func' as being unloaded.
410/// After the unload, the function can no longer be found directly,
411/// until the decl can be found again in the interpreter (in which
412/// the func object will be reused.
413
415{
417 while (lnk) {
418 TFunction *func = (TFunction*)lnk->GetObject();
419
420 fIds->Remove((Long64_t)func->GetDeclId());
421 fUnloaded->Add(func);
422
423 lnk = lnk->Next();
424 }
425
427}
428
429////////////////////////////////////////////////////////////////////////////////
430/// Mark 'func' as being unloaded.
431/// After the unload, the function can no longer be found directly,
432/// until the decl can be found again in the interpreter (in which
433/// the func object will be reused.
434
436{
437 if (THashList::Remove(func)) {
438 // We contains the object, let remove it from the other internal
439 // list and move it to the list of unloaded objects.
440
441 fIds->Remove((Long64_t)func->GetDeclId());
442 fUnloaded->Add(func);
443 }
444}
445
446////////////////////////////////////////////////////////////////////////////////
447
453
454////////////////////////////////////////////////////////////////////////////////
455
461
462////////////////////////////////////////////////////////////////////////////////
463
469
470////////////////////////////////////////////////////////////////////////////////
471
473{
475 return THashList::After(obj);
476}
477
478////////////////////////////////////////////////////////////////////////////////
479
485
486////////////////////////////////////////////////////////////////////////////////
487
493
494////////////////////////////////////////////////////////////////////////////////
495
501
502////////////////////////////////////////////////////////////////////////////////
503
509
510////////////////////////////////////////////////////////////////////////////////
511
517
518////////////////////////////////////////////////////////////////////////////////
519
525
526
527////////////////////////////////////////////////////////////////////////////////
528
534
535////////////////////////////////////////////////////////////////////////////////
536
542
543
544////////////////////////////////////////////////////////////////////////////////
545
551
552/** \class TListOfFunctionsIter
553Iterator for TListOfFunctions.
554*/
555
556
557////////////////////////////////////////////////////////////////////////////////
558
561
562////////////////////////////////////////////////////////////////////////////////
563
569
Cppyy::TCppType_t fClass
#define f(i)
Definition RSha256.hxx:104
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:83
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t option
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
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
#define gInterpreter
@ kInvalidObject
Definition TObject.h:377
#define gROOT
Definition TROOT.h:411
#define R__LOCKGUARD(mutex)
const_iterator begin() const
const_iterator end() const
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
ClassInfo_t * GetClassInfo() const
Definition TClass.h:445
virtual TObject ** GetObjectRef(const TObject *obj) const =0
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
const void * DeclId_t
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
DeclId_t GetDeclId() const
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
void AddBefore(const TObject *before, TObject *obj) override
Insert object before object before in the list.
void Clear(Option_t *option="") override
Remove all objects from the list.
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition THashList.cxx:68
void AddAfter(const TObject *after, TObject *obj) override
Insert object after object after in the list.
void RecursiveRemove(TObject *obj) override
Remove object from this collection and recursively remove the object from all other objects (and coll...
void AddAt(TObject *obj, Int_t idx) override
Insert object at location idx in the list.
THashList(const THashList &)=delete
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...
TObject * Remove(TObject *obj) override
Remove object from the list.
TObject * FindObject(const char *name) const override
Find object using its name.
void AddLast(TObject *obj) override
Add object at the end of the list.
Definition THashList.cxx:94
void Add(TObject *obj) override
Add object to the hash table.
TObject * FindObject(const char *name) const override
Find object using its name.
TDictionary::DeclId_t DeclId_t
Iterator abstract base class.
Definition TIterator.h:30
Iterator of linked list.
Definition TList.h:191
TObject * Next() override
Return next object in the list. Returns 0 when no more objects in list.
Definition TList.cxx:1110
Iterator for TListOfFunctions.
TListOfFunctionsIter(const TListOfFunctions *l, Bool_t dir=kIterForward)
TObject * Next() override
Return next object in the list. Returns 0 when no more objects in list.
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
THashList * fUnloaded
void Clear(Option_t *option="") override
Remove all objects from the list.
void MapObject(TObject *obj)
Add pair<id, object> to the map of functions and their ids.
void AddBefore(const TObject *before, TObject *obj) override
Insert object before object before in the list.
TObject ** GetObjectRef(const TObject *obj) const override
Return address of pointer to obj.
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
TObject * First() const override
Return the first object in the list. Returns 0 when list is empty.
Int_t IndexOf(const TObject *obj) const override
Return index of object in collection.
void Delete(Option_t *option="") override
Delete all TFunction object files.
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
TListOfFunctions(const TListOfFunctions &)=delete
TObject * Remove(TObject *obj) override
Remove object from the list.
TObject * After(const TObject *obj) const override
Returns the object after object obj.
TObject * Last() const override
Return the last object in the list. Returns 0 when list is empty.
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'.
void AddAt(TObject *obj, Int_t idx) override
Insert object at location idx in the list.
virtual TList * GetListForObject(const char *name) const
Return the set of overloads for this name, collecting all available ones.
TDictionary::DeclId_t DeclId_t
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
TObjLink * FirstLink() const override
void Unload()
Mark 'all func' as being unloaded.
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
TObject * Before(const TObject *obj) const override
Returns the object before object obj.
void AddAfter(const TObject *after, TObject *obj) override
Insert object after object after in the list.
void AddLast(TObject *obj) override
Add object at the end of the list.
void RecursiveRemove(TObject *obj) override
Remove object from this collection and recursively remove the object from all other objects (and coll...
TIterator * MakeIterator(Bool_t dir=kIterForward) const override
Return a list iterator.
Int_t GetSize() const override
Return the capacity of the collection, i.e.
TObjLink * LastLink() const override
ULong64_t fLastLoadMarker
Int_t GetLast() const override
Returns index of last object in collection.
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 * After(const TObject *obj) const override
Returns the object after object obj.
Definition TList.cxx:327
virtual TObjLink * LastLink() const
Definition TList.h:105
TObject * Before(const TObject *obj) const override
Returns the object before object obj.
Definition TList.cxx:368
void Add(TObject *obj) override
Definition TList.h:81
TObject * Last() const override
Return the last object in the list. Returns 0 when list is empty.
Definition TList.cxx:690
TObject * First() const override
Return the first object in the list. Returns 0 when list is empty.
Definition TList.cxx:656
virtual TObjLink * FirstLink() const
Definition TList.h:102
TList()
Definition TList.h:72
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:354
Each ROOT class (see TClass) has a linked list of methods.
Definition TMethod.h:38
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Clear(Option_t *="")
Definition TObject.h:125
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:457
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:138
TMarker m
Definition textangle.C:8
TLine l
Definition textangle.C:4