ROOT logo
ROOT » IO » IO » TGenCollectionProxy

class TGenCollectionProxy: public TVirtualCollectionProxy


 Proxy around an arbitrary container, which implements basic
 functionality and iteration.

 In particular this is used to implement splitting and abstract
 element access of any container. Access to compiled code is necessary
 to implement the abstract iteration sequence and functionality like
 size(), clear(), resize(). resize() may be a void operation.

Function Members (Methods)

TGenCollectionProxy(const TGenCollectionProxy& copy)
TGenCollectionProxy(TGenCollectionProxy::Info_t typ, size_t iter_size)
TGenCollectionProxy(const ROOT::TCollectionProxyInfo& info, TClass* cl)
virtual void*Allocate(UInt_t n, Bool_t forceDelete)
virtual void*At(UInt_t idx)
virtual voidClear(const char* opt = "")
virtual voidCommit(void* env)
virtual voidTVirtualCollectionProxy::DeleteArray(void* p, Bool_t dtorOnly = kFALSE)
virtual voidTVirtualCollectionProxy::Destructor(void* p, Bool_t dtorOnly = kFALSE)
virtual TVirtualCollectionProxy*Generate() const
virtual TClass*GetCollectionClass()
virtual Int_tGetCollectionType()
virtual TStreamerInfoActions::TActionSequence*GetConversionReadMemberWiseActions(TClass* oldClass, Int_t version)
virtual TVirtualCollectionProxy::CopyIterator_tGetFunctionCopyIterator(Bool_t read = kTRUE)
virtual TVirtualCollectionProxy::CreateIterators_tGetFunctionCreateIterators(Bool_t read = kTRUE)
virtual TVirtualCollectionProxy::DeleteIterator_tGetFunctionDeleteIterator(Bool_t read = kTRUE)
virtual TVirtualCollectionProxy::DeleteTwoIterators_tGetFunctionDeleteTwoIterators(Bool_t read = kTRUE)
virtual TVirtualCollectionProxy::Next_tGetFunctionNext(Bool_t read = kTRUE)
virtual ULong_tGetIncrement()
virtual TClass*GetOnFileClass() const
virtual Int_tTVirtualCollectionProxy::GetProperties()
virtual TStreamerInfoActions::TActionSequence*GetReadMemberWiseActions(Int_t version)
virtual EDataTypeGetType()
virtual TClass*GetValueClass()
virtual TStreamerInfoActions::TActionSequence*GetWriteMemberWiseActions()
virtual Bool_tHasPointers() const
virtual void*TVirtualCollectionProxy::New() const
virtual void*TVirtualCollectionProxy::New(void* arena) const
virtual void*TVirtualCollectionProxy::NewArray(Int_t nElements) const
virtual void*TVirtualCollectionProxy::NewArray(Int_t nElements, void* arena) const
virtual voidoperator()(TBuffer& refBuffer, void* pObject)
char*TVirtualCollectionProxy::operator[](UInt_t idx) const
virtual voidPopProxy()
virtual voidPushProxy(void* objstart)
virtual voidReadBuffer(TBuffer& b, void* obj)
virtual voidReadBuffer(TBuffer& b, void* obj, const TClass* onfileClass)
virtual voidResize(UInt_t n, Bool_t force_delete)
virtual voidSetOnFileClass(TClass* cl)
virtual voidSetValueClass(TClass* newcl)
virtual UInt_tSize() const
virtual UInt_tSizeof() const
virtual voidStreamer(TBuffer& refBuffer)
virtual voidStreamer(TBuffer& refBuffer, void* pObject, int siz)
voidCheckFunctions() const
virtual voidDeleteItem(Bool_t force, void* ptr) const
TGenCollectionProxy*Initialize(Bool_t silent) const
virtual TGenCollectionProxy*InitializeEx(Bool_t silent)

Data Members

