Logo ROOT  
Reference Guide
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#include "TBuffer.h"
15
17
19
20#include <atomic>
21#include <string>
22#include <map>
23#include <cstdlib>
24#include <vector>
25
26class TObjArray;
28
31{
32
33 // Friend declaration
35
36public:
37
38#ifdef R__HPUX
39 typedef const std::type_info& Info_t;
40#else
41 typedef const std::type_info& Info_t;
42#endif
43
44 enum {
45 // Those 'bits' are used in conjunction with CINT's bit to store the 'type'
46 // info into one int
47 kBIT_ISSTRING = 0x20000000, // We can optimized a value operation when the content are strings
48 kBIT_ISTSTRING = 0x40000000
49 };
50
51 /** @class TGenCollectionProxy::Value TGenCollectionProxy.h TGenCollectionProxy.h
52 *
53 * Small helper to describe the Value_type or the key_type
54 * of an STL container.
55 *
56 * @author M.Frank
57 * @version 1.0
58 * @date 10/10/2004
59 */
60 struct Value {
61 ROOT::NewFunc_t fCtor; ///< Method cache for containee constructor
62 ROOT::DesFunc_t fDtor; ///< Method cache for containee destructor
63 ROOT::DelFunc_t fDelete; ///< Method cache for containee delete
64 UInt_t fCase; ///< type of data of Value_type
65 UInt_t fProperties; ///< Additional properties of the value type (kNeedDelete)
66 TClassRef fType; ///< TClass reference of Value_type in collection
67 EDataType fKind; ///< kind of ROOT-fundamental type
68 size_t fSize; ///< fSize of the contained object
69
70 // Default copy constructor has the correct implementation.
71
72 // Initializing constructor
73 Value(const std::string& info, Bool_t silent, size_t hint_pair_offset = 0, size_t hint_pair_size = 0);
74 // Delete individual item from STL container
75 void DeleteItem(void* ptr);
76
78 };
79
80 /**@class StreamHelper
81 *
82 * Helper class to facilitate I/O
83 *
84 * @author M.Frank
85 * @version 1.0
86 * @date 10/10/2004
87 */
102 void* p_void;
103 void** pp_void;
104 char* kchar;
106 void* ptr() {
107 return *(&this->p_void);
108 }
109 std::string* str() {
110 return (std::string*)this;
111 }
112 const char* c_str() {
113 return ((std::string*)this)->c_str();
114 }
115 const char* c_pstr() {
116 return (*(std::string**)this)->c_str();
117 }
118 void set(void* p) {
119 *(&this->p_void) = p;
120 }
122 TString s;
123 s.Streamer(b);
124 ((std::string*)this)->assign(s.Data());
125 }
127 *((TString*)this) = "";
128 ((TString*)this)->Streamer(b);
129 return this;
130 }
132 TString s;
133 std::string* str2 = (std::string*)ptr();
134 if (!str2) str2 = new std::string();
135 s.Streamer(b);
136 *str2 = s;
137 set(str2);
138 }
140 const char* c;
141 if (ptr()) {
142 std::string* strptr = (*(std::string**)this);
143 c = (const char*)(strptr->c_str());
144 } else c = "";
146 }
148 void* p = ptr();
149 if ( p ) {
150 if ( v->fDelete ) { // Compiled content: call Destructor
151 (*v->fDelete)(p);
152 }
153 else if ( v->fType ) { // Emulated content: call TClass::Delete
154 v->fType->Destructor(p);
155 }
156 else if ( v->fDtor ) {
157 (*v->fDtor)(p);
158 ::operator delete(p);
159 }
160 else {
161 ::operator delete(p);
162 }
163 }
164 set( b.ReadObjectAny(v->fType) );
165 }
166
168 TString* s = (TString*)ptr();
169 if ( vsn3 ) {
170 if ( !s ) s = new TString();
171 else s->Clear();
172 s->Streamer(b);
173 set(s);
174 return;
175 }
176 if ( s ) delete s;
177 set( b.ReadObjectAny(TString::Class()) );
178 }
180 b.WriteObjectAny(ptr(), TString::Class());
181 }
182 };
183
184 /** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollectionProxy.h
185 *
186 * Small helper to execute (compiler) generated function for the
187 * access to STL or other containers.
188 *
189 * @author M.Frank
190 * @version 1.0
191 * @date 10/10/2004
192 */
193 class Method {
194 public:
195 typedef void* (*Call_t)(void*);
197 Method() : call(nullptr) { }
199 Method(const Method& m) : call(m.call) { }
200 Method &operator=(const Method& m) { call = m.call; return *this; }
201 void* invoke(void* obj) const { return (*call)(obj); }
202 };
203
204 /** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollectionProxy.h
205 *
206 * Small helper to execute (compiler) generated function for the
207 * access to STL or other containers.
208 *
209 * @author M.Frank
210 * @version 1.0
211 * @date 10/10/2004
212 */
213 class Method0 {
214 public:
215 typedef void* (*Call_t)();
217 Method0() : call(nullptr) { }
219 Method0(const Method0& m) : call(m.call) { }
220 Method0 &operator=(const Method0& m) { call = m.call; return *this; }
221 void* invoke() const { return (*call)(); }
222 };
223
224 /** @class TGenCollectionProxy::TStaging
225 *
226 * Small helper to stage the content of an associative
227 * container when reading and before inserting it in the
228 * actual collection.
229 *
230 * @author Ph.Canal
231 * @version 1.0
232 * @date 20/08/2010
233 */
234 class TStaging {
235 void *fTarget; ///< Pointer to the collection we are staging for.
236 void *fContent; ///< Pointer to the content
237 size_t fReserved; ///< Amount of space already reserved.
238 size_t fSize; ///< Number of elements
239 size_t fSizeOf; ///< size of each elements
240
241 TStaging(const TStaging&); ///< Not implemented.
242 TStaging &operator=(const TStaging&); ///< Not implemented.
243
244 public:
245 TStaging(size_t size, size_t size_of) : fTarget(nullptr), fContent(nullptr), fReserved(0), fSize(size), fSizeOf(size_of)
246 {
247 // Usual constructor. Reserves the required number of elements.
250 }
251
253 // Usual destructor
255 }
256
257 void *GetContent() {
258 // Return the location of the array of content.
259 return fContent;
260 }
261 void *GetEnd() {
262 // Return the 'end' of the array of content.
263 return ((char*)fContent) + fSize*fSizeOf;
264 }
265 size_t GetSize() {
266 // Return the number of elements.
267 return fSize;
268 }
269 void *GetTarget() {
270 // Get the address of the collection we are staging for.
271 return fTarget;
272 }
273 void Resize(size_t nelement) {
274 if (fReserved < nelement) {
275 fReserved = nelement;
277 }
278 fSize = nelement;
279 }
280 void SetTarget(void *target) {
281 // Set the collection we are staging for.
282 fTarget = target;
283 }
284 };
285
286protected:
289 typedef std::vector<TStaging*> Staged_t; ///< Collection of pre-allocated staged array for associative containers.
290 typedef std::vector<EnvironBase_t*> Proxies_t;
291 mutable TObjArray *fReadMemberWise; ///< Array of bundle of TStreamerInfoActions to stream out (read)
292 mutable std::map<std::string, TObjArray*> *fConversionReadMemberWise; ///< Array of bundle of TStreamerInfoActions to stream out (read) derived from another class.
294 typedef void (*Sizing_t)(void *obj, size_t size);
295 typedef void* (*Feedfunc_t)(void *from, void *to, size_t size);
296 typedef void* (*Collectfunc_t)(void *from, void *to);
297 typedef void* (*ArrIterfunc_t)(void *from, size_t size);
298
299 std::string fName; ///< Name of the class being proxied.
300 Bool_t fPointers; ///< Flag to indicate if containee has pointers (key or value)
301 Method fClear; ///< Method cache for container accessors: clear container
302 Method fSize; ///< Container accessors: size of container
303 Sizing_t fResize; ///< Container accessors: resize container
304 Method fFirst; ///< Container accessors: generic iteration: first
305 Method fNext; ///< Container accessors: generic iteration: next
306 ArrIterfunc_t fConstruct; ///< Container accessors: block construct
307 Sizing_t fDestruct; ///< Container accessors: block destruct
308 Feedfunc_t fFeed; ///< Container accessors: block feed
309 Collectfunc_t fCollect; ///< Method to collect objects from container
310 Method0 fCreateEnv; ///< Method to allocate an Environment holder.
311 std::atomic<Value*> fValue; ///< Descriptor of the container value type
312 Value* fVal; ///< Descriptor of the Value_type
313 Value* fKey; ///< Descriptor of the key_type
314 EnvironBase_t*fEnv; ///< Address of the currently proxied object
315 int fValOffset; ///< Offset from key to value (in maps)
316 int fValDiff; ///< Offset between two consecutive value_types (memory layout).
317 Proxies_t fProxyList; ///< Stack of recursive proxies
318 Proxies_t fProxyKept; ///< Optimization: Keep proxies once they were created
319 Staged_t fStaged; ///< Optimization: Keep staged array once they were created
320 int fSTL_type; ///< STL container type
321 Info_t fTypeinfo; ///< Type information
322 TClass* fOnFileClass; ///< On file class
323
329
330 // Late initialization of collection proxy
332 // Some hack to avoid const-ness.
333 virtual TGenCollectionProxy* InitializeEx(Bool_t silent);
334 // Call to delete/destruct individual contained item.
335 virtual void DeleteItem(Bool_t force, void* ptr) const;
336 // Allow to check function pointers.
337 void CheckFunctions() const;
338
339private:
340 TGenCollectionProxy(); // not implemented on purpose.
341
342public:
343
344 // Virtual copy constructor.
345 virtual TVirtualCollectionProxy* Generate() const override;
346
347 // Copy constructor.
349
350private:
351 // Assignment operator
353
354public:
355 // Initializing constructor
356 TGenCollectionProxy(Info_t typ, size_t iter_size);
358
359 // Standard destructor.
360 virtual ~TGenCollectionProxy();
361
362 // Reset the info gathered from StreamerInfos and value's TClass.
363 Bool_t Reset() override;
364
365 // Return a pointer to the TClass representing the container.
366 TClass *GetCollectionClass() const override;
367
368 // Return the type of collection see TClassEdit::ESTLType
369 Int_t GetCollectionType() const override;
370
371 // Return the offset between two consecutive value_types (memory layout).
372 ULong_t GetIncrement() const override;
373
374 // Return the sizeof the collection object.
375 UInt_t Sizeof() const override;
376
377 // Push new proxy environment.
378 void PushProxy(void *objstart) override;
379
380 // Pop old proxy environment.
381 void PopProxy() override;
382
383 // Return true if the content is of type 'pointer to'.
384 Bool_t HasPointers() const override;
385
386 // Return a pointer to the TClass representing the content.
387 TClass *GetValueClass() const override;
388
389 // If the content is a simple numerical value, return its type (see TDataType).
390 EDataType GetType() const override;
391
392 // Return the address of the value at index 'idx'.
393 void *At(UInt_t idx) override;
394
395 // Clear the container.
396 void Clear(const char *opt = "") override;
397
398 // Resize the container.
399 virtual void Resize(UInt_t n, Bool_t force_delete);
400
401 // Return the current size of the container.
402 UInt_t Size() const override;
403
404 // Block allocation of containees.
405 void* Allocate(UInt_t n, Bool_t forceDelete) override;
406
407 // Insert data into the container where data is a C-style array of the actual type contained in the collection
408 // of the given size. For associative container (map, etc.), the data type is the pair<key,value>.
409 void Insert(const void *data, void *container, size_t size) override;
410
411 // Block commit of containees.
412 void Commit(void* env) override;
413
414 // Streamer function.
415 virtual void Streamer(TBuffer &refBuffer);
416
417 // Streamer I/O overload.
418 virtual void Streamer(TBuffer &refBuffer, void *pObject, int siz);
419
420 // TClassStreamer I/O overload.
421 virtual void operator()(TBuffer &refBuffer, void *pObject);
422
423 // Routine to read the content of the buffer into 'obj'.
424 virtual void ReadBuffer(TBuffer &b, void *obj);
425 virtual void ReadBuffer(TBuffer &b, void *obj, const TClass *onfileClass);
426
427 virtual void SetOnFileClass( TClass* cl ) { fOnFileClass = cl; }
428 virtual TClass* GetOnFileClass() const { return fOnFileClass; }
429
430 // MemberWise actions
434
435 // Set of functions to iterate easily through the collection
436
438 // typedef void (*CreateIterators_t)(void *collection, void **begin_arena, void **end_arena);
439 // begin_arena and end_arena should contain the location of a memory arena of size fgIteratorSize.
440 // If the collection iterator are of that size or less, the iterators will be constructed in place in those location (new with placement)
441 // Otherwise the iterators will be allocated via a regular new and their address returned by modifying the value of begin_arena and end_arena.
442
444 // typedef void* (*CopyIterator_t)(void **dest, const void *source);
445 // Copy the iterator source, into dest. dest should contain the location of a memory arena of size fgIteratorSize.
446 // If the collection iterator is of that size or less, the iterator will be constructed in place in this location (new with placement)
447 // Otherwise the iterator will be allocated via a regular new.
448 // The actual address of the iterator is returned in both case.
449
450 Next_t GetFunctionNext(Bool_t read = kTRUE) override;
451 // typedef void* (*Next_t)(void *iter, const void *end);
452 // iter and end should be pointers to respectively an iterator to be incremented and the result of collection.end()
453 // If the iterator has not reached the end of the collection, 'Next' increment the iterator 'iter' and return 0 if
454 // the iterator reached the end.
455 // If the end was not reached, 'Next' returns the address of the content pointed to by the iterator before the
456 // incrementation ; if the collection contains pointers, 'Next' will return the value of the pointer.
457
460 // typedef void (*DeleteIterator_t)(void *iter);
461 // typedef void (*DeleteTwoIterators_t)(void *begin, void *end);
462 // If the size of the iterator is greater than fgIteratorArenaSize, call delete on the addresses,
463 // Otherwise just call the iterator's destructor.
464
465};
466
467template <typename T>
470 : TGenCollectionProxy(typeid(T::Cont_t),sizeof(T::Iter_t))
471 {
472 // Constructor.
473 fValDiff = sizeof(T::Value_t);
474 fValOffset = T::value_offset();
476 fResize = T::resize;
477 fNext.call = T::next;
478 fFirst.call = T::first;
479 fClear.call = T::clear;
480 fConstruct = T::construct;
481 fDestruct = T::destruct;
482 fFeed = T::feed;
484 }
486};
487
488#endif
489
#define c(i)
Definition: RSha256.hxx:101
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
unsigned short UShort_t
Definition: RtypesCore.h:40
int Int_t
Definition: RtypesCore.h:45
unsigned char UChar_t
Definition: RtypesCore.h:38
char Char_t
Definition: RtypesCore.h:37
long Long_t
Definition: RtypesCore.h:54
float Float_t
Definition: RtypesCore.h:57
short Short_t
Definition: RtypesCore.h:39
long long Long64_t
Definition: RtypesCore.h:80
unsigned long long ULong64_t
Definition: RtypesCore.h:81
const Bool_t kTRUE
Definition: RtypesCore.h:100
unsigned long ULong_t
Definition: RtypesCore.h:55
EDataType
Definition: TDataType.h:28
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
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 b
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 Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
#define realloc
Definition: civetweb.c:1538
#define free
Definition: civetweb.c:1539
#define malloc
Definition: civetweb.c:1536
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
TClassRef is used to implement a permanent reference to a TClass object.
Definition: TClassRef.h:28
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
TCollectionProxyFactory Interface to collection proxy and streamer generator.
Method0 & operator=(const Method0 &m)
Small helper to execute (compiler) generated function for the access to STL or other containers.
Method & operator=(const Method &m)
void * invoke(void *obj) const
Small helper to stage the content of an associative container when reading and before inserting it in...
size_t fSizeOf
size of each elements
TStaging & operator=(const TStaging &)
Not implemented.
size_t fSize
Number of elements.
TStaging(const TStaging &)
Not implemented.
void * fContent
Pointer to the content.
size_t fReserved
Amount of space already reserved.
void * fTarget
Pointer to the collection we are staging for.
TStaging(size_t size, size_t size_of)
Proxy around an arbitrary container, which implements basic functionality and iteration.
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version) override
Return the set of action necessary to stream in this collection member-wise coming from the old value...
Method fFirst
Container accessors: generic iteration: first.
std::atomic< Value * > fValue
Descriptor of the container value type.
std::vector< EnvironBase_t * > Proxies_t
void Insert(const void *data, void *container, size_t size) override
Insert data into the container where data is a C-style array of the actual type contained in the coll...
virtual ~TGenCollectionProxy()
Standard destructor.
std::vector< TStaging * > Staged_t
Collection of pre-allocated staged array for associative containers.
Bool_t fPointers
Flag to indicate if containee has pointers (key or value)
Method fNext
Container accessors: generic iteration: next.
virtual void Streamer(TBuffer &refBuffer)
Streamer Function.
TStreamerInfoActions::TActionSequence * fWriteMemberWise
void * Allocate(UInt_t n, Bool_t forceDelete) override
Allocate the needed space.
void *(* Feedfunc_t)(void *from, void *to, size_t size)
ROOT::Detail::TCollectionProxyInfo::Environ< char[64]> Env_t
Bool_t Reset() override
Reset the info gathered from StreamerInfos and value's TClass.
Info_t fTypeinfo
Type information.
int fValOffset
Offset from key to value (in maps)
TClass * GetValueClass() const override
Return a pointer to the TClass representing the content.
EnvironBase_t * fEnv
Address of the currently proxied object.
DeleteIterator_t fFunctionDeleteIterator
Collectfunc_t fCollect
Method to collect objects from container.
void PushProxy(void *objstart) override
Add an object.
void PopProxy() override
Remove the last object.
EDataType GetType() const override
If the content is a simple numerical value, return its type (see TDataType)
TGenCollectionProxy * Initialize(Bool_t silent) const
Proxy initializer.
virtual TGenCollectionProxy * InitializeEx(Bool_t silent)
Proxy initializer.
void *(* ArrIterfunc_t)(void *from, size_t size)
TGenCollectionProxy & operator=(const TGenCollectionProxy &)
void Commit(void *env) override
Commit the change.
std::string fName
Name of the class being proxied.
CopyIterator_t GetFunctionCopyIterator(Bool_t read=kTRUE) override
See typedef void (*CopyIterator_t)(void *&dest, const void *source); Copy the iterator source,...
int fSTL_type
STL container type.
CopyIterator_t fFunctionCopyIterator
ULong_t GetIncrement() const override
Return the offset between two consecutive value_types (memory layout).
Value * fKey
Descriptor of the key_type.
virtual TClass * GetOnFileClass() const
virtual void Resize(UInt_t n, Bool_t force_delete)
Resize the container.
void(* Sizing_t)(void *obj, size_t size)
Int_t GetCollectionType() const override
Return the type of collection see TClassEdit::ESTLType.
void Clear(const char *opt="") override
Clear the emulated collection.
Proxies_t fProxyList
Stack of recursive proxies.
DeleteIterator_t GetFunctionDeleteIterator(Bool_t read=kTRUE) override
See typedef void (*DeleteIterator_t)(void *iter); If the sizeof iterator is greater than fgIteratorAr...
UInt_t Size() const override
Return the current size of the container.
Sizing_t fDestruct
Container accessors: block destruct.
Method0 fCreateEnv
Method to allocate an Environment holder.
Value * fVal
Descriptor of the Value_type.
Next_t GetFunctionNext(Bool_t read=kTRUE) override
See typedef void* (*Next_t)(void *iter, void *end); iter and end should be pointer to respectively an...
virtual void operator()(TBuffer &refBuffer, void *pObject)
TClassStreamer IO overload.
TClass * fOnFileClass
On file class.
Sizing_t fResize
Container accessors: resize container.
ArrIterfunc_t fConstruct
Container accessors: block construct.
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read=kTRUE) override
See typedef void (*DeleteTwoIterators_t)(void *begin, void *end); If the sizeof iterator is greater t...
std::map< std::string, TObjArray * > * fConversionReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read) derived from another class.
void CheckFunctions() const
Check existence of function pointers.
virtual TVirtualCollectionProxy * Generate() const override
Virtual copy constructor.
DeleteTwoIterators_t fFunctionDeleteTwoIterators
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions() override
Return the set of action necessary to stream out this collection member-wise.
virtual void SetOnFileClass(TClass *cl)
Bool_t HasPointers() const override
Return true if the content is of type 'pointer to'.
CreateIterators_t fFunctionCreateIterators
TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version) override
Return the set of action necessary to stream in this collection member-wise coming from the old value...
TObjArray * fReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read)
ROOT::Detail::TCollectionProxyInfo::EnvironBase EnvironBase_t
virtual void DeleteItem(Bool_t force, void *ptr) const
Call to delete/destruct individual item.
TClass * GetCollectionClass() const override
Return a pointer to the TClass representing the container.
Staged_t fStaged
Optimization: Keep staged array once they were created.
Method fSize
Container accessors: size of container.
Method fClear
Method cache for container accessors: clear container.
Feedfunc_t fFeed
Container accessors: block feed.
CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE) override
See typedef void (*CreateIterators_t)(void *collection, void *&begin_arena, void *&end_arena); begin_...
void *(* Collectfunc_t)(void *from, void *to)
int fValDiff
Offset between two consecutive value_types (memory layout).
virtual void ReadBuffer(TBuffer &b, void *obj)
Proxies_t fProxyKept
Optimization: Keep proxies once they were created.
UInt_t Sizeof() const override
Return the sizeof the collection object.
const std::type_info & Info_t
An array of TObjects.
Definition: TObjArray.h:31
Basic string class.
Definition: TString.h:136
virtual void Streamer(TBuffer &)
Stream a string object.
Definition: TString.cxx:1379
static TClass * Class()
void(* CreateIterators_t)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
void *(* CopyIterator_t)(void *dest, const void *source)
void *(* Next_t)(void *iter, const void *end)
void(* DeleteTwoIterators_t)(void *begin, void *end)
void(* DeleteIterator_t)(void *iter)
const Int_t n
Definition: legend1.C:16
void(off) SmallVectorTemplateBase< T
double T(double x)
Definition: ChebyshevPol.h:34
void(* DesFunc_t)(void *)
Definition: Rtypes.h:112
void(* DelFunc_t)(void *)
Definition: Rtypes.h:110
void *(* NewFunc_t)(void *)
Definition: Rtypes.h:108
static constexpr double s
Small helper to save proxy environment in the event of recursive calls.
Small helper to describe the Value_type or the key_type of an STL container.
UInt_t fCase
type of data of Value_type
TClassRef fType
TClass reference of Value_type in collection.
UInt_t fProperties
Additional properties of the value type (kNeedDelete)
size_t fSize
fSize of the contained object
ROOT::DelFunc_t fDelete
Method cache for containee delete.
ROOT::DesFunc_t fDtor
Method cache for containee destructor.
ROOT::NewFunc_t fCtor
Method cache for containee constructor.
Value(const std::string &info, Bool_t silent, size_t hint_pair_offset=0, size_t hint_pair_size=0)
Constructor.
EDataType fKind
kind of ROOT-fundamental type
Bool_t IsValid()
Return true if the Value has been properly initialized.
TMarker m
Definition: textangle.C:8
Helper class to facilitate I/O.
void read_tstring_pointer(Bool_t vsn3, TBuffer &b)
void read_any_object(Value *v, TBuffer &b)