ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
TGenCollectionProxy.h
Go to the documentation of this file.
1 // @(#)root/io:$Id$
2 // Author: Markus Frank 28/10/04
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, 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 #ifndef ROOT_TGenCollectionProxy
12 #define ROOT_TGenCollectionProxy
13 
14 #ifndef ROOT_TBuffer
15 #include "TBuffer.h"
16 #endif
17 
18 #ifndef ROOT_TVirtualCollectionProxy
20 #endif
21 
22 #ifndef ROOT_TCollectionProxyInfo
23 #include "TCollectionProxyInfo.h"
24 #endif
25 
26 #ifndef ROOT_Rtypeinfo
27 #include "Rtypeinfo.h"
28 #endif
29 
30 #include <atomic>
31 #include <string>
32 #include <map>
33 #include <stdlib.h>
34 
35 class TObjArray;
37 
40 {
41 
42  // Friend declaration
44 
45 public:
46 
47 #ifdef R__HPUX
48  typedef const type_info& Info_t;
49 #else
50  typedef const std::type_info& Info_t;
51 #endif
52 
53  enum {
54  // Those 'bits' are used in conjunction with CINT's bit to store the 'type'
55  // info into one int
56  kBIT_ISSTRING = 0x20000000, // We can optimized a value operation when the content are strings
57  kBIT_ISTSTRING = 0x40000000,
58  kBOOL_t = 21
59  };
60 
61  /** @class TGenCollectionProxy::Value TGenCollectionProxy.h TGenCollectionProxy.h
62  *
63  * Small helper to describe the Value_type or the key_type
64  * of an STL container.
65  *
66  * @author M.Frank
67  * @version 1.0
68  * @date 10/10/2004
69  */
70  struct Value {
71  ROOT::NewFunc_t fCtor; ///< Method cache for containee constructor
72  ROOT::DesFunc_t fDtor; ///< Method cache for containee destructor
73  ROOT::DelFunc_t fDelete; ///< Method cache for containee delete
74  UInt_t fCase; ///< type of data of Value_type
75  UInt_t fProperties; ///< Additional properties of the value type (kNeedDelete)
76  TClassRef fType; ///< TClass reference of Value_type in collection
77  EDataType fKind; ///< kind of ROOT-fundamental type
78  size_t fSize; ///< fSize of the contained object
79 
80  // Default copy constructor has the correct implementation.
81 
82  // Initializing constructor
83  Value(const std::string& info, Bool_t silent);
84  // Delete individual item from STL container
85  void DeleteItem(void* ptr);
86 
87  Bool_t IsValid();
88  };
89 
90  /**@class StreamHelper
91  *
92  * Helper class to facilitate I/O
93  *
94  * @author M.Frank
95  * @version 1.0
96  * @date 10/10/2004
97  */
98  union StreamHelper {
112  void* p_void;
113  void** pp_void;
114  char* kchar;
116  void* ptr() {
117  return *(&this->p_void);
118  }
119  std::string* str() {
120  return (std::string*)this;
121  }
122  const char* c_str() {
123  return ((std::string*)this)->c_str();
124  }
125  const char* c_pstr() {
126  return (*(std::string**)this)->c_str();
127  }
128  void set(void* p) {
129  *(&this->p_void) = p;
130  }
132  TString s;
133  s.Streamer(b);
134  ((std::string*)this)->assign(s.Data());
135  }
136  void* read_tstring(TBuffer& b) {
137  *((TString*)this) = "";
138  ((TString*)this)->Streamer(b);
139  return this;
140  }
142  TString s;
143  std::string* str2 = (std::string*)ptr();
144  if (!str2) str2 = new std::string();
145  s.Streamer(b);
146  *str2 = s;
147  set(str2);
148  }
150  const char* c;
151  if (ptr()) {
152  std::string* strptr = (*(std::string**)this);
153  c = (const char*)(strptr->c_str());
154  } else c = "";
155  TString(c).Streamer(b);
156  }
158  void* p = ptr();
159  if ( p ) {
160  if ( v->fDelete ) { // Compiled content: call Destructor
161  (*v->fDelete)(p);
162  }
163  else if ( v->fType ) { // Emulated content: call TClass::Delete
164  v->fType->Destructor(p);
165  }
166  else if ( v->fDtor ) {
167  (*v->fDtor)(p);
168  ::operator delete(p);
169  }
170  else {
171  ::operator delete(p);
172  }
173  }
174  set( b.ReadObjectAny(v->fType) );
175  }
176 
178  TString* s = (TString*)ptr();
179  if ( vsn3 ) {
180  if ( !s ) s = new TString();
181  else s->Clear();
182  s->Streamer(b);
183  set(s);
184  return;
185  }
186  if ( s ) delete s;
188  }
191  }
192  };
193 
194  /** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollectionProxy.h
195  *
196  * Small helper to execute (compiler) generated function for the
197  * access to STL or other containers.
198  *
199  * @author M.Frank
200  * @version 1.0
201  * @date 10/10/2004
202  */
203  class Method {
204  public:
205  typedef void* (*Call_t)(void*);
207  Method() : call(0) { }
208  Method(Call_t c) : call(c) { }
209  Method(const Method& m) : call(m.call) { }
210  Method &operator=(const Method& m) { call = m.call; return *this; }
211  void* invoke(void* obj) const { return (*call)(obj); }
212  };
213 
214  /** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollectionProxy.h
215  *
216  * Small helper to execute (compiler) generated function for the
217  * access to STL or other containers.
218  *
219  * @author M.Frank
220  * @version 1.0
221  * @date 10/10/2004
222  */
223  class Method0 {
224  public:
225  typedef void* (*Call_t)();
227  Method0() : call(0) { }
228  Method0(Call_t c) : call(c) { }
229  Method0(const Method0& m) : call(m.call) { }
230  Method0 &operator=(const Method0& m) { call = m.call; return *this; }
231  void* invoke() const { return (*call)(); }
232  };
233 
234  /** @class TGenCollectionProxy::TStaging
235  *
236  * Small helper to stage the content of an associative
237  * container when reading and before inserting it in the
238  * actual collection.
239  *
240  * @author Ph.Canal
241  * @version 1.0
242  * @date 20/08/2010
243  */
244  class TStaging {
245  void *fTarget; ///< Pointer to the collection we are staging for.
246  void *fContent; ///< Pointer to the content
247  size_t fReserved; ///< Amount of space already reserved.
248  size_t fSize; ///< Number of elements
249  size_t fSizeOf; ///< size of each elements
250 
251  TStaging(const TStaging&); ///< Not implemented.
252  TStaging &operator=(const TStaging&); ///< Not implemented.
253 
254  public:
255  TStaging(size_t size, size_t size_of) : fTarget(0), fContent(0), fReserved(0), fSize(size), fSizeOf(size_of)
256  {
257  // Usual constructor. Reserves the required number of elements.
258  fReserved = fSize;
260  }
261 
263  // Usual destructor
264  ::free(fContent);
265  }
266 
267  void *GetContent() {
268  // Return the location of the array of content.
269  return fContent;
270  }
271  void *GetEnd() {
272  // Return the 'end' of the array of content.
273  return ((char*)fContent) + fSize*fSizeOf;
274  }
275  size_t GetSize() {
276  // Return the number of elements.
277  return fSize;
278  }
279  void *GetTarget() {
280  // Get the address of the collection we are staging for.
281  return fTarget;
282  }
283  void Resize(size_t nelement) {
284  if (fReserved < nelement) {
285  fReserved = nelement;
286  fContent = ::realloc(fContent,fReserved * fSizeOf);
287  }
288  fSize = nelement;
289  }
290  void SetTarget(void *target) {
291  // Set the collection we are staging for.
292  fTarget = target;
293  }
294  };
295 
296 protected:
299  typedef std::vector<TStaging*> Staged_t; ///< Collection of pre-allocated staged array for associative containers.
300  typedef std::vector<EnvironBase_t*> Proxies_t;
301  mutable TObjArray *fReadMemberWise; ///< Array of bundle of TStreamerInfoActions to stream out (read)
302  mutable std::map<std::string, TObjArray*> *fConversionReadMemberWise; ///< Array of bundle of TStreamerInfoActions to stream out (read) derived from another class.
304  typedef void (*Sizing_t)(void *obj, size_t size);
305  typedef void* (*Feedfunc_t)(void *from, void *to, size_t size);
306  typedef void* (*Collectfunc_t)(void *from, void *to);
307  typedef void* (*ArrIterfunc_t)(void *from, size_t size);
308 
309  std::string fName; ///< Name of the class being proxied.
310  Bool_t fPointers; ///< Flag to indicate if containee has pointers (key or value)
311  Method fClear; ///< Method cache for container accessors: clear container
312  Method fSize; ///< Container accessors: size of container
313  Sizing_t fResize; ///< Container accessors: resize container
314  Method fFirst; ///< Container accessors: generic iteration: first
315  Method fNext; ///< Container accessors: generic iteration: next
316  ArrIterfunc_t fConstruct; ///< Container accessors: block construct
317  Sizing_t fDestruct; ///< Container accessors: block destruct
318  Feedfunc_t fFeed; ///< Container accessors: block feed
319  Collectfunc_t fCollect; ///< Method to collect objects from container
320  Method0 fCreateEnv; ///< Method to allocate an Environment holder.
321  std::atomic<Value*> fValue; ///< Descriptor of the container value type
322  Value* fVal; ///< Descriptor of the Value_type
323  Value* fKey; ///< Descriptor of the key_type
324  EnvironBase_t*fEnv; ///< Address of the currently proxied object
325  int fValOffset; ///< Offset from key to value (in maps)
326  int fValDiff; ///< Offset between two consecutive value_types (memory layout).
327  Proxies_t fProxyList; ///< Stack of recursive proxies
328  Proxies_t fProxyKept; ///< Optimization: Keep proxies once they were created
329  Staged_t fStaged; ///< Optimization: Keep staged array once they were created
330  int fSTL_type; ///< STL container type
331  Info_t fTypeinfo; ///< Type information
332  TClass* fOnFileClass; ///< On file class
333 
339 
340  // Late initialization of collection proxy
341  TGenCollectionProxy* Initialize(Bool_t silent) const;
342  // Some hack to avoid const-ness.
343  virtual TGenCollectionProxy* InitializeEx(Bool_t silent);
344  // Call to delete/destruct individual contained item.
345  virtual void DeleteItem(Bool_t force, void* ptr) const;
346  // Allow to check function pointers.
347  void CheckFunctions() const;
348 
349  // Set pointer to the TClass representing the content.
350  virtual void UpdateValueClass(const TClass *oldcl, TClass *newcl);
351 
352 private:
353  TGenCollectionProxy(); // not implemented on purpose.
354 
355 public:
356 
357  // Virtual copy constructor.
358  virtual TVirtualCollectionProxy* Generate() const;
359 
360  // Copy constructor.
362 
363 private:
364  // Assignment operator
365  TGenCollectionProxy &operator=(const TGenCollectionProxy&); // Not Implemented
366 
367 public:
368  // Initializing constructor
369  TGenCollectionProxy(Info_t typ, size_t iter_size);
371 
372  // Standard destructor.
373  virtual ~TGenCollectionProxy();
374 
375  // Return a pointer to the TClass representing the container.
376  virtual TClass *GetCollectionClass() const;
377 
378  // Return the type of collection see TClassEdit::ESTLType
379  virtual Int_t GetCollectionType() const;
380 
381  // Return the offset between two consecutive value_types (memory layout).
382  virtual ULong_t GetIncrement() const;
383 
384  // Return the sizeof the collection object.
385  virtual UInt_t Sizeof() const;
386 
387  // Push new proxy environment.
388  virtual void PushProxy(void *objstart);
389 
390  // Pop old proxy environment.
391  virtual void PopProxy();
392 
393  // Return true if the content is of type 'pointer to'.
394  virtual Bool_t HasPointers() const;
395 
396  // Return a pointer to the TClass representing the content.
397  virtual TClass *GetValueClass() const;
398 
399  // If the content is a simple numerical value, return its type (see TDataType).
400  virtual EDataType GetType() const;
401 
402  // Return the address of the value at index 'idx'.
403  virtual void *At(UInt_t idx);
404 
405  // Clear the container.
406  virtual void Clear(const char *opt = "");
407 
408  // Resize the container.
409  virtual void Resize(UInt_t n, Bool_t force_delete);
410 
411  // Return the current size of the container.
412  virtual UInt_t Size() const;
413 
414  // Block allocation of containees.
415  virtual void* Allocate(UInt_t n, Bool_t forceDelete);
416 
417  // Insert data into the container where data is a C-style array of the actual type contained in the collection
418  // of the given size. For associative container (map, etc.), the data type is the pair<key,value>.
419  virtual void Insert(const void *data, void *container, size_t size);
420 
421  // Block commit of containees.
422  virtual void Commit(void* env);
423 
424  // Streamer function.
425  virtual void Streamer(TBuffer &refBuffer);
426 
427  // Streamer I/O overload.
428  virtual void Streamer(TBuffer &refBuffer, void *pObject, int siz);
429 
430  // TClassStreamer I/O overload.
431  virtual void operator()(TBuffer &refBuffer, void *pObject);
432 
433  // Routine to read the content of the buffer into 'obj'.
434  virtual void ReadBuffer(TBuffer &b, void *obj);
435  virtual void ReadBuffer(TBuffer &b, void *obj, const TClass *onfileClass);
436 
437  virtual void SetOnFileClass( TClass* cl ) { fOnFileClass = cl; }
438  virtual TClass* GetOnFileClass() const { return fOnFileClass; }
439 
440  // MemberWise actions
444 
445  // Set of functions to iterate easily throught the collection
446 
448  // typedef void (*CreateIterators_t)(void *collection, void **begin_arena, void **end_arena);
449  // begin_arena and end_arena should contain the location of a memory arena of size fgIteratorSize.
450  // If the collection iterator are of that size or less, the iterators will be constructed in place in those location (new with placement)
451  // Otherwise the iterators will be allocated via a regular new and their address returned by modifying the value of begin_arena and end_arena.
452 
454  // typedef void* (*CopyIterator_t)(void **dest, const void *source);
455  // Copy the iterator source, into dest. dest should contain the location of a memory arena of size fgIteratorSize.
456  // If the collection iterator is of that size or less, the iterator will be constructed in place in this location (new with placement)
457  // Otherwise the iterator will be allocated via a regular new.
458  // The actual address of the iterator is returned in both case.
459 
461  // typedef void* (*Next_t)(void *iter, const void *end);
462  // iter and end should be pointers to respectively an iterator to be incremented and the result of collection.end()
463  // If the iterator has not reached the end of the collection, 'Next' increment the iterator 'iter' and return 0 if
464  // the iterator reached the end.
465  // If the end was not reached, 'Next' returns the address of the content pointed to by the iterator before the
466  // incrementation ; if the collection contains pointers, 'Next' will return the value of the pointer.
467 
470  // typedef void (*DeleteIterator_t)(void *iter);
471  // typedef void (*DeleteTwoIterators_t)(void *begin, void *end);
472  // If the size of the iterator is greater than fgIteratorArenaSize, call delete on the addresses,
473  // Otherwise just call the iterator's destructor.
474 
475 };
476 
477 template <typename T>
480  : TGenCollectionProxy(typeid(T::Cont_t),sizeof(T::Iter_t))
481  {
482  // Constructor.
483  fValDiff = sizeof(T::Value_t);
484  fValOffset = T::value_offset();
485  fSize.call = T::size;
486  fResize = T::resize;
487  fNext.call = T::next;
488  fFirst.call = T::first;
489  fClear.call = T::clear;
490  fConstruct = T::construct;
491  fDestruct = T::destruct;
492  fFeed = T::feed;
493  CheckFunctions();
494  }
495  virtual ~AnyCollectionProxy() { }
496 };
497 
498 #endif
499 
Method fSize
Container accessors: size of container.
void(* DeleteIterator_t)(void *iter)
size_t fSize
Number of elements.
double read(const std::string &file_name)
reading
DeleteIterator_t fFunctionDeleteIterator
ROOT::DelFunc_t fDelete
Method cache for containee delete.
An array of TObjects.
Definition: TObjArray.h:39
ROOT::NewFunc_t fCtor
Method cache for containee constructor.
virtual TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version)
Return the set of action necessary to stream in this collection member-wise coming from the old value...
Proxies_t fProxyKept
Optimization: Keep proxies once they were created.
TStaging(const TStaging &)
Not implemented.
long long Long64_t
Definition: RtypesCore.h:69
virtual TVirtualCollectionProxy * Generate() const
Virtual copy constructor.
DeleteTwoIterators_t fFunctionDeleteTwoIterators
void * invoke(void *obj) const
UInt_t fProperties
Additional properties of the value type (kNeedDelete)
ROOT::Detail::TCollectionProxyInfo::EnvironBase EnvironBase_t
virtual void UpdateValueClass(const TClass *oldcl, TClass *newcl)
Update the internal ValueClass when a TClass constructor need to replace an emulated TClass by the re...
ClassImp(TSeqCollection) Int_t TSeqCollection TIter next(this)
Return index of object in collection.
virtual TClass * GetOnFileClass() const
float Float_t
Definition: RtypesCore.h:53
Bool_t fPointers
Flag to indicate if containee has pointers (key or value)
std::map< std::string, TObjArray * > * fConversionReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read) derived from another class...
TGenCollectionProxy * Initialize(Bool_t silent) const
Proxy initializer.
return c
Collectfunc_t fCollect
Method to collect objects from container.
std::string fName
Name of the class being proxied.
void(* Sizing_t)(void *obj, size_t size)
TStaging(size_t size, size_t size_of)
virtual Int_t WriteObjectAny(const void *obj, const TClass *ptrClass)=0
unsigned short UShort_t
Definition: RtypesCore.h:36
virtual TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions()
Return the set of action necessary to stream out this collection member-wise.
virtual void PopProxy()
Remove the last object.
virtual void Insert(const void *data, void *container, size_t size)
Insert data into the container where data is a C-style array of the actual type contained in the coll...
Method fFirst
Container accessors: generic iteration: first.
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
TClass * fOnFileClass
On file class.
Basic string class.
Definition: TString.h:137
Feedfunc_t fFeed
Container accessors: block feed.
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
UInt_t fCase
type of data of Value_type
virtual Bool_t HasPointers() const
Return true if the content is of type 'pointer to'.
virtual ULong_t GetIncrement() const
Return the offset between two consecutive value_types (memory layout).
Sizing_t fResize
Container accessors: resize container.
void *(* CopyIterator_t)(void *dest, const void *source)
size_t fSize
fSize of the contained object
TTree * T
const char * Data() const
Definition: TString.h:349
virtual Int_t GetCollectionType() const
Return the type of collection see TClassEdit::ESTLType.
virtual void DeleteItem(Bool_t force, void *ptr) const
Call to delete/destruct individual item.
TObjArray * fReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read)
CopyIterator_t fFunctionCopyIterator
virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE)
See typedef void (*CreateIterators_t)(void *collection, void *&begin_arena, void *&end_arena); begin_...
virtual TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version)
Return the set of action necessary to stream in this collection member-wise coming from the old value...
void Class()
Definition: Class.C:29
void Clear()
Clear string without changing its capacity.
Definition: TString.cxx:1126
TStaging & operator=(const TStaging &)
Not implemented.
virtual UInt_t Size() const
Return the current size of the container.
void *(* ArrIterfunc_t)(void *from, size_t size)
Proxies_t fProxyList
Stack of recursive proxies.
Method fClear
Method cache for container accessors: clear container.
Method0 fCreateEnv
Method to allocate an Environment holder.
ArrIterfunc_t fConstruct
Container accessors: block construct.
virtual void Streamer(TBuffer &refBuffer)
Streamer Function.
void * fContent
Pointer to the content.
std::vector< EnvironBase_t * > Proxies_t
EDataType fKind
kind of ROOT-fundamental type
Staged_t fStaged
Optimization: Keep staged array once they were created.
virtual EDataType GetType() const
If the content is a simple numerical value, return its type (see TDataType)
int fValOffset
Offset from key to value (in maps)
Method0 & operator=(const Method0 &m)
void *(* Feedfunc_t)(void *from, void *to, size_t size)
int fSTL_type
STL container type.
SVector< double, 2 > v
Definition: Dict.h:5
virtual void Commit(void *env)
Commit the change.
std::vector< TStaging * > Staged_t
Collection of pre-allocated staged array for associative containers.
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
Definition: TClass.cxx:4959
unsigned int UInt_t
Definition: RtypesCore.h:42
TMarker * m
Definition: textangle.C:8
bool first
Definition: line3Dfit.C:48
virtual void PushProxy(void *objstart)
Add an object.
short Short_t
Definition: RtypesCore.h:35
virtual Next_t GetFunctionNext(Bool_t read=kTRUE)
See typedef void* (*Next_t)(void *iter, void *end); iter and end should be pointer to respectively an...
CreateIterators_t fFunctionCreateIterators
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:81
TGenCollectionProxy & operator=(const TGenCollectionProxy &)
void read_any_object(Value *v, TBuffer &b)
void * fTarget
Pointer to the collection we are staging for.
Small helper to execute (compiler) generated function for the access to STL or other containers...
int fValDiff
Offset between two consecutive value_types (memory layout).
tuple free
Definition: fildir.py:30
void(* DesFunc_t)(void *)
Definition: Rtypes.h:151
long Long_t
Definition: RtypesCore.h:50
virtual void Resize(UInt_t n, Bool_t force_delete)
Resize the container.
TCollectionProxyFactory Interface to collection proxy and streamer generator.
virtual DeleteIterator_t GetFunctionDeleteIterator(Bool_t read=kTRUE)
See typedef void (*DeleteIterator_t)(void *iter); If the sizeof iterator is greater than fgIteratorAr...
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:147
virtual DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read=kTRUE)
See typedef void (*DeleteTwoIterators_t)(void *begin, void *end); If the sizeof iterator is greater t...
double Double_t
Definition: RtypesCore.h:55
virtual TGenCollectionProxy * InitializeEx(Bool_t silent)
Proxy initializer.
void(* CreateIterators_t)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
unsigned long long ULong64_t
Definition: RtypesCore.h:70
unsigned long ULong_t
Definition: RtypesCore.h:51
void *(* Next_t)(void *iter, const void *end)
EDataType
Definition: TDataType.h:30
virtual void * ReadObjectAny(const TClass *cast)=0
void CheckFunctions() const
Check existence of function pointers.
std::atomic< Value * > fValue
Descriptor of the container value type.
TClassRef fType
TClass reference of Value_type in collection.
virtual void SetOnFileClass(TClass *cl)
virtual void Clear(const char *opt="")
Clear the emulated collection.
virtual void ReadBuffer(TBuffer &b, void *obj)
virtual CopyIterator_t GetFunctionCopyIterator(Bool_t read=kTRUE)
See typedef void (*CopyIterator_t)(void *&dest, const void *source); Copy the iterator source...
virtual TClass * GetValueClass() const
Return a pointer to the TClass representing the content.
Value(const std::string &info, Bool_t silent)
Constructor.
virtual void * At(UInt_t idx)
Return the address of the value at index 'idx'.
size_t fSizeOf
size of each elements
TClassRef is used to implement a permanent reference to a TClass object.
Definition: TClassRef.h:33
char Char_t
Definition: RtypesCore.h:29
typedef void((*Func_t)())
Value * fKey
Descriptor of the key_type.
virtual void operator()(TBuffer &refBuffer, void *pObject)
TClassStreamer IO overload.
Small helper to stage the content of an associative container when reading and before inserting it in...
Helper class to facilitate I/O.
Proxy around an arbitrary container, which implements basic functionality and iteration.
EnvironBase_t * fEnv
Address of the currently proxied object.
Sizing_t fDestruct
Container accessors: block destruct.
Bool_t IsValid()
Return true if the Value has been properly initialized.
Method fNext
Container accessors: generic iteration: next.
void(* DeleteTwoIterators_t)(void *begin, void *end)
size_t fReserved
Amount of space already reserved.
unsigned char UChar_t
Definition: RtypesCore.h:34
Info_t fTypeinfo
Type information.
ROOT::Detail::TCollectionProxyInfo::Environ< char[64]> Env_t
void *(* Collectfunc_t)(void *from, void *to)
const Bool_t kTRUE
Definition: Rtypes.h:91
TObject * obj
virtual TClass * GetCollectionClass() const
Return a pointer to the TClass representing the container.
virtual UInt_t Sizeof() const
Return the sizeof the collection object.
Vc_ALWAYS_INLINE_L T *Vc_ALWAYS_INLINE_R malloc(size_t n)
Allocates memory on the Heap with alignment and padding suitable for vectorized access.
Definition: memory.h:67
const std::type_info & Info_t
const Int_t n
Definition: legend1.C:16
TStreamerInfoActions::TActionSequence * fWriteMemberWise
void(* DelFunc_t)(void *)
Definition: Rtypes.h:149
Small helper to describe the Value_type or the key_type of an STL container.
Method & operator=(const Method &m)
void read_tstring_pointer(Bool_t vsn3, TBuffer &b)
virtual ~TGenCollectionProxy()
Standard destructor.
virtual void * Allocate(UInt_t n, Bool_t forceDelete)
Allocate the needed space.
Value * fVal
Descriptor of the Value_type.
ROOT::DesFunc_t fDtor
Method cache for containee destructor.