enum TVirtualCollectionProxy::EProperty { kIsInitialized
static const Int_tTVirtualCollectionProxy::fgIteratorArenaSizegreater than sizeof(void*) + sizeof(UInt_t)
TGenCollectionProxy::MethodfClearMethod cache for container accessors: clear container
TGenCollectionProxy::MethodfCollectMethod to collect objects from container
void*fConstructContainer accessors: block construct
map<std::string,TObjArray*>*fConversionReadMemberWiseArray of bundle of TStreamerInfoActions to stream out (read) derived from another class.
TGenCollectionProxy::Method0fCreateEnvMethod to allocate an Environment holder.
void*fDestructContainer accessors: block destruct
ROOT::TCollectionProxyInfo::EnvironBase*fEnvAddress of the currently proxied object
void*fFeedContainer accessors: block feed
TGenCollectionProxy::MethodfFirstContainer accessors: generic iteration: first
TGenCollectionProxy::Value*fKeyDescriptor of the key_type
stringfNameName of the class being proxied.
TGenCollectionProxy::MethodfNextContainer accessors: generic iteration: next
TClass*fOnFileClassOn file class
Bool_tfPointersFlag to indicate if containee has pointers (key or value)
vector<ROOT::TCollectionProxyInfo::EnvironBase*,allocator<ROOT::TCollectionProxyInfo::EnvironBase*> >fProxyKeptOptimization: Keep proxies once they were created
vector<ROOT::TCollectionProxyInfo::EnvironBase*,allocator<ROOT::TCollectionProxyInfo::EnvironBase*> >fProxyListStack of recursive proxies
TObjArray*fReadMemberWiseArray of bundle of TStreamerInfoActions to stream out (read)
void*fResizeContainer accessors: resize container
intfSTL_typeSTL container type
TGenCollectionProxy::MethodfSizeContainer accessors: size of container
vector<TGenCollectionProxy::TStaging*,allocator<TGenCollectionProxy::TStaging*> >fStagedOptimization: Keep staged array once they were created
type_info&fTypeinfoType information
TGenCollectionProxy::Value*fValDescriptor of the Value_type
intfValDiffOffset between two consecutive value_types (memory layout).
intfValOffsetOffset from key to value (in maps)
TGenCollectionProxy::Value*fValueDescriptor of the container value type

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void DeleteItem(void* ptr)
 Delete individual item from STL container
s. Streamer(TBuffer& refBuffer)
s. Streamer(TBuffer& refBuffer)
else s-> Clear()
void Resize(size_t nelement)
TGenCollectionProxy* Initialize(Bool_t silent) const
 Late initialization of collection proxy
TGenCollectionProxy* InitializeEx(Bool_t silent)
 Some hack to avoid const-ness.
void CheckFunctions() const
 Allow to check function pointers.
TVirtualCollectionProxy* Generate() const
 Virtual copy constructor.
TGenCollectionProxy(const TGenCollectionProxy& copy)
 Copy constructor.
TGenCollectionProxy(TGenCollectionProxy::Info_t typ, size_t iter_size)
 Initializing constructor
TGenCollectionProxy(const ROOT::TCollectionProxyInfo& info, TClass* cl)
virtual ~TGenCollectionProxy()
 Standard destructor.
TClass * GetCollectionClass()
 Return a pointer to the TClass representing the container.
Int_t GetCollectionType()
 Return the type of collection see TClassEdit::ESTLType
ULong_t GetIncrement()
 Return the offset between two consecutive value_types (memory layout).
UInt_t Sizeof() const
 Return the sizeof the collection object.
void PushProxy(void* objstart)
 Push new proxy environment.
void PopProxy()
 Pop old proxy environment.
Bool_t HasPointers() const
 Return true if the content is of type 'pointer to'.
TClass * GetValueClass()
 Return a pointer to the TClass representing the content.
void SetValueClass(TClass* newcl)
 Set pointer to the TClass representing the content.
EDataType GetType()
 If the content is a simple numerical value, return its type (see TDataType).
void * At(UInt_t idx)
 Return the address of the value at index 'idx'.
UInt_t Size() const
 Return the current size of the container.
void* Allocate(UInt_t n, Bool_t forceDelete)
 Block allocation of containees.
void Commit(void* env)
 Block commit of containees.
void operator()(TBuffer& refBuffer, void* pObject)
 TClassStreamer I/O overload.
void ReadBuffer(TBuffer& b, void* obj)
 Routine to read the content of the buffer into 'obj'.
void ReadBuffer(TBuffer& b, void* obj, const TClass* onfileClass)
void SetOnFileClass(TClass* cl)
{ fOnFileClass = cl; }
TClass* GetOnFileClass() const
{ return fOnFileClass; }
TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass* oldClass, Int_t version)
 MemberWise actions
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version)
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions()
CreateIterators_t GetFunctionCreateIterators(Bool_t read = kTRUE)
 Set of functions to iterate easily throught the collection
CopyIterator_t GetFunctionCopyIterator(Bool_t read = kTRUE)
 typedef void (*CreateIterators_t)(void *collection, void **begin_arena, void **end_arena);
 begin_arena and end_arena should contain the location of a memory arena of size fgIteratorSize.
 If the collection iterator are of that size or less, the iterators will be constructed in place in those location (new with placement)
 Otherwise the iterators will be allocated via a regular new and their address returned by modifying the value of begin_arena and end_arena.
Next_t GetFunctionNext(Bool_t read = kTRUE)
 typedef void* (*CopyIterator_t)(void *dest, const void *source);
 Copy the iterator source, into dest.   dest should contain the location of a memory arena of size fgIteratorSize.
 If the collection iterator is of that size or less, the iterator will be constructed in place in this location (new with placement)
 Otherwise the iterator will be allocated via a regular new and its address returned by modifying the value of dest.
DeleteIterator_t GetFunctionDeleteIterator(Bool_t read = kTRUE)
 typedef void* (*Next_t)(void *iter, const void *end);
 iter and end should be pointers to respectively an iterator to be incremented and the result of collection.end()
 If the iterator has not reached the end of the collection, 'Next' increment the iterator 'iter' and return 0 if
 the iterator reached the end.
 If the end was not reached, 'Next' returns the address of the content pointed to by the iterator before the
 incrementation ; if the collection contains pointers, 'Next' will return the value of the pointer.
DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read = kTRUE)
 typedef void (*DeleteIterator_t)(void *iter);
 typedef void (*DeleteTwoIterators_t)(void *begin, void *end);
 If the size of the iterator is greater than fgIteratorArenaSize, call delete on the addresses,
 Otherwise just call the iterator's destructor.