40# define INLINE_TEMPLATE_ARGS
42# define INLINE_TEMPLATE_ARGS inline
55 return isEmulated || (isVector && hasDefaultAlloc);
58 template <
typename From>
59 struct WithFactorMarker {
63 template <
typename From>
64 struct NoFactorMarker {
106 printf(
"StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
107 " %s, offset=%d (%s), elemnId=%d \n",
123 printf(
"StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
124 " %s, bufpos=%d, arr=%p, offset=%d (%s)\n",
134 printf(
"TLoopConfiguration: unconfigured\n");
143 void PrintDebug(
TBuffer &,
void *)
const {
159 void PrintDebug(
TBuffer &,
void *)
const {
165 printf(
"StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
166 " %s, offset=%d (%s)\n",
171 void AddToOffset(
Int_t delta)
193 char *obj = (
char*)addr;
194 TGenericConfiguration *conf = (TGenericConfiguration*)config;
200 char *obj = (
char*)addr;
201 TGenericConfiguration *conf = (TGenericConfiguration*)config;
202 return ((
TStreamerInfo*)conf->fInfo)->WriteBufferAux(buf, &obj, &(conf->fCompInfo), 0, 1, 1, config->
fOffset, 2);
205 template <
typename T>
208 T *
x = (
T*)( ((
char*)addr) + config->
fOffset );
215 TBitsConfiguration *conf = (TBitsConfiguration*)config;
227 uid = ( obj->
GetUniqueID() & 0xffffff) + (gpid<<24);
248 template <
typename T>
251 T *
x = (
T *)(((
char *)addr) + config->
fOffset);
259 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
267 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
275 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
283 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
293 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
300 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
307 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
315 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
328 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
335 void *
x = (
void *)(((
char *)addr) + config->
fOffset);
342 template<
bool kIsTextT>
367 char **contp = (
char **)((
char *)addr + ioffset);
369 char *cont = contp[j];
371 Int_t nobjects = cont ? proxy->
Size() : 0;
385 }
else if (pstreamer ==
nullptr) {
387 char **contp = (
char **)((
char *)addr + ioffset);
389 char *cont = contp[j];
405 template<
bool kIsTextT>
428 if( vers < 9 && newClass && newClass!=oldClass ) {
429 Error(
"ReadBuffer",
"Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
453 void **contp = (
void**)((
char *) addr + ioffset);
455 void *cont = contp[j];
457 contp[j] = cle->
New();
463 env = newProxy->
Allocate(nobjects,
true);
476 }
else if (pstreamer ==
nullptr) {
478 void **contp = (
void **)((
char *)addr + ioffset);
480 void *cont = contp[j];
481 if (cont ==
nullptr) {
486 contp[j] = cle->
New();
502 template<
bool kIsTextT>
519 (*pstreamer)(buf, (
char *) addr + ioffset , *counter);
521 buf.SetByteCount(pos,
kTRUE);
539 fileVersion =
file->GetVersion();
544 if (fileVersion > 51508) {
554 char** pp = (
char**) ((
char *) addr + ioffset );
593 char** pp = (
char**) ((
char *) addr + ioffset );
617 char**
r = (
char**) pp[ndx];
635 template<
bool kIsTextT>
658 (*pstreamer)(buf, (
char *) addr + ioffset , *counter);
676 fileVersion =
file->GetVersion();
683 if (fileVersion > 51508) {
688 Int_t vlen = *((
Int_t *)((
char *)addr + eoffset +
696 char **pp = (
char **)((
char *)addr + ioffset );
749 pp[ndx] = (
char *)cl->
NewArray(vlen);
751 Error(
"ReadBuffer",
"Memory allocation failed!\n");
758 pp[ndx] = (
char *)
new char *[vlen];
760 Error(
"ReadBuffer",
"Memory allocation failed!\n");
764 memset(pp[ndx], 0, vlen *
sizeof(
char *));
781 Int_t vlen = *((
Int_t *)((
char *)addr + eoffset +
789 char **pp = (
char **)((
char *)addr + ioffset );
839 pp[ndx] = (
char *)cl->
NewArray(vlen);
841 Error(
"ReadBuffer",
"Memory allocation failed!\n");
848 pp[ndx] = (
char *)
new char *[vlen];
850 Error(
"ReadBuffer",
"Memory allocation failed!\n");
854 memset(pp[ndx], 0, vlen *
sizeof(
char *));
867 char **
r = (
char **)pp[ndx];
871 r[
v] = (
char *)cl->
New();
893 TConfWithFactor(
TVirtualStreamerInfo *info,
UInt_t id, TCompInfo_t *compinfo,
Int_t offset,
Double_t factor,
Double_t xmin) :
TConfiguration(info,
id,compinfo,offset),fFactor(factor),fXmin(
xmin) {};
897 template <
typename T>
903 TConfWithFactor *conf = (TConfWithFactor *)config;
916 template <
typename T>
921 TConfNoFactor *conf = (TConfNoFactor *)config;
922 Int_t nbits = conf->fNbits;
934 ((
TString*)(((
char*)addr)+config->
fOffset))->TString::Streamer(buf);
944 ((
TObject*)(((
char*)addr)+config->
fOffset))->TObject::Streamer(buf);
977 const char *fTypeName;
986 TConfiguration(info,
id,compinfo,offset,length), fOldClass(oldClass), fNewClass(oldClass), fStreamer(0), fTypeName(type_name), fIsSTLBase(isbase),
987 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) {
Init(); }
990 TConfiguration(info,
id,compinfo,offset,length), fOldClass(oldClass), fNewClass(newClass), fStreamer(0), fTypeName(type_name), fIsSTLBase(isbase),
991 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) {
Init(); }
994 TConfiguration(info,
id,compinfo,offset,length), fOldClass(oldClass), fNewClass(oldClass), fStreamer(streamer), fTypeName(type_name), fIsSTLBase(isbase),
995 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) {
Init(); }
998 TConfiguration(info,
id,compinfo,offset,length), fOldClass(oldClass), fNewClass(newClass), fStreamer(streamer), fTypeName(type_name), fIsSTLBase(isbase),
999 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) {
Init(); }
1004 class TConfSTLWithFactor :
public TConfigSTL {
1009 TConfSTLWithFactor(TConfigSTL *orig,
Double_t factor,
Double_t xmin) : TConfigSTL(*orig),fFactor(factor),fXmin(
xmin) {};
1013 class TConfSTLNoFactor :
public TConfigSTL {
1017 TConfSTLNoFactor(TConfigSTL *orig,
Int_t nbits) : TConfigSTL(*orig),fNbits(nbits) {};
1029 virtual ~TVectorLoopConfig() {};
1032 printf(
"TVectorLoopConfig: increment=%ld\n",fIncrement);
1035 void* GetFirstAddress(
void *start,
const void * )
const
1050 virtual ~TAssocLoopConfig() {};
1057 void* GetFirstAddress(
void *start,
const void * )
const
1097 virtual ~TGenericLoopConfig() {};
1104 void* GetFirstAddress(
void *start_collection,
const void *end_collection)
const
1109 void *iter = fCopyIterator(&iterator,start_collection);
1110 void *arr0 = fNext(iter,end_collection);
1111 if (iter != &iterator[0]) {
1112 fDeleteIterator(iter);
1122 TConfigSTL *config = (TConfigSTL*)conf;
1127 TClass *oldClass = config->fOldClass;
1140 void* alternative = oldProxy->
Allocate(nobjects,
true);
1146 void *begin = &(startbuf[0]);
1147 void *end = &(endbuf[0]);
1148 config->fCreateIterators(alternative, &begin, &end, oldProxy);
1152 if (begin != &(startbuf[0])) {
1154 config->fDeleteTwoIterators(begin,end);
1157 oldProxy->
Commit(alternative);
1161 TClass *oldClass = config->fOldClass;
1172 void* env = oldProxy->
Allocate(nobjects,
true);
1174 if (nobjects || vers < 7 ) {
1188 TConfigSTL *config = (TConfigSTL*)conf;
1193 TClass *oldClass = config->fOldClass;
1205 int objectSize = oldClass->
Size();
1206 char *obj = (
char*)addr;
1207 char *endobj = obj + conf->
fLength*objectSize;
1209 for(; obj<endobj; obj+=objectSize) {
1213 void* alternative = oldProxy->
Allocate(nobjects,
true);
1217 void *begin = &(startbuf[0]);
1218 void *end = &(endbuf[0]);
1219 config->fCreateIterators(alternative, &begin, &end, oldProxy);
1223 if (begin != &(startbuf[0])) {
1225 config->fDeleteTwoIterators(begin,end);
1228 oldProxy->
Commit(alternative);
1233 TClass *oldClass = config->fOldClass;
1241 int objectSize = oldClass->
Size();
1242 char *obj = (
char*)addr;
1243 char *endobj = obj + conf->
fLength*objectSize;
1245 for(; obj<endobj; obj+=objectSize) {
1249 void* env = oldProxy->
Allocate(nobjects,
true);
1251 if (nobjects || vers < 7 ) {
1266 TConfigSTL *config = (TConfigSTL*)conf;
1270 TClass *newClass = config->fNewClass;
1271 TClass *oldClass = config->fOldClass;
1274 Error(
"ReadSTLMemberWiseChangedClass",
"Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1286 void* alternative = newProxy->
Allocate(nobjects,
true);
1291 void *begin = &(startbuf[0]);
1292 void *end = &(endbuf[0]);
1293 config->fCreateIterators( alternative, &begin, &end, newProxy);
1297 if (begin != &(startbuf[0])) {
1299 config->fDeleteTwoIterators(begin,end);
1302 newProxy->
Commit(alternative);
1310 TConfigSTL *config = (TConfigSTL*)conf;
1314 TClass *newClass = config->fNewClass;
1315 TClass *oldClass = config->fOldClass;
1318 Error(
"ReadSTLMemberWiseChangedClass",
"Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1327 int objectSize = newClass->
Size();
1328 char *obj = (
char*)addr;
1329 char *endobj = obj + conf->
fLength*objectSize;
1331 for(; obj<endobj; obj+=objectSize) {
1335 void* alternative = newProxy->
Allocate(nobjects,
true);
1340 void *begin = &(startbuf[0]);
1341 void *end = &(endbuf[0]);
1342 config->fCreateIterators( alternative, &begin, &end, newProxy);
1346 if (begin != &(startbuf[0])) {
1348 config->fDeleteTwoIterators(begin,end);
1351 newProxy->
Commit(alternative);
1359 TConfigSTL *config = (TConfigSTL*)conf;
1365 TConfigSTL *config = (TConfigSTL*)conf;
1366 (*config->fStreamer)(buf,addr,conf->
fLength);
1372 TConfigSTL *config = (TConfigSTL*)conf;
1375 if (config->fIsSTLBase || vers == 0) {
1385 TConfigSTL *config = (TConfigSTL*)conf;
1388 if (config->fIsSTLBase || vers == 0) {
1391 (*config->fStreamer)(buf,addr,conf->
fLength);
1398 TConfigSTL *config = (TConfigSTL*)conf;
1402 memberwise(buf,((
char*)addr)+config->fOffset,config, vers);
1404 objectwise(buf,((
char*)addr)+config->fOffset,config, vers, start);
1410 template <
typename From,
typename To>
1411 struct ConvertBasicType {
1417 *(To*)( ((
char*)addr) + config->
fOffset ) = (To)temp;
1422 template <
typename To>
1423 struct ConvertBasicType<BitsMarker,To> {
1434 *(To*)( ((
char*)addr) + config->
fOffset ) = (To)temp;
1439 template <
typename From,
typename To>
1440 struct ConvertBasicType<WithFactorMarker<From>,To> {
1444 TConfWithFactor *conf = (TConfWithFactor *)config;
1447 *(To*)( ((
char*)addr) + config->
fOffset ) = (To)temp;
1452 template <
typename From,
typename To>
1453 struct ConvertBasicType<NoFactorMarker<From>,To> {
1457 TConfNoFactor *conf = (TConfNoFactor *)config;
1460 *(To*)( ((
char*)addr) + config->
fOffset ) = (To)temp;
1471 TConfiguration(info, -1, nullptr, offset), fOnfileObject(onfileObject)
1474 virtual void Print()
const {
1477 printf(
"StreamerInfoAction, class:%s, PushDataCache offset=%d\n",
1480 printf(
"StreamerInfoAction, class:%s, PopDataCache offset=%d\n",
1483 virtual void PrintDebug(
TBuffer &buffer,
void *
object)
const {
1486 printf(
"StreamerInfoAction, class:%s, %sDataCache, bufpos=%d, arr=%p, offset=%d, onfileObject=%p\n",
1487 info->
GetClass()->
GetName(), fOnfileObject ?
"Push" :
"Pop", buffer.
Length(),
object, fOffset, fOnfileObject);
1495 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1496 auto onfileObject = config->fOnfileObject;
1499 b.PushDataCache( onfileObject );
1506 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1507 auto onfileObject = config->fOnfileObject;
1510 b.PushDataCache( onfileObject );
1517 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1518 auto onfileObject = config->fOnfileObject;
1523 onfileObject->SetSize(
n);
1524 b.PushDataCache( onfileObject );
1554 TConfiguration(info,action.fConfiguration->fElemId,action.fConfiguration->fCompInfo,action.fConfiguration->fOffset),fAction(action),fNeedRepeat(repeat) {};
1555 virtual void PrintDebug(
TBuffer &
b,
void *addr)
const
1561 fprintf(stdout,
"StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
1562 " %s, bufpos=%d, arr=%p, eoffset=%d, Redirect=%p\n",
1564 aElement->
ClassName(),
b.Length(),addr, 0,
b.PeekDataCache() ?
b.PeekDataCache()->GetObjectAt(0) : 0);
1568 virtual ~TConfigurationUseCache() {};
1570 TConfigurationUseCache *copy =
new TConfigurationUseCache(*
this);
1578 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1580 Int_t bufpos =
b.Length();
1585 Warning(
"ReadBuffer",
"Skipping %s::%s because the cache is missing.",info->
GetName(),aElement->
GetName());
1586 char *ptr = (
char*)addr;
1589 config->fAction(
b, (*cached)[0]);
1592 if (config->fNeedRepeat) {
1593 b.SetBufferOffset(bufpos);
1600 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1601 Int_t bufpos =
b.Length();
1607 Warning(
"ReadBuffer",
"Skipping %s::%s because the cache is missing.",info->
GetName(),aElement->
GetName());
1608 char *ptr = (
char*)start;
1609 UInt_t n = (((
void**)end)-((
void**)start));
1612 TVectorLoopConfig cached_config(
nullptr, cached->
fClass->
Size(),
kTRUE );
1613 void *cached_start = (*cached)[0];
1614 void *cached_end = ((
char*)cached_start) + cached->
fSize * cached_config.fIncrement;
1615 config->fAction(
b,cached_start,cached_end,&cached_config);
1618 if (config->fNeedRepeat) {
1619 b.SetBufferOffset(bufpos);
1626 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1628 Int_t bufpos =
b.Length();
1633 Warning(
"ReadBuffer",
"Skipping %s::%s because the cache is missing.",info->
GetName(),aElement->
GetName());
1634 char *ptr = (
char*)start;
1635 UInt_t n = (((
char*)end)-((
char*)start))/((TVectorLoopConfig*)loopconf)->fIncrement;
1638 TVectorLoopConfig cached_config(
nullptr, cached->
fClass->
Size(),
kTRUE );
1639 void *cached_start = (*cached)[0];
1640 void *cached_end = ((
char*)cached_start) + cached->
fSize * cached_config.fIncrement;
1641 config->fAction(
b,cached_start,cached_end,&cached_config);
1644 if (config->fNeedRepeat) {
1645 b.SetBufferOffset(bufpos);
1652 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1654 Int_t bufpos =
b.Length();
1661 Warning(
"ReadBuffer",
"Skipping %s::%s because the cache is missing.",info->
GetName(),aElement->
GetName());
1665 TVectorLoopConfig cached_config(
nullptr, cached->
fClass->
Size(),
kTRUE );
1666 void *cached_start = (*cached)[0];
1667 void *cached_end = ((
char*)cached_start) + cached->
fSize * cached_config.fIncrement;
1668 config->fAction(
b,cached_start,cached_end,&cached_config);
1671 if (config->fNeedRepeat) {
1672 b.SetBufferOffset(bufpos);
1713 struct VectorLooper {
1715 template <
typename T>
1718 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1719 iter = (
char*)iter + config->
fOffset;
1720 end = (
char*)end + config->
fOffset;
1721 for(; iter != end; iter = (
char*)iter + incr ) {
1722 T *
x = (
T*) ((
char*) iter);
1728 template <
typename From,
typename To>
1729 struct ConvertBasicType {
1734 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1735 iter = (
char*)iter + config->
fOffset;
1736 end = (
char*)end + config->
fOffset;
1737 for(; iter != end; iter = (
char*)iter + incr ) {
1739 *(To*)( ((
char*)iter) ) = (To)temp;
1745 template <
typename To>
1746 struct ConvertBasicType<BitsMarker,To> {
1751 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1752 iter = (
char*)iter + config->
fOffset;
1753 end = (
char*)end + config->
fOffset;
1754 for(; iter != end; iter = (
char*)iter + incr ) {
1761 *(To*)( ((
char*)iter) ) = (To)temp;
1767 template <
typename From,
typename To>
1768 struct ConvertBasicType<WithFactorMarker<From>,To> {
1772 TConfWithFactor *conf = (TConfWithFactor *)config;
1774 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1775 iter = (
char*)iter + config->
fOffset;
1776 end = (
char*)end + config->
fOffset;
1777 for(; iter != end; iter = (
char*)iter + incr ) {
1779 *(To*)( ((
char*)iter) ) = (To)temp;
1785 template <
typename From,
typename To>
1786 struct ConvertBasicType<NoFactorMarker<From>,To> {
1790 TConfNoFactor *conf = (TConfNoFactor *)config;
1792 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1793 iter = (
char*)iter + config->
fOffset;
1794 end = (
char*)end + config->
fOffset;
1795 for(; iter != end; iter = (
char*)iter + incr ) {
1797 *(To*)( ((
char*)iter) ) = (To)temp;
1803 template <
typename T>
1806 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1807 iter = (
char*)iter + config->
fOffset;
1808 end = (
char*)end + config->
fOffset;
1809 for(; iter != end; iter = (
char*)iter + incr ) {
1810 T *
x = (
T*) ((
char*) iter);
1816 template <Int_t (*iter_action)(TBuffer&,
void *,const TConfiguration*)>
1819 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1822 for(
void *iter = start; iter != end; iter = (
char*)iter + incr ) {
1823 iter_action(buf, iter, config);
1833 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1834 UInt_t n = (((
char*)end)-((
char*)start))/incr;
1835 char **arrptr =
new char*[
n];
1837 for(
void *iter = start; iter != end; iter = (
char*)iter + incr, ++i ) {
1838 arrptr[i] = (
char*)iter;
1870 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1871 UInt_t n = (((
char*)end)-((
char*)start))/incr;
1872 char **arrptr =
new char*[
n];
1874 for(
void *iter = start; iter != end; iter = (
char*)iter + incr, ++i ) {
1875 arrptr[i] = (
char*)iter;
1886 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1887 UInt_t n = (((
char*)end)-((
char*)start))/incr;
1888 char **arrptr =
new char*[
n];
1890 for(
void *iter = start; iter != end; iter = (
char*)iter + incr, ++i ) {
1891 arrptr[i] = (
char*)iter;
1898 template <
typename T>
1903 TConfigSTL *config = (TConfigSTL*)conf;
1905 buf.
ReadVersion(&start, &count, config->fOldClass);
1907 std::vector<T> *
const vec = (std::vector<T>*)(((
char*)addr)+config->fOffset);
1910 vec->resize(nvalues);
1912#ifdef R__VISUAL_CPLUSPLUS
1918 T *begin = &(*vec->begin());
1929 TConfigSTL *config = (TConfigSTL*)conf;
1931 buf.
ReadVersion(&start, &count, config->fOldClass);
1933 std::vector<bool> *
const vec = (std::vector<bool>*)(((
char*)addr)+config->fOffset);
1936 vec->resize(nvalues);
1938 bool *items =
new bool[nvalues];
1940 for(
Int_t i = 0 ; i < nvalues; ++i) {
1941 (*vec)[i] = items[i];
1960 TConfigSTL *config = (TConfigSTL*)conf;
1962 buf.
ReadVersion(&start, &count, config->fOldClass);
1964 std::vector<float> *
const vec = (std::vector<float>*)(((
char*)addr)+config->fOffset);
1967 vec->resize(nvalues);
1969#ifdef R__VISUAL_CPLUSPLUS
1975 float *begin = &(*vec->begin());
1986 TConfigSTL *config = (TConfigSTL*)conf;
1988 buf.
ReadVersion(&start, &count, config->fOldClass);
1990 std::vector<double> *
const vec = (std::vector<double>*)(((
char*)addr)+config->fOffset);
1993 vec->resize(nvalues);
1995#ifdef R__VISUAL_CPLUSPLUS
2001 double *begin = &(*vec->begin());
2008 template <
typename From,
typename To>
2009 struct ConvertCollectionBasicType {
2014 TConfigSTL *config = (TConfigSTL*)conf;
2016 buf.
ReadVersion(&start, &count, config->fOldClass);
2018 std::vector<To> *
const vec = (std::vector<To>*)(((
char*)addr)+config->fOffset);
2021 vec->resize(nvalues);
2023 From *temp =
new From[nvalues];
2025 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2026 (*vec)[ind] = (To)temp[ind];
2035 template <
typename From,
typename To>
2036 struct ConvertCollectionBasicType<NoFactorMarker<From>,To> {
2041 TConfigSTL *config = (TConfigSTL*)conf;
2043 buf.
ReadVersion(&start, &count, config->fOldClass);
2045 std::vector<To> *
const vec = (std::vector<To>*)(((
char*)addr)+config->fOffset);
2048 vec->resize(nvalues);
2050 From *temp =
new From[nvalues];
2052 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2053 (*vec)[ind] = (To)temp[ind];
2062 template <
typename To>
2067 TConfigSTL *config = (TConfigSTL*)conf;
2069 buf.
ReadVersion(&start, &count, config->fOldClass);
2071 std::vector<To> *
const vec = (std::vector<To>*)(((
char*)addr)+config->fOffset);
2074 vec->resize(nvalues);
2078 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2079 (*vec)[ind] = (To)temp[ind];
2089 struct VectorPtrLooper {
2091 template <
typename T>
2096 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2097 T *
x = (
T*)( ((
char*) (*(
void**)iter) ) + offset );
2103 template <
typename From,
typename To>
2104 struct ConvertBasicType {
2110 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2112 To *
x = (To*)( ((
char*) (*(
void**)iter) ) + offset );
2119 template <
typename To>
2120 struct ConvertBasicType<BitsMarker,To> {
2126 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2133 To *
x = (To*)( ((
char*) (*(
void**)iter) ) + offset );
2140 template <
typename From,
typename To>
2141 struct ConvertBasicType<WithFactorMarker<From>,To> {
2145 TConfWithFactor *conf = (TConfWithFactor *)config;
2148 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2150 To *
x = (To*)( ((
char*) (*(
void**)iter) ) + offset );
2157 template <
typename From,
typename To>
2158 struct ConvertBasicType<NoFactorMarker<From>,To> {
2162 TConfNoFactor *conf = (TConfNoFactor *)config;
2165 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2167 To *
x = (To*)( ((
char*) (*(
void**)iter) ) + offset );
2174 template <
typename T>
2179 for(; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2180 T *
x = (
T*)( ((
char*) (*(
void**)iter) ) + offset );
2186 template <Int_t (*action)(TBuffer&,
void *,const TConfiguration*)>
2189 for(
void *iter = start; iter != end; iter = (
char*)iter +
sizeof(
void*) ) {
2190 action(buf, *(
void**)iter, config);
2200 return GenericRead(buf,start,end,config);
2205 Int_t n = ( ((
void**)end) - ((
void**)iter) );
2206 char **arr = (
char**)iter;
2212 Int_t n = ( ((
void**)end) - ((
void**)iter) );
2213 char **arr = (
char**)iter;
2219 struct AssociativeLooper {
2221 template <
typename T>
2237 template <
typename T,
void (*action)(TBuffer&,
void *,Int_t)>
2242 TConfigSTL *config = (TConfigSTL*)conf;
2244 buf.
ReadVersion(&start, &count, config->fOldClass);
2246 TClass *newClass = config->fNewClass;
2252 void* alternative = newProxy->
Allocate(nvalues,
true);
2256 void *begin = &(startbuf[0]);
2257 void *end = &(endbuf[0]);
2258 config->fCreateIterators(alternative, &begin, &end, newProxy);
2262 action(buf,begin,nvalues);
2264 if (begin != &(startbuf[0])) {
2266 config->fDeleteTwoIterators(begin,end);
2269 newProxy->
Commit(alternative);
2277 return ReadNumericalCollection<bool,SimpleRead<bool> >(buf,addr,conf);
2282 return ReadNumericalCollection<Float_t,SimpleReadFloat16 >(buf,addr,conf);
2287 return ReadNumericalCollection<Double_t,SimpleReadDouble32 >(buf,addr,conf);
2290 template <
typename T>
2293 return ReadNumericalCollection<T,SimpleRead<T> >(buf,addr,conf);
2296 template <
typename From,
typename To>
2297 struct ConvertRead {
2300 From *temp =
new From[nvalues];
2302 To *vec = (To*)addr;
2303 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2304 vec[ind] = (To)temp[ind];
2310 template <
typename From,
typename To>
2311 struct ConvertRead<NoFactorMarker<From>,To> {
2314 From *temp =
new From[nvalues];
2316 To *vec = (To*)addr;
2317 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2318 vec[ind] = (To)temp[ind];
2324 template <
typename From,
typename To>
2325 struct ConvertRead<WithFactorMarker<From>,To> {
2328 From *temp =
new From[nvalues];
2331 To *vec = (To*)addr;
2332 for(
Int_t ind = 0; ind < nvalues; ++ind) {
2333 vec[ind] = (To)temp[ind];
2339 template <
typename From,
typename To>
2340 struct ConvertCollectionBasicType {
2343 return ReadNumericalCollection<To,ConvertRead<From,To>::Action >(buf,addr,conf);
2349 struct GenericLooper {
2351 template <
typename T>
2354 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2356 Next_t next = loopconfig->fNext;
2360 void *iter = loopconfig->fCopyIterator(iterator,start);
2362 while( (addr = next(iter,end)) ) {
2363 T *
x = (
T*)( ((
char*)addr) + offset );
2366 if (iter != &iterator[0]) {
2367 loopconfig->fDeleteIterator(iter);
2372 template <
typename T>
2375 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2377 Next_t next = loopconfig->fNext;
2381 void *iter = loopconfig->fCopyIterator(iterator,start);
2383 while( (addr = next(iter,end)) ) {
2384 T *
x = (
T*)( ((
char*)addr) + offset );
2387 if (iter != &iterator[0]) {
2388 loopconfig->fDeleteIterator(iter);
2393 template <Int_t (*iter_action)(TBuffer&,
void *,const TConfiguration*)>
2396 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2399 Next_t next = loopconfig->fNext;
2402 void *iter = loopconfig->fCopyIterator(&iterator,start);
2404 while( (addr = next(iter,end)) ) {
2405 iter_action(buf, addr, config);
2407 if (iter != &iterator[0]) {
2408 loopconfig->fDeleteIterator(iter);
2413 template <
typename From,
typename To>
2417 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2420 Next_t next = loopconfig->fNext;
2423 void *iter = loopconfig->fCopyIterator(&iterator,start);
2425 while( (addr = next(iter,end)) ) {
2426 To *
x = (To*)( ((
char*)addr) + offset );
2430 if (iter != &iterator[0]) {
2431 loopconfig->fDeleteIterator(iter);
2436 template <
typename From,
typename To>
2443 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2444 Next_t next = loopconfig->fNext;
2448 while( (addr = next(iter,end)) ) {
2449 To *
x = (To*)(addr);
2456 template <
typename From,
typename To,
template <
typename F,
typename T>
class Converter = Generic >
2457 struct ConvertBasicType {
2462 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2466 From *items =
new From[nvalues];
2468 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2474 template <
typename To>
2475 struct ConvertBasicType<BitsMarker, To, Generic> {
2480 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2485 UInt_t *items = items_storage;
2488 Next_t next = loopconfig->fNext;
2491 void *iter = loopconfig->fCopyIterator(&iterator,start);
2493 while( (addr = next(iter,end)) ) {
2498 To *
x = (To*)( ((
char*)addr) + offset );
2502 if (iter != &iterator[0]) {
2503 loopconfig->fDeleteIterator(iter);
2506 delete [] items_storage;
2511 template <
typename From,
typename To,
template <
typename F,
typename T>
class Converter >
2512 struct ConvertBasicType<WithFactorMarker<From>,To,Converter > {
2517 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2521 TConfSTLWithFactor *conf = (TConfSTLWithFactor *)config;
2523 From *items =
new From[nvalues];
2525 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2531 template <
typename From,
typename To,
template <
typename F,
typename T>
class Converter >
2532 struct ConvertBasicType<NoFactorMarker<From>,To,Converter > {
2537 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2541 TConfSTLNoFactor *conf = (TConfSTLNoFactor *)config;
2543 From *items =
new From[nvalues];
2545 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2556 return GenericRead(buf,start,end,loopconfig, config);
2561 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2568 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2573 template <
typename T>
2592 template <
typename ActionHolder>
2597 TConfigSTL *config = (TConfigSTL*)conf;
2599 buf.
ReadVersion(&start, &count, config->fOldClass);
2601 TClass *newClass = config->fNewClass;
2607 void* alternative = newProxy->
Allocate(nvalues,
true);
2611 void *begin = &(startbuf[0]);
2612 void *end = &(endbuf[0]);
2613 config->fCreateIterators(alternative, &begin, &end, newProxy);
2617 TGenericLoopConfig loopconf(newProxy,
kTRUE);
2618 ActionHolder::Action(buf,begin,end,&loopconf,config);
2620 if (begin != &(startbuf[0])) {
2622 config->fDeleteTwoIterators(begin,end);
2625 newProxy->
Commit(alternative);
2633 return ReadNumericalCollection<ConvertBasicType<bool,bool,Numeric > >(buf,addr,conf);
2638 return ReadNumericalCollection<ConvertBasicType<NoFactorMarker<float>,float,Numeric > >(buf,addr,conf);
2643 return ReadNumericalCollection<ConvertBasicType<float,double,Numeric > >(buf,addr,conf);
2648 template <
typename T>
2653 return ReadNumericalCollection<ConvertBasicType<T,T,Numeric > >(buf,addr,conf);
2656 template <
typename From,
typename To>
2657 struct ConvertCollectionBasicType {
2661 return ReadNumericalCollection<ConvertBasicType<From,To,Numeric > >(buf,addr,conf);
2668template <
typename Looper,
typename From>
2696template <
class Looper>
2716 case TStreamerInfo::kBits:
Error(
"GetNumericCollectionReadAction",
"There is no support for kBits outside of a TObject.");
break;
2718 TConfigSTL *alternate =
new TConfSTLNoFactor(conf,12);
2731 TConfigSTL *alternate =
new TConfSTLNoFactor(conf,0);
2747 Fatal(
"GetNumericCollectionReadAction",
"Is confused about %d",
type);
2752template <
typename Looper,
typename From>
2779template <
typename Looper>
2784 return GetConvertCollectionReadActionFrom<Looper,Bool_t>(newtype, conf );
2787 return GetConvertCollectionReadActionFrom<Looper,Char_t>(newtype, conf );
2790 return GetConvertCollectionReadActionFrom<Looper,Short_t>(newtype, conf );
2793 return GetConvertCollectionReadActionFrom<Looper,Int_t>(newtype, conf );
2796 return GetConvertCollectionReadActionFrom<Looper,Long_t>(newtype, conf );
2799 return GetConvertCollectionReadActionFrom<Looper,Long64_t>(newtype, conf );
2802 return GetConvertCollectionReadActionFrom<Looper,Float_t>( newtype, conf );
2805 return GetConvertCollectionReadActionFrom<Looper,Double_t>(newtype, conf );
2808 return GetConvertCollectionReadActionFrom<Looper,UChar_t>(newtype, conf );
2811 return GetConvertCollectionReadActionFrom<Looper,UShort_t>(newtype, conf );
2814 return GetConvertCollectionReadActionFrom<Looper,UInt_t>(newtype, conf );
2817 return GetConvertCollectionReadActionFrom<Looper,ULong_t>(newtype, conf );
2820 return GetConvertCollectionReadActionFrom<Looper,ULong64_t>(newtype, conf );
2823 return GetConvertCollectionReadActionFrom<Looper,NoFactorMarker<Float16_t> >( newtype, conf );
2826 return GetConvertCollectionReadActionFrom<Looper,NoFactorMarker<Double32_t> >( newtype, conf );
2829 Error(
"GetConvertCollectionReadAction",
"There is no support for kBits outside of a TObject.");
2838template <
class Looper>
2859 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<float> >,
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
2862 if (!nbits) nbits = 12;
2863 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<float> >,
new TConfNoFactor(info,i,compinfo,offset,nbits) );
2869 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<double> >,
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
2875 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<double> >,
new TConfNoFactor(info,i,compinfo,offset,nbits) );
2893 return GetCollectionReadConvertAction<Looper,Bool_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2896 return GetCollectionReadConvertAction<Looper,Char_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2899 return GetCollectionReadConvertAction<Looper,Short_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2902 return GetCollectionReadConvertAction<Looper,Int_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2905 return GetCollectionReadConvertAction<Looper,Long_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2908 return GetCollectionReadConvertAction<Looper,Long64_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2911 return GetCollectionReadConvertAction<Looper,Float_t>( element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2914 return GetCollectionReadConvertAction<Looper,Double_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2917 return GetCollectionReadConvertAction<Looper,UChar_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2920 return GetCollectionReadConvertAction<Looper,UShort_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2923 return GetCollectionReadConvertAction<Looper,UInt_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2926 return GetCollectionReadConvertAction<Looper,ULong_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2929 return GetCollectionReadConvertAction<Looper,ULong64_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2932 return GetCollectionReadConvertAction<Looper,BitsMarker>(element->
GetNewType(),
new TBitsConfiguration(info,i,compinfo,offset) );
2936 return GetCollectionReadConvertAction<Looper,WithFactorMarker<float> >(element->
GetNewType(),
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
2939 if (!nbits) nbits = 12;
2940 return GetCollectionReadConvertAction<Looper,NoFactorMarker<float> >(element->
GetNewType(),
new TConfNoFactor(info,i,compinfo,offset,nbits) );
2946 return GetCollectionReadConvertAction<Looper,WithFactorMarker<double> >(element->
GetNewType(),
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
2950 return GetCollectionReadConvertAction<Looper,Float_t>(element->
GetNewType(),
new TConfiguration(info,i,compinfo,offset) );
2952 return GetCollectionReadConvertAction<Looper,NoFactorMarker<double> >(element->
GetNewType(),
new TConfNoFactor(info,i,compinfo,offset,nbits) );
2958 return TConfiguredAction( Looper::GenericRead,
new TGenericConfiguration(info,i,compinfo) );
2965template <
class Looper>
3072 fNslots = ndata + ndata/2 + 1;
3091 for (i = 0; i < ndata; ++i) {
3135 if (!previousOptimized) {
3146 if (
fComp[keep].fLength == 0) {
3151 isOptimized =
kTRUE;
3152 previousOptimized =
kTRUE;
3153 }
else if (element->
GetType() < 0) {
3166 previousOptimized =
kFALSE;
3184 Warning(
"Compile",
"Counter %s should not be skipped from class %s", element->
GetName(),
GetName());
3195 if (
fComp[keep].fLength == 0) {
3199 previousOptimized =
kFALSE;
3209 for (i = 0; i <
fNdata; ++i) {
3238template <
typename From>
3270 switch (compinfo->
fType) {
3288 readSequence->
AddAction( ReadBasicType_WithFactor<float>,
new TConfWithFactor(
this,i,compinfo,compinfo->
fOffset,element->
GetFactor(),element->
GetXmin()) );
3291 if (!nbits) nbits = 12;
3292 readSequence->
AddAction( ReadBasicType_NoFactor<float>,
new TConfNoFactor(
this,i,compinfo,compinfo->
fOffset,nbits) );
3298 readSequence->
AddAction( ReadBasicType_WithFactor<double>,
new TConfWithFactor(
this,i,compinfo,compinfo->
fOffset,element->
GetFactor(),element->
GetXmin()) );
3304 readSequence->
AddAction( ReadBasicType_NoFactor<double>,
new TConfNoFactor(
this,i,compinfo,compinfo->
fOffset,nbits) );
3321 if (newClass && newClass != oldClass) {
3323 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseStreamerV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3325 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseFastArrayV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetTypeName(),isSTLbase));
3329 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseStreamerV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3331 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseFastArrayV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,element->
GetTypeName(),isSTLbase));
3335 if (newClass && newClass != oldClass) {
3337 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseStreamer>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3340 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseFastArray>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetTypeName(),isSTLbase));
3344 readSequence->
AddAction(GetConvertCollectionReadAction<VectorLooper>(oldClass->
GetCollectionProxy()->
GetType(), newClass->
GetCollectionProxy()->
GetType(),
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetTypeName(),isSTLbase)));
3347 readSequence->
AddAction(GetConvertCollectionReadAction<AssociativeLooper>(oldClass->
GetCollectionProxy()->
GetType(), newClass->
GetCollectionProxy()->
GetType(),
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetTypeName(),isSTLbase)));
3353 readSequence->
AddAction(GetConvertCollectionReadAction<GenericLooper>(oldClass->
GetCollectionProxy()->
GetType(), newClass->
GetCollectionProxy()->
GetType(),
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,newClass,element->
GetTypeName(),isSTLbase)));
3360 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseStreamer>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3363 readSequence->
AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseFastArray>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,1,oldClass,element->
GetTypeName(),isSTLbase));
3385 if (newClass && newClass != oldClass) {
3387 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseStreamerV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,newClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3389 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseFastArrayV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,newClass,element->
GetTypeName(),isSTLbase));
3393 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseStreamerV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3395 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseFastArrayV2>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,element->
GetTypeName(),isSTLbase));
3399 if (newClass && newClass != oldClass) {
3401 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseStreamer>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,newClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3403 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseFastArray>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,newClass,element->
GetTypeName(),isSTLbase));
3407 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseStreamer>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,element->
GetStreamer(),element->
GetTypeName(),isSTLbase));
3409 readSequence->
AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseFastArray>,
new TConfigSTL(
this,i,compinfo,compinfo->
fOffset,element->
GetArrayLength(),oldClass,element->
GetTypeName(),isSTLbase));
3457 AddReadConvertAction<BitsMarker>(readSequence, compinfo->
fNewType,
new TBitsConfiguration(
this,i,compinfo,compinfo->
fOffset) );
3461 AddReadConvertAction<WithFactorMarker<float> >(readSequence, compinfo->
fNewType,
new TConfWithFactor(
this,i,compinfo,compinfo->
fOffset,element->
GetFactor(),element->
GetXmin()) );
3464 if (!nbits) nbits = 12;
3465 AddReadConvertAction<NoFactorMarker<float> >(readSequence, compinfo->
fNewType,
new TConfNoFactor(
this,i,compinfo,compinfo->
fOffset,nbits) );
3471 AddReadConvertAction<WithFactorMarker<double> >(readSequence, compinfo->
fNewType,
new TConfWithFactor(
this,i,compinfo,compinfo->
fOffset,element->
GetFactor(),element->
GetXmin()) );
3477 AddReadConvertAction<NoFactorMarker<double> >(readSequence, compinfo->
fNewType,
new TConfNoFactor(
this,i,compinfo,compinfo->
fOffset,nbits) );
3505 switch (compinfo->
fType) {
3546 default:
generic =
kTRUE;
break;
3573 readSequence->
AddAction( GetCollectionReadAction<VectorPtrLooper>(
this,element,compinfo->
fType,i,compinfo,compinfo->
fOffset) );
3590 switch (compinfo->
fType) {
3674#if defined(CDJ_NO_COMPILE)
3677 writeSequence->
fActions.pop_back();
3699 switch (compinfo->
fType) {
3854 default:
generic =
kTRUE;
break;
3870#if defined(CDJ_NO_COMPILE)
3873 writeSequence->
fActions.pop_back();
3895#if defined(CDJ_NO_COMPILE)
3900 writeSequence->Addaction( GetCollectionWriteAction<VectorPtrLooper>(
this,element,compinfo->
fType,i,compinfo,compinfo->
fOffset) );
3903 writeSequence->
AddAction( VectorPtrLooper::GenericWrite,
new TGenericConfiguration(
this,i,compinfo) );
3946 for (
UInt_t i = 0; i < ndata; ++i) {
3970 ::Warning(
"CreateReadMemberWiseActions",
"%s",
3986 if (newType != oldType) {
4004 TConfiguredAction action( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4007 sequence->
AddAction( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset));
4014 TConfiguredAction action( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4017 sequence->
AddAction( GetCollectionReadAction<GenericLooper>(info,element,oldType,i,compinfo,offset) );
4061 for (
UInt_t i = 0; i < ndata; ++i) {
4089#if defined(CDJ_NO_COMPILE)
4092 if (newType != oldType) {
4108 TConfiguredAction action( GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4111 sequence->
AddAction(GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset));
4120 TConfiguredAction action( GetWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4141 sequence->
AddAction( GenericLooper<WriteBasicType_WithFactor<float> >,
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
4144 if (!nbits) nbits = 12;
4145 sequence->
AddAction( GenericLooper<WriteBasicType_NoFactor<float> >,
new TConfNoFactor(info,i,compinfo,offset,nbits) );
4151 sequence->
AddAction( GenericLooper<WriteBasicType_WithFactor<double> >,
new TConfWithFactor(info,i,compinfo,offset,element->
GetFactor(),element->
GetXmin()) );
4155 sequence->
AddAction( GenericLooper<ConvertBasicType<float,double> >,
new TConfiguration(info,i,compinfo,offset) );
4157 sequence->
AddAction( GenericLooper<WriteBasicType_NoFactor<double> >,
new TConfNoFactor(info,i,compinfo,offset,nbits) );
4178 sequence->
AddAction( GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4196 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4197 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4202 if (iter->fConfiguration->fElemId != (
UInt_t)-1 &&
4204 iter->fConfiguration->AddToOffset(delta);
4213 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4214 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4218 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(
TStreamerElement::kCache))
4219 iter->fConfiguration->SetMissing();
4231 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4232 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4237 sequence->
AddAction( iter->fAction, conf );
4247 for(
UInt_t id = 0;
id < element_ids.size(); ++
id) {
4248 if ( element_ids[
id].fElemID < 0 ) {
4249 if (element_ids[
id].fNestedIDs) {
4250 auto original = create(element_ids[
id].fNestedIDs->fInfo,
4253 if (element_ids[
id].fNestedIDs->fOnfileObject) {
4254 auto conf =
new TConfigurationPushDataCache(element_ids[
id].fNestedIDs->fInfo, element_ids[
id].fNestedIDs->fOnfileObject, offset);
4263 original->AddToSubSequence(sequence, element_ids[
id].fNestedIDs->fIDs, element_ids[
id].fNestedIDs->fOffset, create);
4265 if (element_ids[
id].fNestedIDs->fOnfileObject) {
4267 new TConfigurationPushDataCache(element_ids[
id].fNestedIDs->fInfo,
nullptr, element_ids[
id].fNestedIDs->fOffset);
4276 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4277 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4282 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(
TStreamerElement::kCache))
4284 sequence->
AddAction( iter->fAction, conf );
4289 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4290 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4302 if ( iter->fConfiguration->fElemId == (
UInt_t)element_ids[
id].fElemID ) {
4304 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(
TStreamerElement::kCache))
4306 sequence->
AddAction( iter->fAction, conf );
4323 AddToSubSequence(sequence, element_ids, offset, create);
4337 for(
UInt_t id = 0;
id < element_ids.size(); ++
id) {
4338 if ( element_ids[
id] < 0 ) {
4339 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4340 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4345 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(
TStreamerElement::kCache))
4347 sequence->
AddAction( iter->fAction, conf );
4350 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4351 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4354 if ( iter->fConfiguration->fElemId == (
UInt_t)element_ids[
id] ) {
4356 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(
TStreamerElement::kCache))
4358 sequence->
AddAction( iter->fAction, conf );
4366#if !defined(R__WIN32) && !defined(_AIX)
4375#if defined(R__WIN32) || defined(__CYGWIN__) || defined(_AIX)
4376 return "not available on this platform";
4378 MEMORY_BASIC_INFORMATION mbi;
4379 if (!VirtualQuery (func, &mbi,
sizeof (mbi)))
4384 HMODULE hMod = (HMODULE) mbi.AllocationBase;
4385 static char moduleName[MAX_PATH];
4387 if (!GetModuleFileNameA (hMod, moduleName,
sizeof (moduleName)))
4395 if (dladdr((
void*)func,&info)==0) {
4397 return "name not found";
4400 return info.dli_sname;
4412 fLoopConfig->Print();
4414 TStreamerInfoActions::ActionContainer_t::const_iterator end = fActions.end();
4415 for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = fActions.begin();
4419 iter->fConfiguration->Print();
4420 if (strstr(opt,
"func")) {
void Error(const char *location, const char *msgfmt,...)
void Warning(const char *location, const char *msgfmt,...)
void Fatal(const char *location, const char *msgfmt,...)
R__EXTERN TVirtualMutex * gInterpreterMutex
static TConfiguredAction GetNumericCollectionReadAction(Int_t type, TConfigSTL *conf)
static void AddReadConvertAction(TStreamerInfoActions::TActionSequence *sequence, Int_t newtype, TConfiguration *conf)
static TConfiguredAction GetCollectionReadConvertAction(Int_t newtype, TConfiguration *conf)
static TConfiguredAction GetCollectionReadAction(TVirtualStreamerInfo *info, TStreamerElement *element, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset)
static const Int_t kRegrouped
#define INLINE_TEMPLATE_ARGS
static const char * R__GetSymbolName(voidfunc func)
static TConfiguredAction GetConvertCollectionReadAction(Int_t oldtype, Int_t newtype, TConfiguration *conf)
static TConfiguredAction GetCollectionWriteAction(TVirtualStreamerInfo *info, TStreamerElement *, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset)
static TConfiguredAction GetConvertCollectionReadActionFrom(Int_t newtype, TConfiguration *conf)
virtual void ReadBuffer(char *&buffer)
typedef void((*Func_t)())
#define R__LOCKGUARD(mutex)
Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use meth...
Buffer base class used for serializing objects.
virtual void ReadWithNbits(Float_t *ptr, Int_t nbits)=0
virtual void ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue)=0
virtual TProcessID * ReadProcessID(UShort_t pidf)=0
Return the current Process-ID.
virtual void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=0)=0
virtual UInt_t WriteVersionMemberWise(const TClass *cl, Bool_t useBcnt=kFALSE)=0
virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion=kFALSE)=0
virtual void ReadInt(Int_t &i)=0
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
TObject * GetParent() const
Return pointer to parent of this buffer.
virtual UShort_t GetPidOffset() const =0
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
@ kCannotHandleMemberWiseStreaming
virtual void StreamObject(void *obj, const std::type_info &typeinfo, const TClass *onFileClass=0)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
virtual void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=0)=0
virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *object)=0
virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits)=0
void SetBufferOffset(Int_t offset=0)
virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue)=0
virtual UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt=kFALSE)=0
virtual Version_t ReadVersionForMemberWise(const TClass *cl=0)=0
virtual void WriteFastArray(const Bool_t *b, Int_t n)=0
TClass instances represent classes, structs and namespaces in the ROOT type system.
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Bool_t CanSplit() const
Return true if the data member of this TClass can be saved separately.
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.
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=0) const
TVirtualStreamerInfo * GetConversionStreamerInfo(const char *onfile_classname, Int_t version) const
Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this clas...
@ kHasCustomStreamerMember
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
virtual const char * GetTitle() const
Returns title of object.
virtual const char * GetName() const
Returns name of object.
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
Int_t GetEntries() const
Return the number of objects in array (i.e.
virtual void AddAt(TObject *obj, Int_t idx)
Add object at position ids.
TObject * At(Int_t idx) const
Mother of all ROOT objects.
virtual const char * GetName() const
Returns name of object.
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
virtual UInt_t GetUniqueID() const
Return the unique object id.
virtual const char * ClassName() const
Returns name of class to which the object belongs.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
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...
const char * GetErrorMessage() const
virtual Int_t GetSize() const
Returns size of this element in bytes.
virtual const char * GetFullName() const
Return element name including dimensions, if any Note that this function stores the name into a stati...
virtual TClass * GetClassPointer() const
Returns a pointer to the TClass of this element.
Int_t GetArrayDim() const
TMemberStreamer * GetStreamer() const
Return the local streamer object.
TClass * GetNewClass() const
Int_t GetArrayLength() const
Double_t GetFactor() const
const char * GetTypeName() const
virtual Bool_t IsBase() const
Return kTRUE if the element represent a base class.
virtual ULong_t GetMethod() const
virtual Bool_t HasCounter() const
void GetSequenceType(TString &type) const
Fill type with the string representation of sequence information including 'cached',...
Bool_t IsForVectorPtrLooper() const
static TActionSequence * CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
void Print(Option_t *="") const
This method must be overridden when a class wants to print itself.
TLoopConfiguration * fLoopConfig
If this is a bundle of memberwise streaming action, this configures the looping.
static TActionSequence * CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
SequencePtr(*)(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *originalClass) SequenceGetter_t
ActionContainer_t fActions
void AddToSubSequence(TActionSequence *sequence, const TIDs &element_ids, Int_t offset, SequenceGetter_t create)
TActionSequence * CreateSubSequence(const std::vector< Int_t > &element_ids, size_t offset)
TActionSequence * CreateCopy()
void AddAction(action_t action, TConfiguration *conf)
void AddToOffset(Int_t delta)
Base class of the Configurations.
virtual void SetMissing()
virtual void PrintDebug(TBuffer &buffer, void *object) const
virtual TConfiguration * Copy()
TVirtualStreamerInfo * fInfo
TStreamerInfo form which the action is derived.
Int_t fOffset
Offset within the object.
TCompInfo_t * fCompInfo
Access to compiled information (for legacy code)
UInt_t fLength
Number of element in a fixed length array.
UInt_t fElemId
Identifier of the TStreamerElement.
virtual void Print() const
virtual void AddToOffset(Int_t delta)
Base class of the Configurations for the member wise looping routines.
TVirtualCollectionProxy * fProxy
virtual void Print() const
virtual TVirtualCollectionProxy * GetCollectionProxy() const
virtual TLoopConfiguration * Copy() const =0
TClass * fClass
Not Owned.
TMemberStreamer * fStreamer
Not Owned.
TStreamerElement * fElem
Not Owned.
TClass * fNewClass
Not Owned.
Describe Streamer information for one class version.
Int_t fNVirtualInfoLoc
! Number of virtual info location to update.
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.
void AddWriteAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t index, TCompInfo *compinfo)
Int_t fNfulldata
!number of elements
TCompInfo * fComp
![fNslots with less than fElements->GetEntries()*1.5 used] Compiled info
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions(Bool_t forCollection)
void Compile()
loop on the TStreamerElement list regroup members with same type Store predigested information into l...
TStreamerInfoActions::TActionSequence * fWriteMemberWiseVecPtr
! List of write action resulting from the compilation for use in member wise streaming.
TStreamerInfoActions::TActionSequence * fReadText
! List of text read action resulting from the compilation, used for JSON.
void AddReadTextAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read text action for the given element.
TCompInfo ** fCompFull
![fElements->GetEntries()]
TObjArray * fElements
Array of TStreamerElements.
@ 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.
void AddReadMemberWiseVecPtrAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read action for the given element.
TClass * GetClass() const
void ls(Option_t *option="") const
List the TStreamerElement list and also the precomputed tables if option contains the string "incOrig...
TStreamerInfoActions::TActionSequence * fReadMemberWise
! List of read action resulting from the compilation for use in member wise streaming.
Int_t fNdata
!number of optimized elements
TStreamerInfoActions::TActionSequence * fReadMemberWiseVecPtr
! List of read action resulting from the compilation for use in member wise streaming.
TStreamerInfoActions::TActionSequence * fReadObjectWise
! List of read action resulting from the compilation.
TClass * fClass
!pointer to class
TCompInfo ** fCompOpt
![fNdata]
static std::atomic< Int_t > fgCount
Number of TStreamerInfo instances.
void AddWriteTextAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t index, TCompInfo *compinfo)
void ComputeSize()
Compute total size of all persistent elements of the class.
void AddReadAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read action for the given element.
void AddWriteMemberWiseVecPtrAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t index, TCompInfo *compinfo)
This is for streaming via a TClonesArray (or a vector of pointers of this type).
Int_t fNumber
!Unique identifier
TStreamerInfoActions::TActionSequence * fWriteObjectWise
! List of write action resulting from the compilation.
Int_t fSize
!size of the persistent class
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.
TStreamerInfoActions::TActionSequence * fWriteMemberWise
! List of write action resulting from the compilation for use in member wise streaming.
Int_t fNslots
!total numbrer of slots in fComp.
Version_t fOldVersion
! Version of the TStreamerInfo object read from the file
TStreamerInfoActions::TActionSequence * fWriteText
! List of text write action resulting for the compilation, used for JSON.
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Bool_t forCollection)
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
const char * Data() const
Wrapper around an object and giving indirect access to its content even if the object is not of a cla...
virtual Int_t GetProperties() const
virtual ULong_t GetIncrement() const =0
virtual TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version)=0
void(* CreateIterators_t)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
virtual EDataType GetType() const =0
void *(* CopyIterator_t)(void *dest, const void *source)
void *(* Next_t)(void *iter, const void *end)
virtual TClass * GetValueClass() const =0
virtual void Commit(void *)=0
virtual Int_t GetCollectionType() const =0
virtual Next_t GetFunctionNext(Bool_t read=kTRUE)=0
virtual DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read=kTRUE)=0
virtual UInt_t Size() const =0
void(* DeleteTwoIterators_t)(void *begin, void *end)
void(* DeleteIterator_t)(void *iter)
static const Int_t fgIteratorArenaSize
virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE)=0
virtual void * Allocate(UInt_t n, Bool_t forceDelete)=0
virtual TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version)=0
virtual DeleteIterator_t GetFunctionDeleteIterator(Bool_t read=kTRUE)=0
virtual CopyIterator_t GetFunctionCopyIterator(Bool_t read=kTRUE)=0
virtual Bool_t HasPointers() const =0
virtual TClass * GetCollectionClass() const
static void DeleteIterator(void *iter)
static void * Next(void *iter, const void *end)
static void * CopyIterator(void *dest, const void *source)
Abstract Interface class describing Streamer information for one class.
static Bool_t GetStreamMemberWise()
Return whether the TStreamerInfos will save the collections in "member-wise" order whenever possible.
Bool_t IsCompiled() const
static Bool_t CanOptimize()
static function returning true if optimization can be on
virtual TObjArray * GetElements() const =0
virtual Int_t GetClassVersion() const =0
void Copy(void *source, void *dest)
void Print(std::ostream &os, const OptionType &opt)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
INLINE_TEMPLATE_ARGS Int_t UseCache(TBuffer &b, void *addr, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t ReadTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Int_t PushDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t ReadBasicType(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t WriteTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t WriteTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadTextTObjectBase(TBuffer &buf, void *addr, const TConfiguration *config)
Int_t PopDataCache(TBuffer &b, void *, const TConfiguration *)
INLINE_TEMPLATE_ARGS Int_t WriteBasicType(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadSTL(TBuffer &buf, void *addr, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t WriteTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseFastArrayV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
INLINE_TEMPLATE_ARGS Int_t ReadTString(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS void ReadArraySTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Int_t GenericWriteAction(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Int_t PopDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *)
Int_t GenericReadAction(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS void ReadArraySTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
INLINE_TEMPLATE_ARGS Int_t ReadTextObject(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t UseCacheVectorLoop(TBuffer &b, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseFastArray(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t, UInt_t)
Int_t PushDataCache(TBuffer &b, void *, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t ReadBasicType_NoFactor(TBuffer &buf, void *addr, const TConfiguration *config)
std::vector< TIDNode > TIDs
INLINE_TEMPLATE_ARGS void ReadSTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Int_t WriteLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t WriteStreamerLoop(TBuffer &buf, void *addr, const TConfiguration *config)
Direct copy of code from TStreamerInfo::WriteBufferAux, potentially can be used later for non-text st...
INLINE_TEMPLATE_ARGS Int_t UseCacheVectorPtrLoop(TBuffer &b, void *start, const void *end, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t UseCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
INLINE_TEMPLATE_ARGS Int_t ReadTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadSTLp(TBuffer &buf, void *addr, const TConfiguration *config)
Direct copy of code from TStreamerInfo::WriteBufferAux, potentially can be used later for non-text st...
INLINE_TEMPLATE_ARGS Int_t WriteTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseStreamerV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseStreamer(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t, UInt_t)
INLINE_TEMPLATE_ARGS Int_t ReadBasicType< BitsMarker >(TBuffer &buf, void *addr, const TConfiguration *config)
bool IsDefaultVector(TVirtualCollectionProxy &proxy)
Int_t ReadLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t WriteSTLp(TBuffer &buf, void *addr, const TConfiguration *config)
Direct copy of code from TStreamerInfo::WriteBufferAux, potentially can be used later for non-text st...
INLINE_TEMPLATE_ARGS void ReadSTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
void HandleReferencedTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Int_t PopDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *, const TConfiguration *)
INLINE_TEMPLATE_ARGS Int_t ReadStreamerLoop(TBuffer &buf, void *addr, const TConfiguration *config)
Direct copy of code from TStreamerInfo::WriteBufferAux, potentially can be used later for non-text st...
Int_t PushDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
ESelectLooper SelectLooper(TVirtualCollectionProxy &proxy)
INLINE_TEMPLATE_ARGS Int_t ReadTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
INLINE_TEMPLATE_ARGS Int_t ReadBasicType_WithFactor(TBuffer &buf, void *addr, const TConfiguration *config)
TVirtualCollectionProxy::Next_t Next_t