Logo ROOT  
Reference Guide
TCollection.h
Go to the documentation of this file.
1// @(#)root/cont:$Id$
2// Author: Fons Rademakers 13/08/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#ifndef ROOT_TCollection
13#define ROOT_TCollection
14
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TCollection //
19// //
20// Collection abstract base class. This class inherits from TObject //
21// because we want to be able to have collections of collections. //
22// //
23//////////////////////////////////////////////////////////////////////////
24
25#include "TObject.h"
26
27#include "TIterator.h"
28
29#include "TString.h"
30
31#include "TVirtualRWMutex.h"
32
33#include <cassert>
34
35class TClass;
36class TObjectTable;
37class TVirtualMutex;
38class TIter;
39
42
44
45// #define R__CHECK_COLLECTION_MULTI_ACCESS
46
47// When R__CHECK_COLLECTION_MULTI_ACCESS is turned on (defined),
48// the normal (not locked) ROOT TCollections are instrumented with a
49// pseudo read-write lock which does not halt the execution but detects
50// and report concurrent access to the same collections.
51// Multiple readers are allowed.
52// Multiple concurrent writer is reported as a Conflict
53// Readers access while a write is running is reported as Conflict
54// Re-entrant writing call by the same Writer thread are allowed.
55// Entering a writing section by a single Reader thread is allowed.
56
57#ifdef R__CHECK_COLLECTION_MULTI_ACCESS
58#include <atomic>
59#include <thread>
60#include <unordered_multiset>
61#endif
62
63class TCollection : public TObject {
64
65#ifdef R__CHECK_COLLECTION_MULTI_ACCESS
66public:
67 class TErrorLock {
68 // Warn when multiple thread try to acquire the same 'lock'
69 std::atomic<std::thread::id> fWriteCurrent;
70 std::atomic<size_t> fWriteCurrentRecurse;
71 std::atomic<size_t> fReadCurrentRecurse;
72 std::unordered_multiset<std::thread::id> fReadSet;
73 std::atomic_flag fSpinLockFlag;
74
75 void Lock(const TCollection *collection, const char *function);
76
77 void Unlock();
78
79 void ReadLock(const TCollection *collection, const char *function);
80
81 void ReadUnlock();
82
83 void ConflictReport(std::thread::id holder, const char *accesstype, const TCollection *collection,
84 const char *function);
85
86 public:
87 TErrorLock() : fWriteCurrent(), fWriteCurrentRecurse(0), fReadCurrentRecurse(0)
88 {
89 std::atomic_flag_clear(&fSpinLockFlag);
90 }
91
92 class WriteGuard {
93 TErrorLock *fLock;
94
95 public:
96 WriteGuard(TErrorLock &lock, const TCollection *collection, const char *function) : fLock(&lock)
97 {
98 fLock->Lock(collection, function);
99 }
100 ~~WriteGuard() { fLock->Unlock(); }
101 };
102
103 class ReadGuard {
104 TErrorLock *fLock;
105
106 public:
107 ReadGuard(TErrorLock &lock, const TCollection *collection, const char *function) : fLock(&lock)
108 {
109 fLock->ReadLock(collection, function);
110 }
111 ~~ReadGuard() { fLock->ReadUnlock(); }
112 };
113 };
114
115 mutable TErrorLock fLock; //! Special 'lock' to detect multiple access to a collection.
116
117#define R__COLLECTION_WRITE_GUARD() TCollection::TErrorLock::WriteGuard wg(fLock, this, __PRETTY_FUNCTION__)
118#define R__COLLECTION_READ_GUARD() TCollection::TErrorLock::ReadGuard rg(fLock, this, __PRETTY_FUNCTION__)
119
120#define R__COLLECTION_ITER_GUARD(collection) \
121 TCollection::TErrorLock::ReadGuard rg(collection->fLock, collection, __PRETTY_FUNCTION__)
122
123#else
124
125#define R__COLLECTION_WRITE_GUARD()
126#define R__COLLECTION_READ_GUARD()
127#define R__COLLECTION_ITER_GUARD(collection)
128
129#endif
130
131private:
132 static TCollection *fgCurrentCollection; //used by macro R__FOR_EACH
133 static TObjectTable *fgGarbageCollection; //used by garbage collector
134 static Bool_t fgEmptyingGarbage; //used by garbage collector
135 static Int_t fgGarbageStack; //used by garbage collector
136
137 TCollection(const TCollection &); //private and not-implemented, collections
138 void operator=(const TCollection &); //are too complex to be automatically copied
139
140protected:
143 // BIT(15) is used by TClonesArray and TMap
144 kUseRWLock = BIT(16)
145 };
146
147 TString fName; //name of the collection
148 Int_t fSize; //number of elements in collection
149
150 TCollection() : fName(), fSize(0) { }
151
152 virtual void PrintCollectionHeader(Option_t* option) const;
153 virtual const char* GetCollectionEntryName(TObject* entry) const;
154 virtual void PrintCollectionEntry(TObject* entry, Option_t* option, Int_t recurse) const;
155
156public:
158
159 virtual ~TCollection();
160 virtual void Add(TObject *obj) = 0;
161 void AddVector(TObject *obj1, ...);
162 virtual void AddAll(const TCollection *col);
163 Bool_t AssertClass(TClass *cl) const;
164 void Browse(TBrowser *b);
165 Int_t Capacity() const { return fSize; }
166 virtual void Clear(Option_t *option="") = 0;
167 virtual TObject *Clone(const char *newname="") const;
168 Int_t Compare(const TObject *obj) const;
169 Bool_t Contains(const char *name) const { return FindObject(name) != 0; }
170 Bool_t Contains(const TObject *obj) const { return FindObject(obj) != 0; }
171 virtual void Delete(Option_t *option="") = 0;
172 virtual void Draw(Option_t *option="");
173 virtual void Dump() const ;
174 virtual TObject *FindObject(const char *name) const;
175 TObject *operator()(const char *name) const;
176 virtual TObject *FindObject(const TObject *obj) const;
177 virtual Int_t GetEntries() const { return GetSize(); }
178 virtual const char *GetName() const;
179 virtual TObject **GetObjectRef(const TObject *obj) const = 0;
180 /// Return the *capacity* of the collection, i.e. the current total amount of space that has been allocated so far.
181 /// Same as `Capacity`. Use `GetEntries` to get the number of elements currently in the collection.
182 virtual Int_t GetSize() const { return fSize; }
183 virtual Int_t GrowBy(Int_t delta) const;
184 ULong_t Hash() const { return fName.Hash(); }
185 Bool_t IsArgNull(const char *where, const TObject *obj) const;
186 virtual Bool_t IsEmpty() const { return GetSize() <= 0; }
187 virtual Bool_t IsFolder() const { return kTRUE; }
188 Bool_t IsOwner() const { return TestBit(kIsOwner); }
189 Bool_t IsSortable() const { return kTRUE; }
190 virtual void ls(Option_t *option="") const ;
191 virtual Bool_t Notify();
192 virtual TIterator *MakeIterator(Bool_t dir = kIterForward) const = 0;
194 virtual void Paint(Option_t *option="");
195 virtual void Print(Option_t *option="") const;
196 virtual void Print(Option_t *option, Int_t recurse) const;
197 virtual void Print(Option_t *option, const char* wildcard, Int_t recurse=1) const;
198 virtual void Print(Option_t *option, TPRegexp& regexp, Int_t recurse=1) const;
199 virtual void RecursiveRemove(TObject *obj);
200 virtual TObject *Remove(TObject *obj) = 0;
201 virtual void RemoveAll(TCollection *col);
202 void RemoveAll() { Clear(); }
204 void SetName(const char *name) { fName = name; }
205 virtual void SetOwner(Bool_t enable = kTRUE);
206 virtual bool UseRWLock();
207 virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0);
208 virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0) const;
209
211
213 static void StartGarbageCollection();
214 static void GarbageCollect(TObject *obj);
215 static void EmptyGarbageCollection();
216
217 TIter begin() const;
218 TIter end() const;
219
220 ClassDef(TCollection,3) //Collection abstract base class
221};
222
223
224//////////////////////////////////////////////////////////////////////////
225// //
226// TIter //
227// //
228// Iterator wrapper. Type of iterator used depends on type of //
229// collection. //
230// //
231//////////////////////////////////////////////////////////////////////////
232
233class TIter {
234
235private:
236 TIterator *fIterator; //collection iterator
237
238protected:
239 TIter() : fIterator(nullptr) { }
240
241public:
243 : fIterator(col ? col->MakeIterator(dir) : 0) { }
244 TIter(TIterator *it) : fIterator(it) { }
245 TIter(const TIter &iter);
246 TIter &operator=(const TIter &rhs);
248 TObject *operator()() { return Next(); }
249 TObject *Next() { return fIterator ? fIterator->Next() : nullptr; }
250 const TCollection *GetCollection() const { return fIterator ? fIterator->GetCollection() : nullptr; }
251 Option_t *GetOption() const { return fIterator ? fIterator->GetOption() : ""; }
252 void Reset() { if (fIterator) fIterator->Reset(); }
253 TIter &operator++() { Next(); return *this; }
254 Bool_t operator==(const TIter &aIter) const {
255 if (fIterator == nullptr)
256 return aIter.fIterator == nullptr || **aIter.fIterator == nullptr;
257 if (aIter.fIterator == nullptr)
258 return fIterator == nullptr || **fIterator == nullptr;
259 return *fIterator == *aIter.fIterator;
260 }
261 Bool_t operator!=(const TIter &aIter) const {
262 return !(*this == aIter);
263 }
265 {
266 if (fIterator)
267 delete fIterator;
268 fIterator = iter;
269 return *this;
270 }
271 TObject *operator*() const { return fIterator ? *(*fIterator): nullptr; }
272 TIter &Begin();
273 static TIter End();
274
275 ClassDef(TIter,0) //Iterator wrapper
276};
277
278template <class T>
279class TIterCategory: public TIter, public std::iterator_traits<typename T::Iterator_t> {
280
281public:
282 TIterCategory(const TCollection *col, Bool_t dir = kIterForward) : TIter(col, dir) { }
284 virtual ~TIterCategory() { }
285 TIterCategory &Begin() { TIter::Begin(); return *this; }
286 static TIterCategory End() { return TIterCategory(static_cast<TIterator*>(nullptr)); }
287};
288
289
290inline TIter TCollection::begin() const { return ++(TIter(this)); }
291inline TIter TCollection::end() const { return TIter::End(); }
292
293namespace ROOT {
294namespace Internal {
295
297bool ContaineeInheritsFrom(TClass *cl, TClass *base);
298
299/// @brief Internal help class implmenting an iterator for TRangeDynCast.
300template <class Containee> // Containee must derive from TObject.
302 static_assert(std::is_base_of<TObject, Containee>::value, "Containee type must inherit from TObject");
303
304 /// This is a workaround against ClassDefInline not supporting classes
305 /// missing their default constructor or having them private.
306 template <class T>
308
310
311public:
312 using TIter::TIter;
313 TRangeDynCastIterator(const TIter &iter) : TIter(iter) {}
314
315 Containee *operator()() = delete;
316
317 Containee *Next() { return dynamic_cast<Containee *>(TIter::Next()); }
318 Containee *operator*() const { return dynamic_cast<Containee *>(TIter::operator*()); }
319
321};
322
323} // namespace Internal
324
325namespace Detail {
326
327/// @brief TTypedIter is a typed version of TIter.
328///
329/// This requires the collection to contains elements of the type requested
330/// (or a derived class). Any deviation from this expectation
331/// will only be caught/reported by an assert in debug builds.
332///
333/// This is best used with a TClonesArray, for other cases prefered TRangeDynCast.
334///
335/// The typical use is:
336/// ```{.cpp}
337/// TTypedIter<TBaseClass> next(tbaseClassClonesArrayPtr);
338/// while(auto bcl = next()) {
339/// ... use bcl as a TBaseClass*
340/// }
341/// ```
342template <class Containee> // Containee must derive from TObject.
343class TTypedIter : public TIter {
344 static_assert(std::is_base_of<TObject, Containee>::value, "Containee type must inherit from TObject");
345
346 /// This is a workaround against ClassDefInline not supporting classes
347 /// missing their default constructor or having them private.
348 template <class T>
350
351 TTypedIter() = default;
352
353 static Containee *StaticCast(TObject *obj)
354 {
355 assert(!obj || ROOT::Internal::ContaineeInheritsFrom(obj->IsA(), Containee::Class()));
356 return static_cast<Containee *>(obj);
357 }
358
359public:
360 using TIter::TIter;
361 TTypedIter(const TIter &iter) : TIter(iter) {}
362
363 Containee *operator()() { return StaticCast(TIter::Next()); }
364 Containee *Next() { return StaticCast(TIter::Next()); }
365 Containee *operator*() const { return StaticCast(TIter::operator*()); }
366
368};
369
370/// @brief TRangeStaticCast is an adaptater class that allows the typed iteration
371/// through a TCollection. This requires the collection to contains element
372/// of the type requested (or a derived class). Any deviation from this expectation
373/// will only be caught/reported by an assert in debug builds.
374///
375/// This is best used with a TClonesArray, for other cases prefered TRangeDynCast.
376///
377/// The typical use is:
378/// ```{.cpp}
379/// for(auto bcl : TRangeStaticCast<TBaseClass>( *tbaseClassClonesArrayPtr )) {
380/// assert(bcl && bcl->IsA()->InheritsFrom(TBaseClass::Class()));
381/// ... use bcl as a TBaseClass*
382/// }
383/// for(auto bcl : TRangeStaticCast<TBaseClass>( tbaseClassClonesArrayPtr )) {
384/// assert(bcl && bcl->IsA()->InheritsFrom(TBaseClass::Class()));
385/// ... use bcl as a TBaseClass*
386/// }
387/// ```
388template <class T>
391
392public:
394 TRangeStaticCast(const TCollection *col) : fCollection(col != nullptr ? *col : ROOT::Internal::EmptyCollection()) {}
395
396 TTypedIter<T> begin() const { return fCollection.begin(); }
397 TTypedIter<T> end() const { return fCollection.end(); }
398};
399
400} // namespace Detail
401} // namespace ROOT
402
403/// @brief TRangeDynCast is an adaptater class that allows the typed iteration
404/// through a TCollection.
405///
406/// The typical use is:
407/// ```{.cpp}
408/// for(auto bcl : TRangeDynCast<TBaseClass>( *cl->GetListOfBases() )) {
409/// if (!bcl) continue;
410/// ... use bcl as a TBaseClass*
411/// }
412/// for(auto bcl : TRangeDynCast<TBaseClass>( cl->GetListOfBases() )) {
413/// if (!bcl) continue;
414/// ... use bcl as a TBaseClass*
415/// }
416/// ```
417template <class T>
420
421public:
423 TRangeDynCast(const TCollection *col) : fCollection(col != nullptr ? *col : ROOT::Internal::EmptyCollection()) {}
424
427};
428
429// Zero overhead macros in case not compiled with thread support
430#if defined (_REENTRANT) || defined (WIN32)
431
432#define R__COLL_COND_MUTEX(mutex) this->IsUsingRWLock() ? mutex : nullptr
433
434#define R__COLLECTION_READ_LOCKGUARD(mutex) ::ROOT::TReadLockGuard _R__UNIQUE_(R__readguard)(R__COLL_COND_MUTEX(mutex))
435#define R__COLLECTION_READ_LOCKGUARD_NAMED(name,mutex) ::ROOT::TReadLockGuard _NAME2_(R__readguard,name)(R__COLL_COND_MUTEX(mutex))
436
437#define R__COLLECTION_WRITE_LOCKGUARD(mutex) ::ROOT::TWriteLockGuard _R__UNIQUE_(R__readguard)(R__COLL_COND_MUTEX(mutex))
438#define R__COLLECTION_WRITE_LOCKGUARD_NAMED(name,mutex) ::ROOT::TWriteLockGuard _NAME2_(R__readguard,name)(R__COLL_COND_MUTEX(mutex))
439
440#else
441
442#define R__COLLECTION_READ_LOCKGUARD(mutex) (void)mutex
443#define R__COLLECTION_COLLECTION_READ_LOCKGUARD_NAMED(name,mutex) (void)mutex
444
445#define R__COLLECTION_WRITE_LOCKGUARD(mutex) (void)mutex
446#define R__COLLECTION_WRITE_LOCKGUARD_NAMED(name,mutex) (void)mutex
447
448#endif
449
450//---- R__FOR_EACH macro -------------------------------------------------------
451
452// Macro to loop over all elements of a list of type "type" while executing
453// procedure "proc" on each element
454
455#define R__FOR_EACH(type,proc) \
456 SetCurrentCollection(); \
457 TIter _NAME3_(nxt_,type,proc)(TCollection::GetCurrentCollection()); \
458 type *_NAME3_(obj_,type,proc); \
459 while ((_NAME3_(obj_,type,proc) = (type*) _NAME3_(nxt_,type,proc)())) \
460 _NAME3_(obj_,type,proc)->proc
461
462#endif
int Int_t
Definition: CPyCppyy.h:43
unsigned long ULong_t
Definition: CPyCppyy.h:51
void Class()
Definition: Class.C:29
#define R__EXTERN
Definition: DllImport.h:27
#define R__ALWAYS_INLINE
Definition: RConfig.hxx:563
#define SafeDelete(p)
Definition: RConfig.hxx:536
#define b(i)
Definition: RSha256.hxx:100
bool Bool_t
Definition: RtypesCore.h:63
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
#define BIT(n)
Definition: Rtypes.h:85
const Bool_t kIterBackward
Definition: TCollection.h:41
R__EXTERN TVirtualMutex * gCollectionMutex
Definition: TCollection.h:43
const Bool_t kIterForward
Definition: TCollection.h:40
TRangeStaticCast is an adaptater class that allows the typed iteration through a TCollection.
Definition: TCollection.h:389
TTypedIter< T > begin() const
Definition: TCollection.h:396
TRangeStaticCast(const TCollection &col)
Definition: TCollection.h:393
const TCollection & fCollection
Definition: TCollection.h:390
TTypedIter< T > end() const
Definition: TCollection.h:397
TRangeStaticCast(const TCollection *col)
Definition: TCollection.h:394
TTypedIter is a typed version of TIter.
Definition: TCollection.h:343
TTypedIter(const TIter &iter)
Definition: TCollection.h:361
ClassDefInline(TTypedIter, 0)
Containee * operator()()
Definition: TCollection.h:363
static Containee * StaticCast(TObject *obj)
Definition: TCollection.h:353
Containee * operator*() const
Definition: TCollection.h:365
Internal help class implmenting an iterator for TRangeDynCast.
Definition: TCollection.h:301
TRangeDynCastIterator(const TIter &iter)
Definition: TCollection.h:313
ClassDefInline(TRangeDynCastIterator, 0)
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
Collection abstract base class.
Definition: TCollection.h:63
virtual void Dump() const
Dump all objects in this collection.
virtual void ls(Option_t *option="") const
List (ls) all objects in this collection.
virtual Bool_t Notify()
'Notify' all objects in this collection.
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
virtual TIterator * MakeIterator(Bool_t dir=kIterForward) const =0
virtual void PrintCollectionEntry(TObject *entry, Option_t *option, Int_t recurse) const
Print the collection entry.
Bool_t IsArgNull(const char *where, const TObject *obj) const
Returns true if object is a null pointer.
virtual TIterator * MakeReverseIterator() const
Definition: TCollection.h:193
TCollection(const TCollection &)
virtual const char * GetName() const
Return name of this collection.
Bool_t IsSortable() const
Definition: TCollection.h:189
void SetCurrentCollection()
Set this collection to be the globally accessible collection.
static TCollection * GetCurrentCollection()
Return the globally accessible collection.
@ kInitHashTableCapacity
Definition: TCollection.h:157
Int_t Capacity() const
Definition: TCollection.h:165
void RemoveAll()
Definition: TCollection.h:202
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
static Bool_t fgEmptyingGarbage
Definition: TCollection.h:134
virtual bool UseRWLock()
Set this collection to use a RW lock upon access, making it thread safe.
Bool_t AssertClass(TClass *cl) const
Make sure all objects in this collection inherit from class cl.
static Int_t fgGarbageStack
Definition: TCollection.h:135
void operator=(const TCollection &)
TIter end() const
Definition: TCollection.h:291
virtual Int_t GrowBy(Int_t delta) const
Increase the collection's capacity by delta slots.
virtual void Clear(Option_t *option="")=0
void SetName(const char *name)
Definition: TCollection.h:204
TIter begin() const
Definition: TCollection.h:290
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
virtual void Draw(Option_t *option="")
Draw all objects in this collection.
virtual void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
ULong_t Hash() const
Return hash value for this object.
Definition: TCollection.h:184
void Browse(TBrowser *b)
Browse this collection (called by TBrowser).
virtual Int_t GetEntries() const
Definition: TCollection.h:177
virtual const char * GetCollectionEntryName(TObject *entry) const
For given collection entry return the string that is used to identify the object and,...
static void EmptyGarbageCollection()
Do the garbage collection.
virtual void PrintCollectionHeader(Option_t *option) const
Print the collection header.
virtual void Delete(Option_t *option="")=0
Delete this object.
virtual TObject ** GetObjectRef(const TObject *obj) const =0
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
static TCollection * fgCurrentCollection
Definition: TCollection.h:132
TString fName
Definition: TCollection.h:147
virtual void Add(TObject *obj)=0
Bool_t IsOwner() const
Definition: TCollection.h:188
virtual TObject * Clone(const char *newname="") const
Make a clone of an collection using the Streamer facility.
virtual TObject * Remove(TObject *obj)=0
virtual Bool_t IsEmpty() const
Definition: TCollection.h:186
R__ALWAYS_INLINE Bool_t IsUsingRWLock() const
Definition: TCollection.h:210
Int_t Compare(const TObject *obj) const
Compare two TCollection objects.
static TObjectTable * fgGarbageCollection
Definition: TCollection.h:133
void AddVector(TObject *obj1,...)
Add all arguments to the collection.
virtual ~TCollection()
TNamed destructor.
static void StartGarbageCollection()
Set up for garbage collection.
static void GarbageCollect(TObject *obj)
Add to the list of things to be cleaned up.
virtual void Paint(Option_t *option="")
Paint all objects in this collection.
virtual Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition: TCollection.h:187
TObject * operator()(const char *name) const
Find an object in this collection by name.
Bool_t Contains(const char *name) const
Definition: TCollection.h:169
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
Bool_t Contains(const TObject *obj) const
Definition: TCollection.h:170
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write all objects in this collection.
TIterCategory(TIterator *it)
Definition: TCollection.h:283
TIterCategory & Begin()
Definition: TCollection.h:285
TIterCategory(const TCollection *col, Bool_t dir=kIterForward)
Definition: TCollection.h:282
virtual ~TIterCategory()
Definition: TCollection.h:284
static TIterCategory End()
Definition: TCollection.h:286
TIter & Begin()
Pointing to the first element of the container.
virtual ~TIter()
Definition: TCollection.h:247
Bool_t operator!=(const TIter &aIter) const
Definition: TCollection.h:261
Bool_t operator==(const TIter &aIter) const
Definition: TCollection.h:254
TIter & operator=(TIterator *iter)
Definition: TCollection.h:264
static TIter End()
Pointing to the element after the last - to a nullptr value in our case.
TObject * Next()
Definition: TCollection.h:249
void Reset()
Definition: TCollection.h:252
TIter & operator++()
Definition: TCollection.h:253
TObject * operator*() const
Definition: TCollection.h:271
TObject * operator()()
Definition: TCollection.h:248
TIter(TIterator *it)
Definition: TCollection.h:244
TIter & operator=(const TIter &rhs)
Assigning an TIter to another.
Option_t * GetOption() const
Definition: TCollection.h:251
TIter(const TCollection *col, Bool_t dir=kIterForward)
Definition: TCollection.h:242
const TCollection * GetCollection() const
Definition: TCollection.h:250
TIterator * fIterator
Definition: TCollection.h:236
Iterator abstract base class.
Definition: TIterator.h:30
virtual Option_t * GetOption() const
Definition: TIterator.h:40
virtual void Reset()=0
virtual const TCollection * GetCollection() const =0
virtual TObject * Next()=0
This class registers all instances of TObject and its derived classes in a hash table.
Definition: TObjectTable.h:35
Mother of all ROOT objects.
Definition: TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
EStatusBits
Definition: TObject.h:57
TRangeDynCast is an adaptater class that allows the typed iteration through a TCollection.
Definition: TCollection.h:418
TRangeDynCast(const TCollection &col)
Definition: TCollection.h:422
ROOT::Internal::TRangeDynCastIterator< T > begin() const
Definition: TCollection.h:425
const TCollection & fCollection
Definition: TCollection.h:419
ROOT::Internal::TRangeDynCastIterator< T > end() const
Definition: TCollection.h:426
TRangeDynCast(const TCollection *col)
Definition: TCollection.h:423
Basic string class.
Definition: TString.h:136
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition: TString.cxx:662
This class implements a mutex interface.
Definition: TVirtualMutex.h:32
bool ContaineeInheritsFrom(TClass *cl, TClass *base)
Return true if 'cl' inherits from 'base'.
const TCollection & EmptyCollection()
Return an empty collection for use with nullptr TRangeCast.
static const std::string name("name")
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: RNumpyDS.hxx:30