53#define DOLOOP for(Int_t k=0; k<narr; ++k)
55#define ReadBasicTypeElem(name,index) \
57 name *x=(name*)(arr[index]+ioffset); \
61#define ReadBasicType(name) \
63 ReadBasicTypeElem(name,0); \
66#define ReadBasicTypeLoop(name) \
68 for(Int_t k=0; k<narr; ++k) ReadBasicTypeElem(name,k); \
71#define ReadBasicArrayElem(name,index) \
73 name *x=(name*)(arr[index]+ioffset); \
74 b.ReadFastArray(x,compinfo[i]->fLength); \
77#define ReadBasicArray(name) \
79 ReadBasicArrayElem(name,0); \
82#define ReadBasicArrayLoop(name) \
84 for(Int_t k=0; k<narr; ++k) ReadBasicArrayElem(name,k) \
87#define ReadBasicPointerElem(name,index) \
91 Int_t *l = (Int_t*)(arr[index]+imethod); \
92 if (*l < 0 || *l > b.BufferSize()) continue; \
93 name **f = (name**)(arr[index]+ioffset); \
95 if (isArray) for(j=0;j<compinfo[i]->fLength;j++) { \
97 f[j] = 0; if (*l <=0) continue; \
98 f[j] = new name[*l]; \
99 b.ReadFastArray(f[j],*l); \
101 else for(j=0;j<compinfo[i]->fLength;j++) { \
107#define ReadBasicPointer(name) \
109 const int imethod = compinfo[i]->fMethod+eoffset; \
110 ReadBasicPointerElem(name,0); \
113#define ReadBasicPointerLoop(name) \
115 int imethod = compinfo[i]->fMethod+eoffset; \
116 for(int k=0; k<narr; ++k) { \
117 ReadBasicPointerElem(name,k); \
121#define SkipCBasicType(name) \
124 DOLOOP{ b >> dummy; } \
128#define SkipCFloat16(name) \
131 DOLOOP { b.ReadFloat16(&dummy,aElement); } \
135#define SkipCDouble32(name) \
138 DOLOOP { b.ReadDouble32(&dummy,aElement); }\
142#define SkipCBasicArray(name,ReadArrayFunc) \
144 name* readbuf = new name[compinfo->fLength]; \
146 b.ReadArrayFunc(readbuf, compinfo->fLength); \
152#define SkipCBasicPointer(name,ReadArrayFunc) \
154 Int_t addCounter = -111; \
155 if ((imethod>0) && (compinfo->fMethod>0)) addCounter = -1; \
156 if((addCounter<-1) && (aElement!=0) && (aElement->IsA()==TStreamerBasicPointer::Class())) { \
157 TStreamerElement* elemCounter = (TStreamerElement*) thisVar->GetElements()->FindObject(((TStreamerBasicPointer*)aElement)->GetCountName()); \
158 if (elemCounter) addCounter = elemCounter->GetTObjectOffset(); \
160 if (addCounter>=-1) { \
161 int len = aElement->GetArrayDim()?aElement->GetArrayLength():1; \
165 char *arr_k = arr[k]; \
166 Int_t *l = (addCounter==-1 && arr_k) ? (Int_t*)(arr_k+imethod) : &addCounter; \
168 name* readbuf = new name[*l]; \
169 for (int j=0;j<len;j++) \
170 b.ReadArrayFunc(readbuf, *l); \
263 char* readbuf =
new char[
nch];
264 b.ReadFastArray(readbuf,
nch);
385#define ConvCBasicType(name,stream) \
390 switch(compinfo->fNewType) { \
391 case TStreamerInfo::kBool: {Bool_t *x=(Bool_t*)(arr[k]+ioffset); *x = (Bool_t)u; break;} \
392 case TStreamerInfo::kChar: {Char_t *x=(Char_t*)(arr[k]+ioffset); *x = (Char_t)u; break;} \
393 case TStreamerInfo::kShort: {Short_t *x=(Short_t*)(arr[k]+ioffset); *x = (Short_t)u; break;} \
394 case TStreamerInfo::kInt: {Int_t *x=(Int_t*)(arr[k]+ioffset); *x = (Int_t)u; break;} \
395 case TStreamerInfo::kLong: {Long_t *x=(Long_t*)(arr[k]+ioffset); *x = (Long_t)u; break;} \
396 case TStreamerInfo::kLong64: {Long64_t *x=(Long64_t*)(arr[k]+ioffset); *x = (Long64_t)u; break;} \
397 case TStreamerInfo::kFloat: {Float_t *x=(Float_t*)(arr[k]+ioffset); *x = (Float_t)u; break;} \
398 case TStreamerInfo::kFloat16: {Float_t *x=(Float_t*)(arr[k]+ioffset); *x = (Float_t)u; break;} \
399 case TStreamerInfo::kDouble: {Double_t *x=(Double_t*)(arr[k]+ioffset); *x = (Double_t)u; break;} \
400 case TStreamerInfo::kDouble32:{Double_t *x=(Double_t*)(arr[k]+ioffset); *x = (Double_t)u; break;} \
401 case TStreamerInfo::kUChar: {UChar_t *x=(UChar_t*)(arr[k]+ioffset); *x = (UChar_t)u; break;} \
402 case TStreamerInfo::kUShort: {UShort_t *x=(UShort_t*)(arr[k]+ioffset); *x = (UShort_t)u; break;} \
403 case TStreamerInfo::kUInt: {UInt_t *x=(UInt_t*)(arr[k]+ioffset); *x = (UInt_t)u; break;} \
404 case TStreamerInfo::kULong: {ULong_t *x=(ULong_t*)(arr[k]+ioffset); *x = (ULong_t)u; break;} \
405 case TStreamerInfo::kULong64: {ULong64_t*x=(ULong64_t*)(arr[k]+ioffset);*x = (ULong64_t)u;break;} \
410#define ConvCBasicArrayTo(newtype) \
412 newtype *f=(newtype*)(arr[k]+ioffset); \
413 for (j=0;j<len;j++) f[j] = (newtype)readbuf[j]; \
417#define ConvCBasicArray(name,ReadArrayFunc) \
419 int j, len = compinfo->fLength; \
420 name* readbuf = new name[len]; \
421 int newtype = compinfo->fNewType%20; \
423 b.ReadArrayFunc(readbuf, len); \
425 case TStreamerInfo::kBool: ConvCBasicArrayTo(Bool_t); \
426 case TStreamerInfo::kChar: ConvCBasicArrayTo(Char_t); \
427 case TStreamerInfo::kShort: ConvCBasicArrayTo(Short_t); \
428 case TStreamerInfo::kInt: ConvCBasicArrayTo(Int_t); \
429 case TStreamerInfo::kLong: ConvCBasicArrayTo(Long_t); \
430 case TStreamerInfo::kLong64: ConvCBasicArrayTo(Long64_t); \
431 case TStreamerInfo::kFloat: ConvCBasicArrayTo(Float_t); \
432 case TStreamerInfo::kFloat16: ConvCBasicArrayTo(Float_t); \
433 case TStreamerInfo::kDouble: ConvCBasicArrayTo(Double_t); \
434 case TStreamerInfo::kDouble32: ConvCBasicArrayTo(Double_t); \
435 case TStreamerInfo::kUChar: ConvCBasicArrayTo(UChar_t); \
436 case TStreamerInfo::kUShort: ConvCBasicArrayTo(UShort_t); \
437 case TStreamerInfo::kUInt: ConvCBasicArrayTo(UInt_t); \
438 case TStreamerInfo::kULong: ConvCBasicArrayTo(ULong_t); \
439 case TStreamerInfo::kULong64: ConvCBasicArrayTo(ULong64_t); \
446#define ConvCBasicPointerToOutOfRange(newtype,ReadArrayFunc) \
448 newtype **f=(newtype**)(arr[k]+ioffset); \
449 for (j=0;j<len;j++) { \
456#define ConvCBasicPointerTo(newtype,ReadArrayFunc) \
458 newtype **f=(newtype**)(arr[k]+ioffset); \
459 for (j=0;j<len;j++) { \
461 f[j] = new newtype[*l]; \
462 newtype *af = f[j]; \
463 b.ReadArrayFunc(readbuf, *l); \
464 for (jj=0;jj<*l;jj++) af[jj] = (newtype)readbuf[jj]; \
469#define ConvCBasicPointer(name,ReadArrayFunc) \
472 int j, jj, len = aElement->GetArrayDim()?aElement->GetArrayLength():1; \
474 int newtype = compinfo->fNewType %20; \
475 Int_t imethod = compinfo->fMethod+eoffset; \
478 Int_t *l = (Int_t*)(arr[k]+imethod); \
479 if (*l>0 && *l < b.BufferSize()) { \
480 readbuf = new name[*l]; \
482 case TStreamerInfo::kBool: ConvCBasicPointerTo(Bool_t,ReadArrayFunc); \
483 case TStreamerInfo::kChar: ConvCBasicPointerTo(Char_t,ReadArrayFunc); \
484 case TStreamerInfo::kShort: ConvCBasicPointerTo(Short_t,ReadArrayFunc); \
485 case TStreamerInfo::kInt: ConvCBasicPointerTo(Int_t,ReadArrayFunc); \
486 case TStreamerInfo::kLong: ConvCBasicPointerTo(Long_t,ReadArrayFunc); \
487 case TStreamerInfo::kLong64: ConvCBasicPointerTo(Long64_t,ReadArrayFunc); \
488 case TStreamerInfo::kFloat: ConvCBasicPointerTo(Float_t,ReadArrayFunc); \
489 case TStreamerInfo::kFloat16: ConvCBasicPointerTo(Float_t,ReadArrayFunc); \
490 case TStreamerInfo::kDouble: ConvCBasicPointerTo(Double_t,ReadArrayFunc); \
491 case TStreamerInfo::kDouble32: ConvCBasicPointerTo(Double_t,ReadArrayFunc); \
492 case TStreamerInfo::kUChar: ConvCBasicPointerTo(UChar_t,ReadArrayFunc); \
493 case TStreamerInfo::kUShort: ConvCBasicPointerTo(UShort_t,ReadArrayFunc); \
494 case TStreamerInfo::kUInt: ConvCBasicPointerTo(UInt_t,ReadArrayFunc); \
495 case TStreamerInfo::kULong: ConvCBasicPointerTo(ULong_t,ReadArrayFunc); \
496 case TStreamerInfo::kULong64: ConvCBasicPointerTo(ULong64_t,ReadArrayFunc); \
501 case TStreamerInfo::kBool: ConvCBasicPointerToOutOfRange(Bool_t,ReadArrayFunc); \
502 case TStreamerInfo::kChar: ConvCBasicPointerToOutOfRange(Char_t,ReadArrayFunc); \
503 case TStreamerInfo::kShort: ConvCBasicPointerToOutOfRange(Short_t,ReadArrayFunc); \
504 case TStreamerInfo::kInt: ConvCBasicPointerToOutOfRange(Int_t,ReadArrayFunc); \
505 case TStreamerInfo::kLong: ConvCBasicPointerToOutOfRange(Long_t,ReadArrayFunc); \
506 case TStreamerInfo::kLong64: ConvCBasicPointerToOutOfRange(Long64_t,ReadArrayFunc); \
507 case TStreamerInfo::kFloat: ConvCBasicPointerToOutOfRange(Float_t,ReadArrayFunc); \
508 case TStreamerInfo::kFloat16: ConvCBasicPointerToOutOfRange(Float_t,ReadArrayFunc); \
509 case TStreamerInfo::kDouble: ConvCBasicPointerToOutOfRange(Double_t,ReadArrayFunc); \
510 case TStreamerInfo::kDouble32: ConvCBasicPointerToOutOfRange(Double_t,ReadArrayFunc); \
511 case TStreamerInfo::kUChar: ConvCBasicPointerToOutOfRange(UChar_t,ReadArrayFunc); \
512 case TStreamerInfo::kUShort: ConvCBasicPointerToOutOfRange(UShort_t,ReadArrayFunc); \
513 case TStreamerInfo::kUInt: ConvCBasicPointerToOutOfRange(UInt_t,ReadArrayFunc); \
514 case TStreamerInfo::kULong: ConvCBasicPointerToOutOfRange(ULong_t,ReadArrayFunc); \
515 case TStreamerInfo::kULong64: ConvCBasicPointerToOutOfRange(ULong64_t,ReadArrayFunc); \
595#if defined(_MSC_VER) && (_MSC_VER <= 1200)
603#if defined(_MSC_VER) && (_MSC_VER <= 1200)
616 pidf +=
b.GetPidOffset();
672#if defined(_MSC_VER) && (_MSC_VER <= 1200)
680#if defined(_MSC_VER) && (_MSC_VER <= 1200)
707#if defined(_MSC_VER) && (_MSC_VER <= 1200)
715#if defined(_MSC_VER) && (_MSC_VER <= 1200)
775 for (
Int_t i=first;i<last;i++) {
786 Warning(
"ReadBuffer",
"Skipping %s::%s because the cache is missing.",
thisVar->GetName(),
aElement->GetName());
790 printf(
"ReadBuffer, class:%s, name=%s, fType[%d]=%d,"
791 " %s, bufpos=%d, arr=%p, eoffset=%d, Redirect=%p\n",
803 printf(
"ReadBuffer, class:%s, name=%s, fType[%d]=%d,"
804 " %s, bufpos=%d, arr=%p, offset=%d\n",
938 f[
j] = 0;
if (*
l <=0)
continue;
953 f[
j] = 0;
if (*
l <=0)
continue;
983 f[
j] = 0;
if (*
l <=0)
continue;
1000 f[
j] = 0;
if (*
l <=0)
continue;
1030 pidf +=
b.GetPidOffset();
1150 Error(
"ReadBuffer",
"Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1151 vers,
b.GetParent() ?
b.GetParent()->GetName() :
"memory/socket",
oldClass->GetName(),
newClass->GetName() );
1157 vClVersion =
b.ReadVersionForMemberWise(
cle->GetCollectionProxy()->GetValueClass() );
1191 b.CheckByteCount(start,count,
aElement->GetFullName());
1214 b.CheckByteCount(start,count,
aElement->GetFullName());
1232 Error(
"ReadBuffer",
"Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1233 vers,
b.GetParent() ?
b.GetParent()->GetName() :
"memory/socket",
oldClass->GetName(),
newClass->GetName() );
1249 b.SetBufferOffset(start+count+
sizeof(
UInt_t));
1279 b.CheckByteCount(start,count,
aElement->GetTypeName());
1286 b.SetBufferOffset(start);
1287 }
else if (
vers==0) {
1288 b.SetBufferOffset(start);
1302 b.CheckByteCount(start,count,
aElement->GetTypeName());
1368 b.SetBufferOffset(start);
1375 b.CheckByteCount(start,count,
aElement->GetFullName());
1387 b.SetBufferOffset(start);
1390 b.SetBufferOffset(start);
1395 Error(
"ReadBuffer",
"Streamer for %s is null\n",
aElement->GetName());
1402 b.CheckByteCount(start,count,
aElement->GetFullName());
1427 b.ReadVersion(&start, &count, cl);
1434 b.CheckByteCount(start, count,
aElement->GetFullName());
1449 b.ReadVersion(&start, &count, cl);
1510 Error(
"ReadBuffer",
"Memory allocation failed!\n");
1517 pp[
ndx] = (
char*)
new char*[
vlen];
1519 Error(
"ReadBuffer",
"Memory allocation failed!\n");
1527 b.ReadFastArray(pp[
ndx], cl,
vlen, 0);
1596 Error(
"ReadBuffer",
"Memory allocation failed!\n");
1603 pp[
ndx] = (
char*)
new char*[
vlen];
1605 Error(
"ReadBuffer",
"Memory allocation failed!\n");
1622 char**
r = (
char**) pp[
ndx];
1626 r[
v] = (
char*) cl->
New();
1639 b.CheckByteCount(start, count,
aElement->GetFullName());
1669 if (
ans==0)
continue;
1673 if (
ans==0)
continue;
1678 if (
ans==0)
continue;
1681 Error(
"ReadBuffer",
"The element %s::%s type %d (%s) is not supported yet\n",
1684 Error(
"ReadBuffer",
"The TStreamerElement for %s %d is missing!\n",
1714template Int_t TStreamerInfo::ReadBufferArtificial<char**>(
TBuffer &
b,
char**
const &
arr,
1724template Int_t TStreamerInfo::ReadBuffer<char**>(
TBuffer &
b,
char**
const &
arr,
1740 if (!nc &&
v7)
return 0;
1752 char **
arr = (
char **)
clones->GetObjectRef(0);
unsigned long long ULong64_t
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
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 r
#define ReadBasicArray(name)
#define ConvCBasicPointer(name, ReadArrayFunc)
#define SkipCBasicPointer(name, ReadArrayFunc)
#define ReadBasicType(name)
#define ReadBasicPointerLoop(name)
static TStreamerElement *& CurrentElement()
#define ReadBasicArrayLoop(name)
#define SkipCFloat16(name)
#define ReadBasicTypeLoop(name)
#define SkipCBasicArray(name, ReadArrayFunc)
#define ConvCBasicArray(name, ReadArrayFunc)
#define SkipCDouble32(name)
#define ConvCBasicType(name, stream)
#define ReadBasicPointer(name)
#define SkipCBasicType(name)
void(* ReadFuncPtr_t)(char *, TVirtualObject *)
void(* ReadRawFuncPtr_t)(char *, TBuffer &)
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.
Buffer base class used for serializing objects.
TClass instances represent classes, structs and namespaces in the ROOT type system.
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=nullptr) const
void * NewArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Int_t Size() const
Return size of object of this class.
void DeleteArray(void *ary, Bool_t dtorOnly=kFALSE)
Explicitly call operator delete[] for an array.
An array of clone (identical) objects.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
The TNamed class is the base class for all named ROOT classes.
const char * GetName() const override
Returns name of object.
void Streamer(TBuffer &) override
Stream an object of class TObject.
Mother of all ROOT objects.
virtual UInt_t GetUniqueID() const
Return the unique object id.
@ kIsOnHeap
object is on heap
@ kNotDeleted
object has not been deleted
virtual void Streamer(TBuffer &)
Stream an object of class TObject.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
@ kIsReferenced
if object is referenced by a TRef or TRefArray
A TProcessID identifies a ROOT job in a unique way in time and space.
void PutObjectWithID(TObject *obj, UInt_t uid=0)
stores the object at the uid th slot in the table of objects The object uniqued is set as well as its...
Persistent Reference link to a TObject A TRef is a lightweight object pointing to any TObject.
Describes a persistent version of a class.
Int_t ReadBufferSTL(TBuffer &b, TVirtualCollectionProxy *cont, Int_t nc, Int_t eoffset, Bool_t v7=kTRUE)
The STL vector/list is deserialized from the buffer b.
Int_t fNfulldata
!number of elements
TCompInfo ** fCompFull
![fElements->GetEntries()]
Int_t ReadBuffer(TBuffer &b, const T &arrptr, TCompInfo *const *const compinfo, Int_t first, Int_t last, Int_t narr=1, Int_t eoffset=0, Int_t mode=0)
Deserialize information from buffer b into object at pointer if (arrayMode & 1) ptr is a pointer to a...
@ kArtificial
Cache the value in memory than is not part of the object but is accessible via a SchemaRule.
@ kUChar
Equal to TDataType's kchar.
Int_t ReadBufferConv(TBuffer &b, const T &arrptr, const TCompInfo *compinfo, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset)
Convert elements of a TClonesArray.
Int_t ReadBufferClones(TBuffer &b, TClonesArray *clones, Int_t nc, Int_t first, Int_t eoffset)
Read for TClonesArray.
TClass * fClass
!pointer to class
void Streamer(TBuffer &) override
Stream an object of class TStreamerInfo.
static TStreamerElement * GetCurrentElement()
static function returning a pointer to the current TStreamerElement fgElement points to the current T...
Int_t ReadBufferArtificial(TBuffer &b, const T &arrptr, TStreamerElement *aElement, Int_t narr, Int_t eoffset)
Handle Artificial StreamerElement.
Int_t ReadBufferSkip(TBuffer &b, const T &arrptr, const TCompInfo *compinfo, Int_t kase, TStreamerElement *aElement, Int_t narr, Int_t eoffset)
Skip an element.
Version_t fOldVersion
! Version of the TStreamerInfo object read from the file
virtual void Streamer(TBuffer &)
Stream a string object.
Wrapper around an object and giving indirect access to its content even if the object is not of a cla...
RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++...
Defines a common interface to inspect/change the contents of an object that represents a collection.
Wrapper around an object and giving indirect access to its content even if the object is not of a cla...