Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TStreamerInfoActions.cxx
Go to the documentation of this file.
1// @(#)root/io:$Id$
2// Author: Philippe Canal 05/2010
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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
12#include "TStreamerInfo.h"
13#include "TStreamerInfoActions.h"
14#include "TROOT.h"
15#include "TStreamerElement.h"
16#include "TVirtualMutex.h"
17#include "TInterpreter.h"
18#include "TError.h"
19#include "TVirtualArray.h"
20#include "TBufferFile.h"
21#include "TBufferText.h"
22#include "TMemberStreamer.h"
23#include "TClassEdit.h"
24#include "TVirtualCollectionIterators.h"
25#include "TProcessID.h"
26#include "TFile.h"
27
28static const Int_t kRegrouped = TStreamerInfo::kOffsetL;
29
30// More possible optimizations:
31// Avoid call the virtual version of TBuffer::ReadInt and co.
32// Merge the Reading of the version and the looking up or the StreamerInfo
33// Avoid if (bytecnt) inside the CheckByteCount routines and avoid multiple (mostly useless nested calls)
34// Try to avoid if statement on onfile class being set (TBufferFile::ReadClassBuffer).
35
36using namespace TStreamerInfoActions;
37
38#ifdef _AIX
39# define INLINE_TEMPLATE_ARGS
40#else
41# define INLINE_TEMPLATE_ARGS inline
42#endif
43
44
45namespace TStreamerInfoActions
46{
47 bool IsDefaultVector(TVirtualCollectionProxy &proxy)
48 {
49 const auto props = proxy.GetProperties();
50 const bool isVector = proxy.GetCollectionType() == ROOT::kSTLvector;
51 const bool hasDefaultAlloc = !(props & TVirtualCollectionProxy::kCustomAlloc);
52 const bool isEmulated = props & TVirtualCollectionProxy::kIsEmulated;
53
54 return isEmulated || (isVector && hasDefaultAlloc);
55 }
56
57 template <typename From>
58 struct WithFactorMarker {
59 typedef From Value_t;
60 };
61
62 template <typename From>
63 struct NoFactorMarker {
64 typedef From Value_t;
65 };
66
67 struct BitsMarker {
68 typedef UInt_t Value_t;
69 };
70
71 void TConfiguration::AddToOffset(Int_t delta)
72 {
73 // Add the (potentially negative) delta to all the configuration's offset. This is used by
74 // TBranchElement in the case of split sub-object.
75
76 if (fOffset != TVirtualStreamerInfo::kMissing)
77 fOffset += delta;
78 }
79
80 void TConfiguration::SetMissing()
81 {
82 // Add the (potentially negative) delta to all the configuration's offset. This is used by
83 // TBranchElement in the case of split sub-object.
84
85 fOffset = TVirtualStreamerInfo::kMissing;
86 }
87
88 void TConfiguredAction::PrintDebug(TBuffer &buf, void *addr) const
89 {
90 // Inform the user what we are about to stream.
91
92 // Idea, we should find a way to print the name of the function
93 if (fConfiguration) fConfiguration->PrintDebug(buf,addr);
94 }
95
96 void TConfiguration::Print() const
97 {
98 // Inform the user what we are about to stream.
99
100 TStreamerInfo *info = (TStreamerInfo*)fInfo;
101 TStreamerElement *aElement = fCompInfo->fElem;
102 TString sequenceType;
103 aElement->GetSequenceType(sequenceType);
104
105 printf("StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
106 " %s, offset=%d (%s), elemnId=%d \n",
107 info->GetClass()->GetName(), aElement->GetName(), fElemId, fCompInfo->fType,
108 aElement->ClassName(), fOffset, sequenceType.Data(), fElemId);
109 }
110
111 void TConfiguration::PrintDebug(TBuffer &buf, void *addr) const
112 {
113 // Inform the user what we are about to stream.
114
115 if (gDebug > 1) {
116 // Idea: We should print the name of the action function.
117 TStreamerInfo *info = (TStreamerInfo*)fInfo;
118 TStreamerElement *aElement = fCompInfo->fElem;
119 TString sequenceType;
120 aElement->GetSequenceType(sequenceType);
121
122 printf("StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
123 " %s, bufpos=%d, arr=%p, offset=%d (%s)\n",
124 info->GetClass()->GetName(), aElement->GetName(), fElemId, fCompInfo->fType,
125 aElement->ClassName(), buf.Length(), addr, fOffset, sequenceType.Data());
126 }
127 }
128
129 void TLoopConfiguration::Print() const
130 {
131 // Inform the user what we are about to stream.
132
133 printf("TLoopConfiguration: unconfigured\n");
134 }
135
136
137 struct TGenericConfiguration : TConfiguration {
138 // Configuration of action using the legacy code.
139 // Mostly to cancel out the PrintDebug.
140 public:
141 TGenericConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset = 0) : TConfiguration(info,id,compinfo,offset) {};
142 void PrintDebug(TBuffer &, void *) const override {
143 // Since we call the old code, it will print the debug statement.
144 }
145
146 TConfiguration *Copy() override { return new TGenericConfiguration(*this); }
147 };
148
149 struct TBitsConfiguration : TConfiguration {
150 // Configuration of action handling kBits.
151 // In this case we need to know both the location
152 // of the member (fBits) and the start of the object
153 // (its TObject part to be exact).
154
155 Int_t fObjectOffset; // Offset of the TObject part within the object
156
157 TBitsConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset = 0) : TConfiguration(info,id,compinfo,offset),fObjectOffset(0) {};
158 void PrintDebug(TBuffer &, void *) const override
159 {
160 TStreamerInfo *info = (TStreamerInfo*)fInfo;
161 TStreamerElement *aElement = fCompInfo->fElem;
162 TString sequenceType;
163 aElement->GetSequenceType(sequenceType);
164
165 printf("StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
166 " %s, offset=%d (%s)\n",
167 info->GetClass()->GetName(), aElement->GetName(), fElemId, fCompInfo->fType,
168 aElement->ClassName(), fOffset, sequenceType.Data());
169 }
170
171 void AddToOffset(Int_t delta) override
172 {
173 // Add the (potentially negative) delta to all the configuration's offset. This is used by
174 // TBranchElement in the case of split sub-object.
175
176 if (fOffset != TVirtualStreamerInfo::kMissing)
177 fOffset += delta;
178 fObjectOffset = 0;
179 }
180
181 void SetMissing() override
182 {
183 fOffset = TVirtualStreamerInfo::kMissing;
184 fObjectOffset = 0;
185 }
186
187 TConfiguration *Copy() override { return new TBitsConfiguration(*this); }
188
189 };
190
191 Int_t GenericReadAction(TBuffer &buf, void *addr, const TConfiguration *config)
192 {
193 char *obj = (char*)addr;
194 TGenericConfiguration *conf = (TGenericConfiguration*)config;
195 return ((TStreamerInfo*)conf->fInfo)->ReadBuffer(buf, &obj, &(conf->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ 1, config->fOffset, 2);
196 }
197
198 Int_t GenericWriteAction(TBuffer &buf, void *addr, const TConfiguration *config)
199 {
200 char *obj = (char*)addr;
201 TGenericConfiguration *conf = (TGenericConfiguration*)config;
202 return ((TStreamerInfo*)conf->fInfo)->WriteBufferAux(buf, &obj, &(conf->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ 1, config->fOffset, 2);
203 }
204
205 template <typename T>
206 INLINE_TEMPLATE_ARGS Int_t ReadBasicType(TBuffer &buf, void *addr, const TConfiguration *config)
207 {
208 T *x = (T*)( ((char*)addr) + config->fOffset );
209 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
210 buf >> *x;
211 return 0;
212 }
213
214 void HandleReferencedTObject(TBuffer &buf, void *addr, const TConfiguration *config) {
215 TBitsConfiguration *conf = (TBitsConfiguration*)config;
216 UShort_t pidf;
217 buf >> pidf;
218 pidf += buf.GetPidOffset();
219 TProcessID *pid = buf.ReadProcessID(pidf);
220 if (pid!=0) {
221 TObject *obj = (TObject*)( ((char*)addr) + conf->fObjectOffset);
222 UInt_t gpid = pid->GetUniqueID();
223 UInt_t uid;
224 if (gpid>=0xff) {
225 uid = obj->GetUniqueID() | 0xff000000;
226 } else {
227 uid = ( obj->GetUniqueID() & 0xffffff) + (gpid<<24);
228 }
229 obj->SetUniqueID(uid);
230 pid->PutObjectWithID(obj);
231 }
232 }
233
234 template <>
235 INLINE_TEMPLATE_ARGS Int_t ReadBasicType<BitsMarker>(TBuffer &buf, void *addr, const TConfiguration *config)
236 {
237 UInt_t *x = (UInt_t*)( ((char*)addr) + config->fOffset );
238 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
239 // Idea: This code really belongs inside TBuffer[File]
240 const UInt_t isonheap = *x & TObject::kIsOnHeap; // Record how this instance was actually allocated.
241 buf >> *x;
242 *x |= isonheap | TObject::kNotDeleted; // by definition de-serialized object are not yet deleted.
243
244 if ((*x & kIsReferenced) != 0) {
245 HandleReferencedTObject(buf,addr,config);
246 }
247 return 0;
248 }
249
250 template <typename T>
251 INLINE_TEMPLATE_ARGS Int_t WriteBasicType(TBuffer &buf, void *addr, const TConfiguration *config)
252 {
253 T *x = (T *)(((char *)addr) + config->fOffset);
254 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
255 buf << *x;
256 return 0;
257 }
258
259 INLINE_TEMPLATE_ARGS Int_t WriteTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
260 {
261 void *x = (void *)(((char *)addr) + config->fOffset);
262 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
263 buf.StreamObject(x, TNamed::Class(), TNamed::Class());
264 return 0;
265 }
266
267 INLINE_TEMPLATE_ARGS Int_t WriteTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
268 {
269 void *x = (void *)(((char *)addr) + config->fOffset);
270 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
271 buf.StreamObject(x, TObject::Class(), TObject::Class());
272 return 0;
273 }
274
275 INLINE_TEMPLATE_ARGS Int_t WriteTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
276 {
277 void *x = (void *)(((char *)addr) + config->fOffset);
278 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
279 ((TBufferText *)&buf)->WriteBaseClass(x, (TStreamerBase *)config->fCompInfo->fElem);
280 return 0;
281 }
282
283 INLINE_TEMPLATE_ARGS Int_t WriteTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
284 {
285 void *x = (void *)(((char *)addr) + config->fOffset);
286 TMemberStreamer *pstreamer = config->fCompInfo->fStreamer;
287 UInt_t pos = buf.WriteVersion(config->fInfo->IsA(), kTRUE);
288 (*pstreamer)(buf, x, config->fCompInfo->fLength);
289 buf.SetByteCount(pos, kTRUE);
290 return 0;
291 }
292
293 INLINE_TEMPLATE_ARGS Int_t ReadTextObject(TBuffer &buf, void *addr, const TConfiguration *config)
294 {
295 void *x = (void *)(((char *)addr) + config->fOffset);
296 buf.ReadFastArray(x, config->fCompInfo->fClass, config->fCompInfo->fLength, config->fCompInfo->fStreamer);
297 return 0;
298 }
299
300 INLINE_TEMPLATE_ARGS Int_t ReadTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
301 {
302 void *x = (void *)(((char *)addr) + config->fOffset);
303 buf.StreamObject(x, TObject::Class(), TObject::Class());
304 return 0;
305 }
306
307 INLINE_TEMPLATE_ARGS Int_t ReadTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
308 {
309 void *x = (void *)(((char *)addr) + config->fOffset);
310 // Idea: Implement buf.ReadBasic/Primitive to avoid the return value
311 ((TBufferText *)&buf)->ReadBaseClass(x, (TStreamerBase *)config->fCompInfo->fElem);
312 return 0;
313 }
314
315 INLINE_TEMPLATE_ARGS Int_t ReadTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
316 {
317 void *x = (void *)(((char *)addr) + config->fOffset);
318 TMemberStreamer *pstreamer = config->fCompInfo->fStreamer;
319
320 UInt_t start, count;
321 /* Version_t v = */ buf.ReadVersion(&start, &count, config->fCompInfo->fClass);
322 (*pstreamer)(buf, x, config->fCompInfo->fLength);
323 buf.CheckByteCount(start, count, config->fCompInfo->fElem->GetFullName());
324 return 0;
325 }
326
327 INLINE_TEMPLATE_ARGS Int_t ReadTextTObjectBase(TBuffer &buf, void *addr, const TConfiguration *config)
328 {
329 // action required to call custom code for TObject as base class
330 void *x = (void *)(((char *)addr) + config->fOffset);
331 buf.ReadClassBuffer(TObject::Class(), x, TObject::Class());
332 return 0;
333 }
334
335 INLINE_TEMPLATE_ARGS Int_t ReadTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
336 {
337 void *x = (void *)(((char *)addr) + config->fOffset);
338 buf.StreamObject(x, TNamed::Class(), TNamed::Class());
339 return 0;
340 }
341
342 /** Direct copy of code from TStreamerInfo::WriteBufferAux,
343 * potentially can be used later for non-text streaming */
344 template<bool kIsTextT>
345 INLINE_TEMPLATE_ARGS Int_t WriteSTLp(TBuffer &buf, void *addr, const TConfiguration *config)
346 {
347 TClass *cl = config->fCompInfo->fClass;
348 TMemberStreamer *pstreamer = config->fCompInfo->fStreamer;
349 TVirtualCollectionProxy *proxy = cl->GetCollectionProxy();
350 TClass* vClass = proxy ? proxy->GetValueClass() : 0;
351 UInt_t eoffset = 0; // extra parameter of TStreamerInfo::WriteBufferAux, 0 for all kind of objects writing
352 UInt_t ioffset = eoffset + config->fOffset;
353
354 if (!buf.TestBit(TBuffer::kCannotHandleMemberWiseStreaming)
355 && proxy && vClass
356 && config->fInfo->GetStreamMemberWise()
357 && cl->CanSplit()
358 && !(strspn(config->fCompInfo->fElem->GetTitle(),"||") == 2)
359 && !(vClass->TestBit(TClass::kHasCustomStreamerMember)) ) {
360 // Let's save the collection member-wise.
361
362 UInt_t pos = buf.WriteVersionMemberWise(config->fInfo->IsA(),kTRUE);
363 buf.WriteVersion( vClass, kFALSE );
364
365 // TODO: subinfo used for WriteBufferSTL call, which is private for the moment
366 //TStreamerInfo *subinfo = (TStreamerInfo*)vClass->GetStreamerInfo();
367
368 //for (int k = 0; k < narr; ++k) {
369 char **contp = (char **)((char *)addr + ioffset);
370 for(int j=0;j<config->fCompInfo->fLength;++j) {
371 char *cont = contp[j];
372 TVirtualCollectionProxy::TPushPop helper( proxy, cont );
373 Int_t nobjects = cont ? proxy->Size() : 0;
374 buf << nobjects;
375
376 // TODO: method is private, should be made accesible from here
377 // subinfo->WriteBufferSTL(buf,proxy,nobjects);
378 }
379 //}
380 buf.SetByteCount(pos,kTRUE);
381 return 0;
382 }
383 UInt_t pos = buf.WriteVersion(config->fInfo->IsA(), kTRUE);
384 if (kIsTextT) {
385 // use same method which is used in kSTL
386 buf.WriteFastArray((void **)((char *)addr + ioffset), cl, config->fCompInfo->fLength, kFALSE, pstreamer);
387 } else if (pstreamer == nullptr) {
388 // for (int k = 0; k < narr; ++k) {
389 char **contp = (char **)((char *)addr + ioffset);
390 for (int j = 0; j < config->fCompInfo->fLength; ++j) {
391 char *cont = contp[j];
392 cl->Streamer(cont, buf);
393 }
394 // }
395 } else {
396 // for (int k = 0; k < narr; ++k) {
397 (*pstreamer)(buf, (char *)addr + ioffset, config->fCompInfo->fLength);
398 //}
399 }
400 buf.SetByteCount(pos, kTRUE);
401 return 0;
402 }
403
404
405 /** Direct copy of code from TStreamerInfo::WriteBufferAux,
406 * potentially can be used later for non-text streaming */
407 template<bool kIsTextT>
408 INLINE_TEMPLATE_ARGS Int_t ReadSTLp(TBuffer &buf, void *addr, const TConfiguration *config)
409 {
410 TClass *cle = config->fCompInfo->fClass;
411 TStreamerElement * aElement = (TStreamerElement*) config->fCompInfo->fElem;
412 TMemberStreamer *pstreamer = config->fCompInfo->fStreamer;
413 //TVirtualCollectionProxy *proxy = cl->GetCollectionProxy();
414 //TClass* vClass = proxy ? proxy->GetValueClass() : 0;
415
416 UInt_t eoffset = 0; // extra parameter of TStreamerInfo::WriteBufferAux, 0 for all kind of objects writing
417 UInt_t ioffset = eoffset + config->fOffset;
418
419
420 UInt_t start,count;
421 Version_t vers = buf.ReadVersion(&start, &count, cle);
422
423 if (!kIsTextT && (vers & TBufferFile::kStreamedMemberWise) ) {
424 // Collection was saved member-wise
425
426 vers &= ~( TBufferFile::kStreamedMemberWise );
427
428 TClass *newClass = aElement->GetNewClass();
429 TClass *oldClass = aElement->GetClassPointer();
430 if( vers < 9 && newClass && newClass!=oldClass ) {
431 Error( "ReadBuffer", "Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
432 vers, buf.GetParent() ? buf.GetParent()->GetName() : "memory/socket", oldClass->GetName(), newClass->GetName() );
433 return 0;
434 }
435
436 Version_t vClVersion = 0; // For vers less than 9, we have to use the current version.
437 if( vers >= 9 ) {
438 vClVersion = buf.ReadVersionForMemberWise( cle->GetCollectionProxy()->GetValueClass() );
439 }
440
441 TVirtualCollectionProxy *newProxy = (newClass ? newClass->GetCollectionProxy() : nullptr);
442 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
443 TStreamerInfo *subinfo = nullptr;
444
445 if( newProxy ) {
446 // coverity[dereference] oldProxy->GetValueClass() can not be null since this was streamed memberwise.
447 subinfo = (TStreamerInfo*)newProxy->GetValueClass()->GetConversionStreamerInfo( oldProxy->GetValueClass(), vClVersion );
448 } else {
449 subinfo = (TStreamerInfo*)oldProxy->GetValueClass()->GetStreamerInfo( vClVersion );
450 newProxy = oldProxy;
451 }
452 if (subinfo) {
453 // DOLOOP {
454 void* env;
455 void **contp = (void**)((char *) addr + ioffset);
456 for(int j=0;j<config->fCompInfo->fLength;j++) {
457 void *cont = contp[j];
458 if (cont==nullptr) {
459 contp[j] = cle->New();
460 cont = contp[j];
461 }
462 TVirtualCollectionProxy::TPushPop helper( newProxy, cont );
463 Int_t nobjects;
464 buf >> nobjects;
465 env = newProxy->Allocate(nobjects,true);
466 subinfo->ReadBufferSTL(buf,newProxy,nobjects,/* offset */ 0, vers>=7 );
467 newProxy->Commit(env);
468 }
469 // } // DOLOOP
470 }
471 buf.CheckByteCount(start,count,aElement->GetFullName());
472 return 0;
473 }
474
475 if (kIsTextT) {
476 // use same method which is used in kSTL
477 buf.ReadFastArray((void **)((char *)addr + ioffset), cle, config->fCompInfo->fLength, kFALSE, pstreamer);
478 } else if (pstreamer == nullptr) {
479 // DOLOOP {
480 void **contp = (void **)((char *)addr + ioffset);
481 for (int j = 0; j < config->fCompInfo->fLength; j++) {
482 void *cont = contp[j];
483 if (cont == nullptr) {
484 // int R__n;
485 // b >> R__n;
486 // b.SetOffset(b.GetOffset()-4); // rewind to the start of the int
487 // if (R__n) continue;
488 contp[j] = cle->New();
489 cont = contp[j];
490 }
491 cle->Streamer(cont, buf);
492 }
493 // }
494 } else {
495 (*pstreamer)(buf, (char *)addr + ioffset, config->fCompInfo->fLength);
496 }
497 buf.CheckByteCount(start, count, aElement->GetFullName());
498
499 return 0;
500 }
501
502 /** Direct copy of code from TStreamerInfo::WriteBufferAux,
503 * potentially can be used later for non-text streaming */
504 template<bool kIsTextT>
505 INLINE_TEMPLATE_ARGS Int_t WriteStreamerLoop(TBuffer &buf, void *addr, const TConfiguration *config)
506 {
507 UInt_t eoffset = 0; // extra parameter of TStreamerInfo::WriteBufferAux, 0 for all kind of objects writing
508 UInt_t ioffset = eoffset + config->fOffset;
509
510 if (!kIsTextT && config->fCompInfo->fStreamer) {
511 // Get any private streamer which was set for the data member.
512 TMemberStreamer* pstreamer = config->fCompInfo->fStreamer;
513 // -- We have a private streamer.
514 UInt_t pos = buf.WriteVersion(config->fInfo->IsA(), kTRUE);
515 // Loop over the entries in the clones array or the STL container.
516 //for (int k = 0; k < narr; ++k) {
517 // Get a pointer to the counter for the varying length array.
518 Int_t* counter = (Int_t*) ((char *) addr /*entry pointer*/ + eoffset /*entry offset*/ + config->fCompInfo->fMethod /*counter offset*/);
519
520 // And call the private streamer, passing it the buffer, the object, and the counter.
521 (*pstreamer)(buf, (char *) addr /*entry pointer*/ + ioffset /*object offset*/, *counter);
522 //} for k
523 buf.SetByteCount(pos, kTRUE);
524 // We are done, next streamer element.
525 return 0;
526 }
527
528 // Get the class of the data member.
529 TClass* cl = config->fCompInfo->fClass;
530 // Which are we, an array of objects or an array of pointers to objects?
531 Bool_t isPtrPtr = (strstr(config->fCompInfo->fElem->GetTypeName(), "**") != 0);
532
533 // By default assume the file version is the newest.
534 Int_t fileVersion = kMaxInt;
535
536 if (!kIsTextT) {
537 // At this point we do *not* have a private streamer.
538 // Get the version of the file we are writing to.
539 TFile* file = (TFile*) buf.GetParent();
540 if (file) {
541 fileVersion = file->GetVersion();
542 }
543 }
544 // Write the class version to the buffer.
545 UInt_t pos = buf.WriteVersion(config->fInfo->IsA(), kTRUE);
546 if (fileVersion > 51508) {
547 // -- Newer versions allow polymorphic pointers to objects.
548 // Loop over the entries in the clones array or the STL container.
549 //for (int k = 0; k < narr; ++k) {
550 // Get the counter for the varying length array.
551 Int_t vlen = *((Int_t*) ((char *) addr /*entry pointer*/ + eoffset /*entry offset*/ + config->fCompInfo->fMethod /*counter offset*/));
552
553 //b << vlen;
554 if (vlen) {
555 // Get a pointer to the array of pointers.
556 char** pp = (char**) ((char *) addr /*entry pointer*/ + ioffset /*object offset*/);
557 // Loop over each element of the array of pointers to varying-length arrays.
558 for (Int_t ndx = 0; ndx < config->fCompInfo->fLength; ++ndx) {
559 if (!pp[ndx]) {
560 // -- We do not have a pointer to a varying-length array.
561 // Error("WriteBufferAux", "The pointer to element %s::%s type %d (%s) is null\n", GetName(), aElement->GetFullName(), compinfo[i]->fType, aElement->GetTypeName());
562 // ::ErrorHandler(kError, "::WriteStreamerLoop", Form("The pointer to element %s::%s type %d (%s) is null\n", config->fInfo->GetName(), config->fCompInfo->fElem->GetFullName(), config->fCompInfo->fType, config->fCompInfo->fElem->GetTypeName()));
563 printf("WriteStreamerLoop - The pointer to element %s::%s type %d (%s) is null\n", config->fInfo->GetName(), config->fCompInfo->fElem->GetFullName(), config->fCompInfo->fType, config->fCompInfo->fElem->GetTypeName());
564 continue;
565 }
566 if (!isPtrPtr) {
567 // -- We are a varying-length array of objects.
568 // Write the entire array of objects to the buffer.
569 // Note: Polymorphism is not allowed here.
570 buf.WriteFastArray(pp[ndx], cl, vlen, nullptr);
571 } else {
572 // -- We are a varying-length array of pointers to objects.
573 // Write the entire array of object pointers to the buffer.
574 // Note: The object pointers are allowed to be polymorphic.
575 buf.WriteFastArray((void **)pp[ndx], cl, vlen, kFALSE, nullptr);
576 } // isPtrPtr
577 } // ndx
578 } else // vlen
579 if (kIsTextT) {
580 // special handling for the text-based streamers
581 for (Int_t ndx = 0; ndx < config->fCompInfo->fLength; ++ndx)
582 buf.WriteFastArray((void *)nullptr, cl, -1, nullptr);
583 }
584 //} // k
585 }
586 else {
587 // -- Older versions do *not* allow polymorphic pointers to objects.
588 // Loop over the entries in the clones array or the STL container.
589 //for (int k = 0; k < narr; ++k) {
590 // Get the counter for the varying length array.
591 Int_t vlen = *((Int_t*) ((char *) addr /*entry pointer*/ + eoffset /*entry offset*/ + config->fCompInfo->fMethod /*counter offset*/));
592 //b << vlen;
593 if (vlen) {
594 // Get a pointer to the array of pointers.
595 char** pp = (char**) ((char *) addr /*entry pointer*/ + ioffset /*object offset*/);
596 // -- Older versions do *not* allow polymorphic pointers to objects.
597 // Loop over each element of the array of pointers to varying-length arrays.
598 for (Int_t ndx = 0; ndx < config->fCompInfo->fLength; ++ndx) {
599 if (!pp[ndx]) {
600 // -- We do not have a pointer to a varying-length array.
601 //Error("WriteBufferAux", "The pointer to element %s::%s type %d (%s) is null\n", GetName(), aElement->GetFullName(), compinfo[i]->fType, aElement->GetTypeName());
602 // ::ErrorHandler(kError, "::WriteTextStreamerLoop", Form("The pointer to element %s::%s type %d (%s) is null\n", config->fInfo->GetName(), config->fCompInfo->fElem->GetFullName(), config->fCompInfo->fType, config->fCompInfo->fElem->GetTypeName()));
603 printf("WriteStreamerLoop - The pointer to element %s::%s type %d (%s) is null\n", config->fInfo->GetName(), config->fCompInfo->fElem->GetFullName(), config->fCompInfo->fType, config->fCompInfo->fElem->GetTypeName());
604 continue;
605 }
606 if (!isPtrPtr) {
607 // -- We are a varying-length array of objects.
608 // Loop over the elements of the varying length array.
609 for (Int_t v = 0; v < vlen; ++v) {
610 // Write the object to the buffer.
611 cl->Streamer(pp[ndx] + (v * cl->Size()), buf);
612 } // v
613 }
614 else {
615 // -- We are a varying-length array of pointers to objects.
616 // Loop over the elements of the varying length array.
617 for (Int_t v = 0; v < vlen; ++v) {
618 // Get a pointer to the object pointer.
619 char** r = (char**) pp[ndx];
620 // Write the object to the buffer.
621 cl->Streamer(r[v], buf);
622 } // v
623 } // isPtrPtr
624 } // ndx
625 } // vlen
626 //} // k
627 } // fileVersion
628 // Backpatch the byte count into the buffer.
629 buf.SetByteCount(pos, kTRUE);
630
631 return 0;
632 }
633
634
635 /** Direct copy of code from TStreamerInfo::WriteBufferAux,
636 * potentially can be used later for non-text streaming */
637 template<bool kIsTextT>
638 INLINE_TEMPLATE_ARGS Int_t ReadStreamerLoop(TBuffer &buf, void *addr, const TConfiguration *config)
639 {
640 UInt_t eoffset = 0; // extra parameter of TStreamerInfo::WriteBufferAux, 0 for all kind of objects writing
641 UInt_t ioffset = eoffset + config->fOffset;
642
643 // Get the class of the data member.
644 TClass* cl = config->fCompInfo->fClass;
645
646 // Check for a private streamer.
647 if (!kIsTextT && config->fCompInfo->fStreamer) {
648 // Get any private streamer which was set for the data member.
649 TMemberStreamer* pstreamer = config->fCompInfo->fStreamer;
650 // -- We have a private streamer.
651 // Read the class version and byte count from the buffer.
652 UInt_t start = 0;
653 UInt_t count = 0;
654 buf.ReadVersion(&start, &count, cl);
655 // Loop over the entries in the clones array or the STL container.
656 //for (Int_t k = 0; k < narr; ++k) {
657
658 Int_t* counter = (Int_t*) ((char *) addr /*entry pointer*/ + eoffset /*entry offset*/ + config->fCompInfo->fMethod /*counter offset*/);
659 // And call the private streamer, passing it the buffer, the object, and the counter.
660 (*pstreamer)(buf, (char *) addr /*entry pointer*/ + ioffset /*object offset*/, *counter);
661
662 // } // for k
663 buf.CheckByteCount(start, count, config->fCompInfo->fElem->GetFullName());
664 // We are done, next streamer element.
665 return 0;
666 }
667
668 // Which are we, an array of objects or an array of pointers to objects?
669 Bool_t isPtrPtr = (strstr(config->fCompInfo->fElem->GetTypeName(), "**") != 0);
670
671 // By default assume the file version is the newest.
672 Int_t fileVersion = kMaxInt;
673 if (!kIsTextT) {
674 // At this point we do *not* have a private streamer.
675 // Get the version of the file we are reading from.
676 TFile* file = (TFile*) buf.GetParent();
677 if (file) {
678 fileVersion = file->GetVersion();
679 }
680 }
681 // Read the class version and byte count from the buffer.
682 UInt_t start = 0;
683 UInt_t count = 0;
684 buf.ReadVersion(&start, &count, cl);
685 if (fileVersion > 51508) {
686 // -- Newer versions allow polymorphic pointers.
687 // Loop over the entries in the clones array or the STL container.
688 // for (Int_t k = 0; k < narr; ++k) {
689 // Get the counter for the varying length array.
690 Int_t vlen = *((Int_t *)((char *)addr /*entry pointer*/ + eoffset /*entry offset*/ +
691 config->fCompInfo->fMethod /*counter offset*/));
692 // Int_t realLen;
693 // b >> realLen;
694 // if (realLen != vlen) {
695 // fprintf(stderr, "read vlen: %d realLen: %s\n", vlen, realLen);
696 //}
697 // Get a pointer to the array of pointers.
698 char **pp = (char **)((char *)addr /*entry pointer*/ + ioffset /*object offset*/);
699 // Loop over each element of the array of pointers to varying-length arrays.
700 // if (!pp) {
701 // continue;
702 // }
703
704 if (pp) // SL: place it here instead of continue, which is related to for(k) loop
705 for (Int_t ndx = 0; ndx < config->fCompInfo->fLength; ++ndx) {
706 // if (!pp[ndx]) {
707 // -- We do not have a pointer to a varying-length array.
708 // Error("ReadBuffer", "The pointer to element %s::%s type %d (%s) is null\n", thisVar->GetName(),
709 // aElement->GetFullName(), compinfo[i]->fType, aElement->GetTypeName());
710 // continue;
711 //}
712 // Delete any memory at pp[ndx].
713 if (!isPtrPtr) {
714 cl->DeleteArray(pp[ndx]);
715 pp[ndx] = 0;
716 } else {
717 // Using vlen is wrong here because it has already
718 // been overwritten with the value needed to read
719 // the current record. Fixing this will require
720 // doing a pass over the object at the beginning
721 // of the I/O and releasing all the buffer memory
722 // for varying length arrays before we overwrite
723 // the counter values.
724 //
725 // For now we will just leak memory, just as we
726 // have always done in the past. Fix this.
727 //
728 // char** r = (char**) pp[ndx];
729 // if (r) {
730 // for (Int_t v = 0; v < vlen; ++v) {
731 // cl->Destructor(r[v]);
732 // r[v] = 0;
733 // }
734 //}
735 delete[] pp[ndx];
736 pp[ndx] = 0;
737 }
738 if (!vlen) {
739 if (kIsTextT) {
740 // special handling for the text-based streamers - keep calling to shift array index
741 buf.ReadFastArray((void *)nullptr, cl, -1, nullptr);
742 }
743 continue;
744 }
745 // Note: We now have pp[ndx] is null.
746 // Allocate memory to read into.
747 if (!isPtrPtr) {
748 // -- We are a varying-length array of objects.
749 // Note: Polymorphism is not allowed here.
750 // Allocate a new array of objects to read into.
751 pp[ndx] = (char *)cl->NewArray(vlen);
752 if (!pp[ndx]) {
753 Error("ReadBuffer", "Memory allocation failed!\n");
754 continue;
755 }
756 } else {
757 // -- We are a varying-length array of pointers to objects.
758 // Note: The object pointers are allowed to be polymorphic.
759 // Allocate a new array of pointers to objects to read into.
760 pp[ndx] = (char *)new char *[vlen];
761 if (!pp[ndx]) {
762 Error("ReadBuffer", "Memory allocation failed!\n");
763 continue;
764 }
765 // And set each pointer to null.
766 memset(pp[ndx], 0, vlen * sizeof(char *)); // This is the right size we really have a char**: pp[ndx]
767 // = (char*) new char*[vlen];
768 }
769 if (!isPtrPtr) {
770 // -- We are a varying-length array of objects.
771 buf.ReadFastArray(pp[ndx], cl, vlen, nullptr);
772 } else {
773 // -- We are a varying-length array of object pointers.
774 buf.ReadFastArray((void **)pp[ndx], cl, vlen, kFALSE, nullptr);
775 } // isPtrPtr
776 } // ndx
777 // } // k
778 } else {
779 // -- Older versions do *not* allow polymorphic pointers.
780 // Loop over the entries in the clones array or the STL container.
781 // for (Int_t k = 0; k < narr; ++k) {
782 // Get the counter for the varying length array.
783 Int_t vlen = *((Int_t *)((char *)addr /*entry pointer*/ + eoffset /*entry offset*/ +
784 config->fCompInfo->fMethod /*counter offset*/));
785 // Int_t realLen;
786 // b >> realLen;
787 // if (realLen != vlen) {
788 // fprintf(stderr, "read vlen: %d realLen: %s\n", vlen, realLen);
789 //}
790 // Get a pointer to the array of pointers.
791 char **pp = (char **)((char *)addr /*entry pointer*/ + ioffset /*object offset*/);
792 // if (!pp) {
793 // continue;
794 //}
795
796 if (pp) // SL: place it here instead of continue, which is related to for(k) loop
797
798 // Loop over each element of the array of pointers to varying-length arrays.
799 for (Int_t ndx = 0; ndx < config->fCompInfo->fLength; ++ndx) {
800 // if (!pp[ndx]) {
801 // -- We do not have a pointer to a varying-length array.
802 // Error("ReadBuffer", "The pointer to element %s::%s type %d (%s) is null\n", thisVar->GetName(),
803 // aElement->GetFullName(), compinfo[i]->fType, aElement->GetTypeName());
804 // continue;
805 //}
806 // Delete any memory at pp[ndx].
807 if (!isPtrPtr) {
808 cl->DeleteArray(pp[ndx]);
809 pp[ndx] = 0;
810 } else {
811 // Using vlen is wrong here because it has already
812 // been overwritten with the value needed to read
813 // the current record. Fixing this will require
814 // doing a pass over the object at the beginning
815 // of the I/O and releasing all the buffer memory
816 // for varying length arrays before we overwrite
817 // the counter values.
818 //
819 // For now we will just leak memory, just as we
820 // have always done in the past. Fix this.
821 //
822 // char** r = (char**) pp[ndx];
823 // if (r) {
824 // for (Int_t v = 0; v < vlen; ++v) {
825 // cl->Destructor(r[v]);
826 // r[v] = 0;
827 // }
828 //}
829 delete[] pp[ndx];
830 pp[ndx] = 0;
831 }
832 if (!vlen) {
833 continue;
834 }
835 // Note: We now have pp[ndx] is null.
836 // Allocate memory to read into.
837 if (!isPtrPtr) {
838 // -- We are a varying-length array of objects.
839 // Note: Polymorphism is not allowed here.
840 // Allocate a new array of objects to read into.
841 pp[ndx] = (char *)cl->NewArray(vlen);
842 if (!pp[ndx]) {
843 Error("ReadBuffer", "Memory allocation failed!\n");
844 continue;
845 }
846 } else {
847 // -- We are a varying-length array of pointers to objects.
848 // Note: The object pointers are allowed to be polymorphic.
849 // Allocate a new array of pointers to objects to read into.
850 pp[ndx] = (char *)new char *[vlen];
851 if (!pp[ndx]) {
852 Error("ReadBuffer", "Memory allocation failed!\n");
853 continue;
854 }
855 // And set each pointer to null.
856 memset(pp[ndx], 0, vlen * sizeof(char *)); // This is the right size we really have a char**: pp[ndx]
857 // = (char*) new char*[vlen];
858 }
859 if (!isPtrPtr) {
860 // -- We are a varying-length array of objects.
861 // Loop over the elements of the varying length array.
862 for (Int_t v = 0; v < vlen; ++v) {
863 // Read the object from the buffer.
864 cl->Streamer(pp[ndx] + (v * cl->Size()), buf);
865 } // v
866 } else {
867 // -- We are a varying-length array of object pointers.
868 // Get a pointer to the object pointer array.
869 char **r = (char **)pp[ndx];
870 // Loop over the elements of the varying length array.
871 for (Int_t v = 0; v < vlen; ++v) {
872 // Allocate an object to read into.
873 r[v] = (char *)cl->New();
874 if (!r[v]) {
875 // Do not print a second error message here.
876 // Error("ReadBuffer", "Memory allocation failed!\n");
877 continue;
878 }
879 // Read the object from the buffer.
880 cl->Streamer(r[v], buf);
881 } // v
882 } // isPtrPtr
883 } // ndx
884 // } // k
885 } // fileVersion
886 buf.CheckByteCount(start, count, config->fCompInfo->fElem->GetFullName());
887 return 0;
888 }
889
890 class TConfWithFactor : public TConfiguration {
891 // Configuration object for the Float16/Double32 where a factor has been specified.
892 public:
893 Double_t fFactor;
894 Double_t fXmin;
895 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) {};
896 TConfiguration *Copy() override { return new TConfWithFactor(*this); }
897 };
898
899 template <typename T>
900 INLINE_TEMPLATE_ARGS Int_t ReadBasicType_WithFactor(TBuffer &buf, void *addr, const TConfiguration *config)
901 {
902 // Stream a Float16 or Double32 where a factor has been specified.
903 //a range was specified. We read an integer and convert it back to a double.
904
905 TConfWithFactor *conf = (TConfWithFactor *)config;
906 buf.ReadWithFactor((T*)( ((char*)addr) + config->fOffset ), conf->fFactor, conf->fXmin);
907 return 0;
908 }
909
910 class TConfNoFactor : public TConfiguration {
911 // Configuration object for the Float16/Double32 where a factor has been specified.
912 public:
913 Int_t fNbits;
914 TConfNoFactor(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, Int_t nbits) : TConfiguration(info,id,compinfo,offset),fNbits(nbits) {};
915 TConfiguration *Copy() override { return new TConfNoFactor(*this); }
916 };
917
918 template <typename T>
919 INLINE_TEMPLATE_ARGS Int_t ReadBasicType_NoFactor(TBuffer &buf, void *addr, const TConfiguration *config)
920 {
921 // Stream a Float16 or Double32 where a factor has not been specified.
922
923 TConfNoFactor *conf = (TConfNoFactor *)config;
924 Int_t nbits = conf->fNbits;
925
926 buf.ReadWithNbits( (T*)( ((char*)addr) + config->fOffset ), nbits );
927 return 0;
928 }
929
930 INLINE_TEMPLATE_ARGS Int_t ReadTString(TBuffer &buf, void *addr, const TConfiguration *config)
931 {
932 // Read in a TString object.
933
934 // Idea: We could separate the TString Streamer in its two parts and
935 // avoid the if (buf.IsReading()) and try having it inlined.
936 ((TString*)(((char*)addr)+config->fOffset))->TString::Streamer(buf);
937 return 0;
938 }
939
940 INLINE_TEMPLATE_ARGS Int_t ReadTObject(TBuffer &buf, void *addr, const TConfiguration *config)
941 {
942 // Read in a TObject object part.
943
944 // Idea: We could separate the TObject Streamer in its two parts and
945 // avoid the if (buf.IsReading()).
946 ((TObject*)(((char*)addr)+config->fOffset))->TObject::Streamer(buf);
947 return 0;
948 }
949
950 INLINE_TEMPLATE_ARGS Int_t ReadTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
951 {
952 // Read in a TNamed object part.
953 // Since the TNamed streamer is solely delegating back to the StreamerInfo we
954 // can skip the streamer.
955
956 // Idea: We could extract the code from ReadClassBuffer and avoid one function
957 // code.
958 static const TClass *TNamed_cl = TNamed::Class();
959 return buf.ReadClassBuffer(TNamed_cl,(((char*)addr)+config->fOffset));
960 }
961
962 class TConfigSTL : public TConfiguration {
963 // Configuration object for the kSTL case
964 private:
965 void Init() {
966 TVirtualCollectionProxy *proxy = fNewClass->GetCollectionProxy();
967 if (proxy) {
968 fCreateIterators = proxy->GetFunctionCreateIterators();
969 fCreateWriteIterators = proxy->GetFunctionCreateIterators(kFALSE);
970 fCopyIterator = proxy->GetFunctionCopyIterator();
971 fDeleteIterator = proxy->GetFunctionDeleteIterator();
972 fDeleteTwoIterators = proxy->GetFunctionDeleteTwoIterators();
973 }
974 }
975
976 public:
977 TClass *fOldClass; // Class of the content on file
978 TClass *fNewClass; // Class of the content in memory.
979 TMemberStreamer *fStreamer;
980 const char *fTypeName; // Type name of the member as typed by ther user.
981 Bool_t fIsSTLBase; // aElement->IsBase() && aElement->IsA()!=TStreamerBase::Class()
982
983 TVirtualCollectionProxy::CreateIterators_t fCreateIterators;
984 TVirtualCollectionProxy::CreateIterators_t fCreateWriteIterators;
985 TVirtualCollectionProxy::CopyIterator_t fCopyIterator;
986 TVirtualCollectionProxy::DeleteIterator_t fDeleteIterator;
987 TVirtualCollectionProxy::DeleteTwoIterators_t fDeleteTwoIterators;
988
989 TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, const char *type_name, Bool_t isbase) :
990 TConfiguration(info,id,compinfo,offset,length), fOldClass(oldClass), fNewClass(oldClass), fStreamer(0), fTypeName(type_name), fIsSTLBase(isbase),
991 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) { Init(); }
992
993 TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TClass *newClass, const char *type_name, Bool_t isbase) :
994 TConfiguration(info,id,compinfo,offset,length), fOldClass(oldClass), fNewClass(newClass), fStreamer(0), fTypeName(type_name), fIsSTLBase(isbase),
995 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) { Init(); }
996
997 TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TMemberStreamer* streamer, const char *type_name, Bool_t isbase) :
998 TConfiguration(info,id,compinfo,offset,length), fOldClass(oldClass), fNewClass(oldClass), fStreamer(streamer), fTypeName(type_name), fIsSTLBase(isbase),
999 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) { Init(); }
1000
1001 TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TClass *newClass, TMemberStreamer* streamer, const char *type_name, Bool_t isbase) :
1002 TConfiguration(info,id,compinfo,offset,length), fOldClass(oldClass), fNewClass(newClass), fStreamer(streamer), fTypeName(type_name), fIsSTLBase(isbase),
1003 fCreateIterators(0), fCopyIterator(0), fDeleteIterator(0), fDeleteTwoIterators(0) { Init(); }
1004
1005 TConfiguration *Copy() override { return new TConfigSTL(*this); }
1006 };
1007
1008 class TConfSTLWithFactor : public TConfigSTL {
1009 // Configuration object for the Float16/Double32 where a factor has been specified.
1010 public:
1011 Double_t fFactor;
1012 Double_t fXmin;
1013 TConfSTLWithFactor(TConfigSTL *orig, Double_t factor, Double_t xmin) : TConfigSTL(*orig),fFactor(factor),fXmin(xmin) {};
1014 TConfiguration *Copy() override { return new TConfSTLWithFactor(*this); }
1015 };
1016
1017 class TConfSTLNoFactor : public TConfigSTL {
1018 // Configuration object for the Float16/Double32 where a factor has been specified.
1019 public:
1020 Int_t fNbits;
1021 TConfSTLNoFactor(TConfigSTL *orig, Int_t nbits) : TConfigSTL(*orig),fNbits(nbits) {};
1022 TConfiguration *Copy() override { return new TConfSTLNoFactor(*this); }
1023 };
1024
1025 class TVectorLoopConfig : public TLoopConfiguration {
1026 // Base class of the Configurations used in member wise streaming.
1027 protected:
1028 public:
1029 Long_t fIncrement; // Either a value to increase the cursor by and
1030 public:
1031 TVectorLoopConfig(TVirtualCollectionProxy *proxy, Long_t increment, Bool_t /* read */) : TLoopConfiguration(proxy), fIncrement(increment) {};
1032 //virtual void PrintDebug(TBuffer &buffer, void *);
1033 ~TVectorLoopConfig() override {};
1034 void Print() const override
1035 {
1036 printf("TVectorLoopConfig: increment=%ld\n",fIncrement);
1037 }
1038
1039 void* GetFirstAddress(void *start, const void * /* end */) const override
1040 {
1041 // Return the address of the first element of the collection.
1042
1043 return start;
1044 }
1045
1046 TLoopConfiguration* Copy() const override { return new TVectorLoopConfig(*this); }
1047 };
1048
1049 class TAssocLoopConfig : public TLoopConfiguration {
1050 // Base class of the Configurations used in member wise streaming.
1051 public:
1052 TAssocLoopConfig(TVirtualCollectionProxy *proxy, Bool_t /* read */) : TLoopConfiguration(proxy) {};
1053 //virtual void PrintDebug(TBuffer &buffer, void *);
1054 ~TAssocLoopConfig() override {};
1055 void Print() const override
1056 {
1057 printf("TAssocLoopConfig: proxy=%s\n",fProxy->GetCollectionClass()->GetName());
1058 }
1059 TLoopConfiguration* Copy() const override { return new TAssocLoopConfig(*this); }
1060
1061 void* GetFirstAddress(void *start, const void * /* end */) const override
1062 {
1063 // Return the address of the first element of the collection.
1064
1065 R__ASSERT(0);
1066// char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
1067// void *iter = genloopconfig->fCopyIterator(&iterator,start_collection);
1068// arr0 = genloopconfig->fNext(iter,end_collection);
1069// if (iter != &iterator[0]) {
1070// genloopconfig->fDeleteIterator(iter);
1071// }
1072 return start;
1073 }
1074 };
1075
1076 class TGenericLoopConfig : public TLoopConfiguration {
1077 // Configuration object for the generic case of member wise streaming looping.
1078 private:
1079 void Init(Bool_t read) {
1080 if (fProxy) {
1081 if (fProxy->HasPointers()) {
1082 fNext = TVirtualCollectionPtrIterators::Next;
1083 fCopyIterator = TVirtualCollectionPtrIterators::CopyIterator;
1084 fDeleteIterator = TVirtualCollectionPtrIterators::DeleteIterator;
1085 } else {
1086 fNext = fProxy->GetFunctionNext(read);
1087 fCopyIterator = fProxy->GetFunctionCopyIterator(read);
1088 fDeleteIterator = fProxy->GetFunctionDeleteIterator(read);
1089 }
1090 }
1091 }
1092 public:
1093 TVirtualCollectionProxy::Next_t fNext;
1094 TVirtualCollectionProxy::CopyIterator_t fCopyIterator;
1095 TVirtualCollectionProxy::DeleteIterator_t fDeleteIterator;
1096
1097 TGenericLoopConfig(TVirtualCollectionProxy *proxy, Bool_t read) : TLoopConfiguration(proxy), fNext(0), fCopyIterator(0), fDeleteIterator(0)
1098 {
1099 Init(read);
1100 }
1101 ~TGenericLoopConfig() override {};
1102 void Print() const override
1103 {
1104 printf("TGenericLoopConfig: proxy=%s\n",fProxy->GetCollectionClass()->GetName());
1105 }
1106 TLoopConfiguration* Copy() const override { return new TGenericLoopConfig(*this); }
1107
1108 void* GetFirstAddress(void *start_collection, const void *end_collection) const override
1109 {
1110 // Return the address of the first element of the collection.
1111
1112 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
1113 void *iter = fCopyIterator(&iterator,start_collection);
1114 void *arr0 = fNext(iter,end_collection);
1115 if (iter != &iterator[0]) {
1116 fDeleteIterator(iter);
1117 }
1118 return arr0;
1119 }
1120 };
1121
1122 INLINE_TEMPLATE_ARGS void ReadSTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
1123 {
1124 // Collection was saved member-wise
1125
1126 TConfigSTL *config = (TConfigSTL*)conf;
1127 vers &= ~( TBufferFile::kStreamedMemberWise );
1128
1129 if( vers >= 8 ) {
1130
1131 TClass *oldClass = config->fOldClass;
1132
1133 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1134 if (!oldProxy) {
1135 // Missing information, broken file ... give up
1136 return;
1137 }
1138 TClass *valueClass = oldProxy->GetValueClass();
1139 Version_t vClVersion = buf.ReadVersionForMemberWise( valueClass );
1140
1141 TVirtualCollectionProxy::TPushPop helper( oldProxy, (char*)addr );
1142 Int_t nobjects;
1143 buf.ReadInt(nobjects);
1144 void* alternative = oldProxy->Allocate(nobjects,true);
1145 if (nobjects) {
1146 TActionSequence *actions = oldProxy->GetReadMemberWiseActions( vClVersion );
1147
1148 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1149 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1150 void *begin = &(startbuf[0]);
1151 void *end = &(endbuf[0]);
1152 config->fCreateIterators(alternative, &begin, &end, oldProxy);
1153 // We can not get here with a split vector of pointer, so we can indeed assume
1154 // that actions->fConfiguration != null.
1155 buf.ApplySequence(*actions, begin, end);
1156 if (begin != &(startbuf[0])) {
1157 // assert(end != endbuf);
1158 config->fDeleteTwoIterators(begin,end);
1159 }
1160 }
1161 oldProxy->Commit(alternative);
1162
1163 } else {
1164
1165 TClass *oldClass = config->fOldClass;
1166
1167 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1168 if (!oldProxy) {
1169 // Missing information, broken file ... give up
1170 return;
1171 }
1172
1173 TVirtualCollectionProxy::TPushPop helper( oldProxy, (char*)addr );
1174 Int_t nobjects;
1175 buf.ReadInt(nobjects);
1176 void* env = oldProxy->Allocate(nobjects,true);
1177
1178 if (nobjects || vers < 7 ) {
1179 // coverity[dereference] since this is a member streaming action by definition the collection contains objects.
1180 TStreamerInfo *subinfo = (TStreamerInfo*)oldProxy->GetValueClass()->GetStreamerInfo( 0 );
1181
1182 subinfo->ReadBufferSTL(buf, oldProxy, nobjects, /* offset */ 0, /* v7 */ kFALSE);
1183 }
1184 oldProxy->Commit(env);
1185 }
1186 }
1187
1188 INLINE_TEMPLATE_ARGS void ReadArraySTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
1189 {
1190 // Collection was saved member-wise
1191
1192 TConfigSTL *config = (TConfigSTL*)conf;
1193 vers &= ~( TBufferFile::kStreamedMemberWise );
1194
1195 if( vers >= 8 ) {
1196
1197 TClass *oldClass = config->fOldClass;
1198
1199 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1200 if (!oldProxy) {
1201 // Missing information, broken file ... give up
1202 return;
1203 }
1204 TClass *valueClass = oldProxy->GetValueClass();
1205 Version_t vClVersion = buf.ReadVersionForMemberWise( valueClass );
1206
1207 TActionSequence *actions = oldProxy->GetReadMemberWiseActions( vClVersion );
1208
1209 int objectSize = oldClass->Size();
1210 char *obj = (char*)addr;
1211 char *endobj = obj + conf->fLength*objectSize;
1212
1213 for(; obj<endobj; obj+=objectSize) {
1214 Int_t nobjects;
1215 buf.ReadInt(nobjects);
1216 TVirtualCollectionProxy::TPushPop helper( oldProxy, (char*)obj );
1217 void* alternative = oldProxy->Allocate(nobjects,true);
1218 if (nobjects) {
1219 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1220 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1221 void *begin = &(startbuf[0]);
1222 void *end = &(endbuf[0]);
1223 config->fCreateIterators(alternative, &begin, &end, oldProxy);
1224 // We can not get here with a split vector of pointer, so we can indeed assume
1225 // that actions->fConfiguration != null.
1226 buf.ApplySequence(*actions, begin, end);
1227 if (begin != &(startbuf[0])) {
1228 // assert(end != endbuf);
1229 config->fDeleteTwoIterators(begin,end);
1230 }
1231 }
1232 oldProxy->Commit(alternative);
1233 }
1234
1235 } else {
1236
1237 TClass *oldClass = config->fOldClass;
1238
1239 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1240 if (!oldProxy) {
1241 // Missing information, broken file ... give up
1242 return;
1243 }
1244
1245 int objectSize = oldClass->Size();
1246 char *obj = (char*)addr;
1247 char *endobj = obj + conf->fLength*objectSize;
1248
1249 for(; obj<endobj; obj+=objectSize) {
1250 TVirtualCollectionProxy::TPushPop helper( oldProxy, (char*)obj );
1251 Int_t nobjects;
1252 buf.ReadInt(nobjects);
1253 void* env = oldProxy->Allocate(nobjects,true);
1254
1255 if (nobjects || vers < 7 ) {
1256 // coverity[dereference] since this is a member streaming action by definition the collection contains objects.
1257 TStreamerInfo *subinfo = (TStreamerInfo*)oldProxy->GetValueClass()->GetStreamerInfo( 0 );
1258
1259 subinfo->ReadBufferSTL(buf, oldProxy, nobjects, /* offset */ 0, /* v7 */ kFALSE);
1260 }
1261 oldProxy->Commit(env);
1262 }
1263 }
1264 }
1265
1266 INLINE_TEMPLATE_ARGS void ReadSTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
1267 {
1268 // Collection was saved member-wise
1269
1270 TConfigSTL *config = (TConfigSTL*)conf;
1271
1272 vers &= ~( TBufferFile::kStreamedMemberWise );
1273
1274 TClass *newClass = config->fNewClass;
1275 TClass *oldClass = config->fOldClass;
1276
1277 if( vers < 8 ) {
1278 Error( "ReadSTLMemberWiseChangedClass", "Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1279 vers, buf.GetParent() ? buf.GetParent()->GetName() : "memory/socket", oldClass->GetName(), newClass->GetName() );
1280 } else {
1281
1282 Version_t vClVersion = buf.ReadVersionForMemberWise( oldClass->GetCollectionProxy()->GetValueClass() );
1283
1284 TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();
1285 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1286
1287 TVirtualCollectionProxy::TPushPop helper( newProxy, (char*)addr );
1288 Int_t nobjects;
1289 buf.ReadInt(nobjects);
1290 void* alternative = newProxy->Allocate(nobjects,true);
1291 if (nobjects) {
1292 TActionSequence *actions = newProxy->GetConversionReadMemberWiseActions( oldProxy->GetValueClass(), vClVersion );
1293 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1294 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1295 void *begin = &(startbuf[0]);
1296 void *end = &(endbuf[0]);
1297 config->fCreateIterators( alternative, &begin, &end, newProxy);
1298 // We can not get here with a split vector of pointer, so we can indeed assume
1299 // that actions->fConfiguration != null.
1300 buf.ApplySequence(*actions, begin, end);
1301 if (begin != &(startbuf[0])) {
1302 // assert(end != endbuf);
1303 config->fDeleteTwoIterators(begin,end);
1304 }
1305 }
1306 newProxy->Commit(alternative);
1307 }
1308 }
1309
1310 INLINE_TEMPLATE_ARGS void ReadArraySTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
1311 {
1312 // Collection was saved member-wise
1313
1314 TConfigSTL *config = (TConfigSTL*)conf;
1315
1316 vers &= ~( TBufferFile::kStreamedMemberWise );
1317
1318 TClass *newClass = config->fNewClass;
1319 TClass *oldClass = config->fOldClass;
1320
1321 if( vers < 8 ) {
1322 Error( "ReadSTLMemberWiseChangedClass", "Unfortunately, version %d of TStreamerInfo (used in %s) did not record enough information to convert a %s into a %s.",
1323 vers, buf.GetParent() ? buf.GetParent()->GetName() : "memory/socket", oldClass->GetName(), newClass->GetName() );
1324 } else {
1325
1326 Version_t vClVersion = buf.ReadVersionForMemberWise( oldClass->GetCollectionProxy()->GetValueClass() );
1327
1328 TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();
1329 TVirtualCollectionProxy *oldProxy = oldClass->GetCollectionProxy();
1330
1331 int objectSize = newClass->Size();
1332 char *obj = (char*)addr;
1333 char *endobj = obj + conf->fLength*objectSize;
1334
1335 for(; obj<endobj; obj+=objectSize) {
1336 TVirtualCollectionProxy::TPushPop helper( newProxy, (char*)obj );
1337 Int_t nobjects;
1338 buf.ReadInt(nobjects);
1339 void* alternative = newProxy->Allocate(nobjects,true);
1340 if (nobjects) {
1341 TActionSequence *actions = newProxy->GetConversionReadMemberWiseActions( oldProxy->GetValueClass(), vClVersion );
1342 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1343 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
1344 void *begin = &(startbuf[0]);
1345 void *end = &(endbuf[0]);
1346 config->fCreateIterators( alternative, &begin, &end, newProxy);
1347 // We can not get here with a split vector of pointer, so we can indeed assume
1348 // that actions->fConfiguration != null.
1349 buf.ApplySequence(*actions, begin, end);
1350 if (begin != &(startbuf[0])) {
1351 // assert(end != endbuf);
1352 config->fDeleteTwoIterators(begin,end);
1353 }
1354 }
1355 newProxy->Commit(alternative);
1356 }
1357 }
1358 }
1359
1360 INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseFastArray(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t /* vers */, UInt_t /* start */)
1361 {
1362 TConfigSTL *config = (TConfigSTL*)conf;
1363 // Idea: This needs to be unrolled, it currently calls the TGenCollectionStreamer ....
1364 buf.ReadFastArray(addr,config->fNewClass,conf->fLength,(TMemberStreamer*)0,config->fOldClass);
1365 }
1366 INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseStreamer(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t /* vers */, UInt_t /* start */)
1367 {
1368 TConfigSTL *config = (TConfigSTL*)conf;
1369 (*config->fStreamer)(buf,addr,conf->fLength);
1370 }
1371 INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseFastArrayV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
1372 {
1373 // case of old TStreamerInfo
1374
1375 TConfigSTL *config = (TConfigSTL*)conf;
1376 // Backward compatibility. Some TStreamerElement's where without
1377 // Streamer but were not removed from element list
1378 if (config->fIsSTLBase || vers == 0) {
1379 buf.SetBufferOffset(start); //there is no byte count
1380 }
1381 // Idea: This needs to be unrolled, it currently calls the TGenCollectionStreamer ....
1382 buf.ReadFastArray(addr,config->fNewClass,conf->fLength,(TMemberStreamer*)0,config->fOldClass);
1383 }
1384 INLINE_TEMPLATE_ARGS void ReadSTLObjectWiseStreamerV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
1385 {
1386 // case of old TStreamerInfo
1387
1388 TConfigSTL *config = (TConfigSTL*)conf;
1389 // Backward compatibility. Some TStreamerElement's where without
1390 // Streamer but were not removed from element list
1391 if (config->fIsSTLBase || vers == 0) {
1392 buf.SetBufferOffset(start); //there is no byte count
1393 }
1394 (*config->fStreamer)(buf,addr,conf->fLength);
1395 }
1396
1397 template <void (*memberwise)(TBuffer&,void *,const TConfiguration*, Version_t),
1398 void (*objectwise)(TBuffer&,void *,const TConfiguration*, Version_t, UInt_t)>
1399 INLINE_TEMPLATE_ARGS Int_t ReadSTL(TBuffer &buf, void *addr, const TConfiguration *conf)
1400 {
1401 TConfigSTL *config = (TConfigSTL*)conf;
1402 UInt_t start, count;
1403 Version_t vers = buf.ReadVersion(&start, &count, config->fOldClass);
1404 if ( vers & TBufferFile::kStreamedMemberWise ) {
1405 memberwise(buf,((char*)addr)+config->fOffset,config, vers);
1406 } else {
1407 objectwise(buf,((char*)addr)+config->fOffset,config, vers, start);
1408 }
1409 buf.CheckByteCount(start,count,config->fTypeName);
1410 return 0;
1411 }
1412
1413 template <typename From, typename To>
1414 struct ConvertBasicType {
1415 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
1416 {
1417 // Simple conversion from a 'From' on disk to a 'To' in memory.
1418 From temp;
1419 buf >> temp;
1420 *(To*)( ((char*)addr) + config->fOffset ) = (To)temp;
1421 return 0;
1422 }
1423 };
1424
1425 template <typename To>
1426 struct ConvertBasicType<BitsMarker,To> {
1427 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
1428 {
1429 // Simple conversion from a 'From' on disk to a 'To' in memory
1430 UInt_t temp;
1431 buf >> temp;
1432
1433 if ((temp & kIsReferenced) != 0) {
1434 HandleReferencedTObject(buf,addr,config);
1435 }
1436
1437 *(To*)( ((char*)addr) + config->fOffset ) = (To)temp;
1438 return 0;
1439 }
1440 };
1441
1442 template <typename From, typename To>
1443 struct ConvertBasicType<WithFactorMarker<From>,To> {
1444 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
1445 {
1446 // Simple conversion from a 'From' on disk to a 'To' in memory.
1447 TConfWithFactor *conf = (TConfWithFactor *)config;
1448 From temp;
1449 buf.ReadWithFactor(&temp, conf->fFactor, conf->fXmin);
1450 *(To*)( ((char*)addr) + config->fOffset ) = (To)temp;
1451 return 0;
1452 }
1453 };
1454
1455 template <typename From, typename To>
1456 struct ConvertBasicType<NoFactorMarker<From>,To> {
1457 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
1458 {
1459 // Simple conversion from a 'From' on disk to a 'To' in memory.
1460 TConfNoFactor *conf = (TConfNoFactor *)config;
1461 From temp;
1462 buf.ReadWithNbits(&temp, conf->fNbits);
1463 *(To*)( ((char*)addr) + config->fOffset ) = (To)temp;
1464 return 0;
1465 }
1466 };
1467
1468 class TConfigurationPushDataCache : public TConfiguration {
1469 // Configuration object for the PushDataCache case.
1470 public:
1471 TVirtualArray *fOnfileObject;
1472
1473 TConfigurationPushDataCache(TVirtualStreamerInfo *info, TVirtualArray *onfileObject, Int_t offset) :
1474 TConfiguration(info, -1, nullptr, offset), fOnfileObject(onfileObject)
1475 {}
1476
1477 void Print() const override
1478 {
1479 TStreamerInfo *info = (TStreamerInfo*)fInfo;
1480 if (fOnfileObject)
1481 printf("StreamerInfoAction, class:%s, PushDataCache offset=%d\n",
1482 info->GetClass()->GetName(), fOffset);
1483 else
1484 printf("StreamerInfoAction, class:%s, PopDataCache offset=%d\n",
1485 info->GetClass()->GetName(), fOffset);
1486 }
1487 void PrintDebug(TBuffer &buffer, void *object) const override
1488 {
1489 if (gDebug > 1) {
1490 TStreamerInfo *info = (TStreamerInfo*)fInfo;
1491 printf("StreamerInfoAction, class:%s, %sDataCache, bufpos=%d, arr=%p, offset=%d, onfileObject=%p\n",
1492 info->GetClass()->GetName(), fOnfileObject ? "Push" : "Pop", buffer.Length(), object, fOffset, fOnfileObject);
1493
1494 }
1495 }
1496 };
1497
1498 Int_t PushDataCache(TBuffer &b, void *, const TConfiguration *conf)
1499 {
1500 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1501 auto onfileObject = config->fOnfileObject;
1502
1503 // onfileObject->SetSize(1);
1504 b.PushDataCache( onfileObject );
1505
1506 return 0;
1507 }
1508
1509 Int_t PushDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *conf)
1510 {
1511 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1512 auto onfileObject = config->fOnfileObject;
1513
1514 // onfileObject->SetSize(n);
1515 b.PushDataCache( onfileObject );
1516
1517 return 0;
1518 }
1519
1520 Int_t PushDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
1521 {
1522 TConfigurationPushDataCache *config = (TConfigurationPushDataCache*)conf;
1523 auto onfileObject = config->fOnfileObject;
1524
1525 TVirtualCollectionProxy *proxy = ((TGenericLoopConfig*)loopconfig)->fProxy;
1526 UInt_t n = proxy->Size();
1527
1528 onfileObject->SetSize(n);
1529 b.PushDataCache( onfileObject );
1530
1531 return 0;
1532 }
1533
1534 Int_t PopDataCache(TBuffer &b, void *, const TConfiguration *)
1535 {
1536 b.PopDataCache();
1537 return 0;
1538 }
1539
1540 Int_t PopDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *)
1541 {
1542 b.PopDataCache();
1543 return 0;
1544 }
1545
1546 Int_t PopDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *, const TConfiguration *)
1547 {
1548 b.PopDataCache();
1549 return 0;
1550 }
1551
1552 class TConfigurationUseCache : public TConfiguration {
1553 // Configuration object for the UseCache case.
1554 public:
1555 TConfiguredAction fAction;
1556 Bool_t fNeedRepeat;
1557
1558 TConfigurationUseCache(TVirtualStreamerInfo *info, TConfiguredAction &action, Bool_t repeat) :
1559 TConfiguration(info,action.fConfiguration->fElemId,action.fConfiguration->fCompInfo,action.fConfiguration->fOffset),fAction(action),fNeedRepeat(repeat) {};
1560 void PrintDebug(TBuffer &b, void *addr) const override
1561 {
1562 if (gDebug > 1) {
1563 // Idea: We should print the name of the action function.
1564 TStreamerInfo *info = (TStreamerInfo*)fInfo;
1565 TStreamerElement *aElement = fCompInfo->fElem;
1566 fprintf(stdout,"StreamerInfoAction, class:%s, name=%s, fType[%d]=%d,"
1567 " %s, bufpos=%d, arr=%p, eoffset=%d, Redirect=%p\n",
1568 info->GetClass()->GetName(),aElement->GetName(),fElemId,fCompInfo->fType,
1569 aElement->ClassName(),b.Length(),addr, 0,b.PeekDataCache() ? b.PeekDataCache()->GetObjectAt(0) : 0);
1570 }
1571
1572 }
1573 ~TConfigurationUseCache() override {}
1574 TConfiguration *Copy() override
1575 {
1576 TConfigurationUseCache *copy = new TConfigurationUseCache(*this);
1577 fAction.fConfiguration = copy->fAction.fConfiguration->Copy(); // since the previous allocation did a 'move' of fAction we need to fix it.
1578 return copy;
1579 }
1580 };
1581
1582 INLINE_TEMPLATE_ARGS Int_t UseCache(TBuffer &b, void *addr, const TConfiguration *conf)
1583 {
1584 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1585
1586 Int_t bufpos = b.Length();
1587 TVirtualArray *cached = b.PeekDataCache();
1588 if (cached==0) {
1589 TStreamerElement *aElement = conf->fCompInfo->fElem;
1590 TStreamerInfo *info = (TStreamerInfo*)conf->fInfo;
1591 Warning("ReadBuffer","Skipping %s::%s because the cache is missing.",info->GetName(),aElement->GetName());
1592 char *ptr = (char*)addr;
1593 info->ReadBufferSkip(b,&ptr,config->fCompInfo,config->fCompInfo->fType+TStreamerInfo::kSkip,aElement,1,0);
1594 } else {
1595 config->fAction(b, (*cached)[0]);
1596 }
1597 // Idea: Factor out this 'if' to a UseCacheRepeat function
1598 if (config->fNeedRepeat) {
1599 b.SetBufferOffset(bufpos);
1600 }
1601 return 0;
1602 }
1603
1604 INLINE_TEMPLATE_ARGS Int_t UseCacheVectorPtrLoop(TBuffer &b, void *start, const void *end, const TConfiguration *conf)
1605 {
1606 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1607 Int_t bufpos = b.Length();
1608
1609 TVirtualArray *cached = b.PeekDataCache();
1610 if (cached==0) {
1611 TStreamerElement *aElement = config->fCompInfo->fElem;
1612 TStreamerInfo *info = (TStreamerInfo*)config->fInfo;
1613 Warning("ReadBuffer","Skipping %s::%s because the cache is missing.",info->GetName(),aElement->GetName());
1614 char *ptr = (char*)start;
1615 UInt_t n = (((void**)end)-((void**)start));
1616 info->ReadBufferSkip(b,&ptr,config->fCompInfo,conf->fCompInfo->fType+TStreamerInfo::kSkip,aElement,n,0);
1617 } else {
1618 TVectorLoopConfig cached_config( nullptr, cached->fClass->Size(), /* read */ kTRUE );
1619 void *cached_start = (*cached)[0];
1620 void *cached_end = ((char*)cached_start) + cached->fSize * cached_config.fIncrement;
1621 config->fAction(b,cached_start,cached_end,&cached_config);
1622 }
1623 // Idea: Factor out this 'if' to a UseCacheRepeat function
1624 if (config->fNeedRepeat) {
1625 b.SetBufferOffset(bufpos);
1626 }
1627 return 0;
1628 }
1629
1630 INLINE_TEMPLATE_ARGS Int_t UseCacheVectorLoop(TBuffer &b, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf)
1631 {
1632 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1633
1634 Int_t bufpos = b.Length();
1635 TVirtualArray *cached = b.PeekDataCache();
1636 if (cached==0) {
1637 TStreamerElement *aElement = config->fCompInfo->fElem;
1638 TStreamerInfo *info = (TStreamerInfo*)config->fInfo;
1639 Warning("ReadBuffer","Skipping %s::%s because the cache is missing.",info->GetName(),aElement->GetName());
1640 char *ptr = (char*)start;
1641 UInt_t n = (((char*)end)-((char*)start))/((TVectorLoopConfig*)loopconf)->fIncrement;
1642 info->ReadBufferSkip(b,&ptr,config->fCompInfo,config->fCompInfo->fType+TStreamerInfo::kSkip,aElement,n,0);
1643 } else {
1644 TVectorLoopConfig cached_config( nullptr, cached->fClass->Size(), /* read */ kTRUE );
1645 void *cached_start = (*cached)[0];
1646 void *cached_end = ((char*)cached_start) + cached->fSize * cached_config.fIncrement;
1647 config->fAction(b,cached_start,cached_end,&cached_config);
1648 }
1649 // Idea: Factor out this 'if' to a UseCacheRepeat function
1650 if (config->fNeedRepeat) {
1651 b.SetBufferOffset(bufpos);
1652 }
1653 return 0;
1654 }
1655
1656 INLINE_TEMPLATE_ARGS Int_t UseCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
1657 {
1658 TConfigurationUseCache *config = (TConfigurationUseCache*)conf;
1659
1660 Int_t bufpos = b.Length();
1661 TVirtualArray *cached = b.PeekDataCache();
1662 if (cached==0) {
1663 TStreamerElement *aElement = config->fCompInfo->fElem;
1664 TStreamerInfo *info = (TStreamerInfo*)config->fInfo;
1665
1666 TVirtualCollectionProxy *proxy = ((TGenericLoopConfig*)loopconfig)->fProxy;
1667 Warning("ReadBuffer","Skipping %s::%s because the cache is missing.",info->GetName(),aElement->GetName());
1668 UInt_t n = proxy->Size();
1669 info->ReadBufferSkip(b, *proxy,config->fCompInfo,config->fCompInfo->fType+TStreamerInfo::kSkip,aElement,n,0);
1670 } else {
1671 TVectorLoopConfig cached_config( nullptr, cached->fClass->Size(), /* read */ kTRUE );
1672 void *cached_start = (*cached)[0];
1673 void *cached_end = ((char*)cached_start) + cached->fSize * cached_config.fIncrement;
1674 config->fAction(b,cached_start,cached_end,&cached_config);
1675 }
1676 // Idea: Factor out this 'if' to a UseCacheRepeat function
1677 if (config->fNeedRepeat) {
1678 b.SetBufferOffset(bufpos);
1679 }
1680 return 0;
1681 }
1682
1683 // Support for collections.
1684
1685 Int_t ReadLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
1686 {
1687 Fatal("ApplySequence","The sequence of actions to read %s:%d member-wise was not initialized.",config->fInfo->GetName(),config->fInfo->GetClassVersion());
1688 return 0;
1689 }
1690
1691 Int_t WriteLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
1692 {
1693 Fatal("ApplySequence","The sequence of actions to write %s:%d member-wise was not initialized.",config->fInfo->GetName(),config->fInfo->GetClassVersion());
1694 return 0;
1695 }
1696
1697 enum ESelectLooper { kVectorLooper, kVectorPtrLooper, kAssociativeLooper, kGenericLooper };
1698
1699 ESelectLooper SelectLooper(TVirtualCollectionProxy &proxy)
1700 {
1701 if ( (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) ) {
1702 return kVectorLooper;
1703 } else if ( (proxy.GetCollectionType() == ROOT::kSTLvector)) {
1704 if (proxy.GetProperties() & TVirtualCollectionProxy::kCustomAlloc)
1705 return kGenericLooper;
1706 else
1707 return kVectorLooper;
1708 } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLunorderedset
1709 || proxy.GetCollectionType() == ROOT::kSTLmultiset || proxy.GetCollectionType() == ROOT::kSTLunorderedmultiset
1710 || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap
1711 || proxy.GetCollectionType() == ROOT::kSTLunorderedmap || proxy.GetCollectionType() == ROOT::kSTLunorderedmultimap
1712 || proxy.GetCollectionType() == ROOT::kSTLbitset) {
1713 return kAssociativeLooper;
1714 } else {
1715 return kGenericLooper;
1716 }
1717 }
1718
1719 struct VectorLooper {
1720
1721 template <typename T>
1722 static INLINE_TEMPLATE_ARGS Int_t ReadBasicType(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1723 {
1724 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1725 iter = (char*)iter + config->fOffset;
1726 end = (char*)end + config->fOffset;
1727 for(; iter != end; iter = (char*)iter + incr ) {
1728 T *x = (T*) ((char*) iter);
1729 buf >> *x;
1730 }
1731 return 0;
1732 }
1733
1734 template <typename From, typename To>
1735 struct ConvertBasicType {
1736 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1737 {
1738 // Simple conversion from a 'From' on disk to a 'To' in memory.
1739 From temp;
1740 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1741 iter = (char*)iter + config->fOffset;
1742 end = (char*)end + config->fOffset;
1743 for(; iter != end; iter = (char*)iter + incr ) {
1744 buf >> temp;
1745 *(To*)( ((char*)iter) ) = (To)temp;
1746 }
1747 return 0;
1748 }
1749 };
1750
1751 template <typename To>
1752 struct ConvertBasicType<BitsMarker,To> {
1753 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1754 {
1755 // Simple conversion from a 'From' on disk to a 'To' in memory.
1756 UInt_t temp;
1757 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1758 iter = (char*)iter + config->fOffset;
1759 end = (char*)end + config->fOffset;
1760 for(; iter != end; iter = (char*)iter + incr ) {
1761 buf >> temp;
1762
1763 if ((temp & kIsReferenced) != 0) {
1764 HandleReferencedTObject(buf, (char*)iter - config->fOffset, config);
1765 }
1766
1767 *(To*)( ((char*)iter) ) = (To)temp;
1768 }
1769 return 0;
1770 }
1771 };
1772
1773 template <typename From, typename To>
1774 struct ConvertBasicType<WithFactorMarker<From>,To> {
1775 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1776 {
1777 // Simple conversion from a 'From' on disk to a 'To' in memory.
1778 TConfWithFactor *conf = (TConfWithFactor *)config;
1779 From temp;
1780 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1781 iter = (char*)iter + config->fOffset;
1782 end = (char*)end + config->fOffset;
1783 for(; iter != end; iter = (char*)iter + incr ) {
1784 buf.ReadWithFactor(&temp, conf->fFactor, conf->fXmin);
1785 *(To*)( ((char*)iter) ) = (To)temp;
1786 }
1787 return 0;
1788 }
1789 };
1790
1791 template <typename From, typename To>
1792 struct ConvertBasicType<NoFactorMarker<From>,To> {
1793 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1794 {
1795 // Simple conversion from a 'From' on disk to a 'To' in memory.
1796 TConfNoFactor *conf = (TConfNoFactor *)config;
1797 From temp;
1798 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1799 iter = (char*)iter + config->fOffset;
1800 end = (char*)end + config->fOffset;
1801 for(; iter != end; iter = (char*)iter + incr ) {
1802 buf.ReadWithNbits(&temp, conf->fNbits);
1803 *(To*)( ((char*)iter) ) = (To)temp;
1804 }
1805 return 0;
1806 }
1807 };
1808
1809 template <typename T>
1810 static INLINE_TEMPLATE_ARGS Int_t WriteBasicType(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1811 {
1812 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1813 iter = (char*)iter + config->fOffset;
1814 end = (char*)end + config->fOffset;
1815 for(; iter != end; iter = (char*)iter + incr ) {
1816 T *x = (T*) ((char*) iter);
1817 buf << *x;
1818 }
1819 return 0;
1820 }
1821
1822 template <Int_t (*iter_action)(TBuffer&,void *,const TConfiguration*)>
1823 static INLINE_TEMPLATE_ARGS Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
1824 {
1825 const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1826 //Idea: can we factor out the addition of fOffset
1827 // iter = (char*)iter + config->fOffset;
1828 for(void *iter = start; iter != end; iter = (char*)iter + incr ) {
1829 iter_action(buf, iter, config);
1830 }
1831 return 0;
1832 }
1833
1834 static INLINE_TEMPLATE_ARGS Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TLoopConfiguration * loopconfig, const TConfiguration *config)
1835 {
1836 // Well the implementation is non trivial since we do not have a proxy for the container of _only_ the base class. For now
1837 // punt.
1838
1839 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1840 UInt_t n = (((char*)end)-((char*)start))/incr;
1841 char **arrptr = new char*[n];
1842 UInt_t i = 0;
1843 for(void *iter = start; iter != end; iter = (char*)iter + incr, ++i ) {
1844 arrptr[i] = (char*)iter;
1845 }
1846 ((TStreamerInfo*)config->fInfo)->ReadBuffer(buf, arrptr, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ n, config->fOffset, 1|2 );
1847 delete [] arrptr;
1848
1849 // // Idea: need to cache this result!
1850 // TStreamerInfo *info = (TStreamerInfo*)config->fInfo;
1851 // TStreamerElement *aElement = (TStreamerElement*)info->GetElem(config->fElemId);
1852 //
1853 // *Int_t clversion = ((TStreamerBase*)aElement)->Get BaseVersion();
1854 // *TClass *cle = aElement->GetNewBaseClass();
1855 // *(TSequence *actions = CreateReadMemberWiseActions( cle->GetStreamerInfo(clversion), ???? );
1856 //
1857 // TSequence *actions = CreateReadMemberWiseActions( ((TStreamerBase*)aElement)->GetBaseStreamerInfo(), ???? );
1858 //
1859 // actions->ReadBuffer(b,start,end);
1860 // delete actions;
1861
1862 // const Int_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1863 // for(void *iter = start; iter != end; iter = (char*)iter + incr )
1864 // {
1865 // ((TStreamerInfo*)(((TStreamerBase*)aElement)->GetBaseStreamerInfo())->ReadBuffer(b,arr,-1,narr,ioffset,arrayMode);
1866 //
1867 // ((TStreamerInfo*)config->fInfo)->ReadBuffer(buf, (char**)&iter, config->fElemId, 1, config->fOffset, 1|2 );
1868 // }
1869 return 0;
1870 }
1871
1872 static INLINE_TEMPLATE_ARGS Int_t GenericRead(TBuffer &buf, void *start, const void *end, const TLoopConfiguration * loopconfig, const TConfiguration *config)
1873 {
1874 // Well the implementation is non trivial. For now punt.
1875
1876 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1877 UInt_t n = (((char*)end)-((char*)start))/incr;
1878 char **arrptr = new char*[n];
1879 UInt_t i = 0;
1880 for(void *iter = start; iter != end; iter = (char*)iter + incr, ++i ) {
1881 arrptr[i] = (char*)iter;
1882 }
1883 ((TStreamerInfo*)config->fInfo)->ReadBuffer(buf, arrptr, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ n, config->fOffset, 1|2 );
1884 delete [] arrptr;
1885 return 0;
1886 }
1887
1888 static INLINE_TEMPLATE_ARGS Int_t GenericWrite(TBuffer &buf, void *start, const void *end, const TLoopConfiguration * loopconfig, const TConfiguration *config)
1889 {
1890 // Well the implementation is non trivial. For now punt.
1891
1892 UInt_t incr = ((TVectorLoopConfig*)loopconfig)->fIncrement;
1893 UInt_t n = (((char*)end)-((char*)start))/incr;
1894 char **arrptr = new char*[n];
1895 UInt_t i = 0;
1896 for(void *iter = start; iter != end; iter = (char*)iter + incr, ++i ) {
1897 arrptr[i] = (char*)iter;
1898 }
1899 ((TStreamerInfo*)config->fInfo)->WriteBufferAux(buf, arrptr, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, n, config->fOffset, 1|2 );
1900 delete [] arrptr;
1901 return 0;
1902 }
1903
1904 template <typename T>
1905 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
1906 {
1907 // Collection of numbers. Memberwise or not, it is all the same.
1908
1909 TConfigSTL *config = (TConfigSTL*)conf;
1910 UInt_t start, count;
1911 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
1912
1913 std::vector<T> *const vec = (std::vector<T>*)(((char*)addr)+config->fOffset);
1914 Int_t nvalues;
1915 buf.ReadInt(nvalues);
1916 vec->resize(nvalues);
1917
1918#ifdef R__VISUAL_CPLUSPLUS
1919 if (nvalues <= 0) {
1920 buf.CheckByteCount(start,count,config->fTypeName);
1921 return 0;
1922 }
1923#endif
1924 T *begin = &(*vec->begin());
1925 buf.ReadFastArray(begin, nvalues);
1926
1927 buf.CheckByteCount(start,count,config->fTypeName);
1928 return 0;
1929 }
1930
1931 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
1932 {
1933 // Collection of numbers. Memberwise or not, it is all the same.
1934
1935 TConfigSTL *config = (TConfigSTL*)conf;
1936 UInt_t start, count;
1937 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
1938
1939 std::vector<bool> *const vec = (std::vector<bool>*)(((char*)addr)+config->fOffset);
1940 Int_t nvalues;
1941 buf.ReadInt(nvalues);
1942 vec->resize(nvalues);
1943
1944 bool *items = new bool[nvalues];
1945 buf.ReadFastArray(items, nvalues);
1946 for(Int_t i = 0 ; i < nvalues; ++i) {
1947 (*vec)[i] = items[i];
1948 }
1949 delete [] items;
1950
1951 // We could avoid the call to ReadFastArray, and we could
1952 // the following, however this breaks TBufferXML ...
1953 // for(Int_t i = 0 ; i < nvalues; ++i) {
1954 // bool tmp; buf >> tmp;
1955 // (*vec)[i] = tmp;
1956 // }
1957
1958 buf.CheckByteCount(start,count,config->fTypeName);
1959 return 0;
1960 }
1961
1962 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
1963 {
1964 // Collection of numbers. Memberwise or not, it is all the same.
1965
1966 TConfigSTL *config = (TConfigSTL*)conf;
1967 UInt_t start, count;
1968 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
1969
1970 std::vector<float> *const vec = (std::vector<float>*)(((char*)addr)+config->fOffset);
1971 Int_t nvalues;
1972 buf.ReadInt(nvalues);
1973 vec->resize(nvalues);
1974
1975#ifdef R__VISUAL_CPLUSPLUS
1976 if (nvalues <= 0) {
1977 buf.CheckByteCount(start,count,config->fTypeName);
1978 return 0;
1979 }
1980#endif
1981 float *begin = &(*vec->begin());
1982 buf.ReadFastArrayFloat16(begin, nvalues);
1983
1984 buf.CheckByteCount(start,count,config->fTypeName);
1985 return 0;
1986 }
1987
1988 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
1989 {
1990 // Collection of numbers. Memberwise or not, it is all the same.
1991
1992 TConfigSTL *config = (TConfigSTL*)conf;
1993 UInt_t start, count;
1994 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
1995
1996 std::vector<double> *const vec = (std::vector<double>*)(((char*)addr)+config->fOffset);
1997 Int_t nvalues;
1998 buf.ReadInt(nvalues);
1999 vec->resize(nvalues);
2000
2001#ifdef R__VISUAL_CPLUSPLUS
2002 if (nvalues <= 0) {
2003 buf.CheckByteCount(start,count,config->fTypeName);
2004 return 0;
2005 }
2006#endif
2007 double *begin = &(*vec->begin());
2008 buf.ReadFastArrayDouble32(begin, nvalues);
2009
2010 buf.CheckByteCount(start,count,config->fTypeName);
2011 return 0;
2012 }
2013
2014 template <typename From, typename To>
2015 struct ConvertCollectionBasicType {
2016 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
2017 {
2018 // Collection of numbers. Memberwise or not, it is all the same.
2019
2020 TConfigSTL *config = (TConfigSTL*)conf;
2021 UInt_t start, count;
2022 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
2023
2024 std::vector<To> *const vec = (std::vector<To>*)(((char*)addr)+config->fOffset);
2025 Int_t nvalues;
2026 buf.ReadInt(nvalues);
2027 vec->resize(nvalues);
2028
2029 From *temp = new From[nvalues];
2030 buf.ReadFastArray(temp, nvalues);
2031 for(Int_t ind = 0; ind < nvalues; ++ind) {
2032 (*vec)[ind] = (To)temp[ind];
2033 }
2034 delete [] temp;
2035
2036 buf.CheckByteCount(start,count,config->fTypeName);
2037 return 0;
2038 }
2039 };
2040
2041 template <typename From, typename To>
2042 struct ConvertCollectionBasicType<NoFactorMarker<From>,To> {
2043 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
2044 {
2045 // Collection of numbers. Memberwise or not, it is all the same.
2046
2047 TConfigSTL *config = (TConfigSTL*)conf;
2048 UInt_t start, count;
2049 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
2050
2051 std::vector<To> *const vec = (std::vector<To>*)(((char*)addr)+config->fOffset);
2052 Int_t nvalues;
2053 buf.ReadInt(nvalues);
2054 vec->resize(nvalues);
2055
2056 From *temp = new From[nvalues];
2057 buf.ReadFastArrayWithNbits(temp, nvalues, 0);
2058 for(Int_t ind = 0; ind < nvalues; ++ind) {
2059 (*vec)[ind] = (To)temp[ind];
2060 }
2061 delete [] temp;
2062
2063 buf.CheckByteCount(start,count,config->fTypeName);
2064 return 0;
2065 }
2066 };
2067
2068 template <typename To>
2069 static INLINE_TEMPLATE_ARGS Int_t ConvertCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
2070 {
2071 // Collection of numbers. Memberwise or not, it is all the same.
2072
2073 TConfigSTL *config = (TConfigSTL*)conf;
2074 UInt_t start, count;
2075 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
2076
2077 std::vector<To> *const vec = (std::vector<To>*)(((char*)addr)+config->fOffset);
2078 Int_t nvalues;
2079 buf.ReadInt(nvalues);
2080 vec->resize(nvalues);
2081
2082 Double32_t *temp = new Double32_t[nvalues];
2083 buf.ReadFastArrayDouble32(temp, nvalues);
2084 for(Int_t ind = 0; ind < nvalues; ++ind) {
2085 (*vec)[ind] = (To)temp[ind];
2086 }
2087 delete [] temp;
2088
2089 buf.CheckByteCount(start,count,config->fTypeName);
2090 return 0;
2091 }
2092
2093 };
2094
2095 struct VectorPtrLooper {
2096
2097 template <typename T>
2098 static INLINE_TEMPLATE_ARGS Int_t ReadBasicType(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2099 {
2100 const Int_t offset = config->fOffset;
2101
2102 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2103 T *x = (T*)( ((char*) (*(void**)iter) ) + offset );
2104 buf >> *x;
2105 }
2106 return 0;
2107 }
2108
2109 template <typename From, typename To>
2110 struct ConvertBasicType {
2111 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2112 {
2113 // Simple conversion from a 'From' on disk to a 'To' in memory.
2114 From temp;
2115 const Int_t offset = config->fOffset;
2116 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2117 buf >> temp;
2118 To *x = (To*)( ((char*) (*(void**)iter) ) + offset );
2119 *x = (To)temp;
2120 }
2121 return 0;
2122 }
2123 };
2124
2125 template <typename To>
2126 struct ConvertBasicType<BitsMarker,To> {
2127 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2128 {
2129 // Simple conversion from a 'From' on disk to a 'To' in memory.
2130 UInt_t temp;
2131 const Int_t offset = config->fOffset;
2132 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2133 buf >> temp;
2134
2135 if ((temp & kIsReferenced) != 0) {
2136 HandleReferencedTObject(buf,*(void**)iter,config);
2137 }
2138
2139 To *x = (To*)( ((char*) (*(void**)iter) ) + offset );
2140 *x = (To)temp;
2141 }
2142 return 0;
2143 }
2144 };
2145
2146 template <typename From, typename To>
2147 struct ConvertBasicType<WithFactorMarker<From>,To> {
2148 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2149 {
2150 // Simple conversion from a 'From' on disk to a 'To' in memory.
2151 TConfWithFactor *conf = (TConfWithFactor *)config;
2152 From temp;
2153 const Int_t offset = config->fOffset;
2154 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2155 buf.ReadWithFactor(&temp, conf->fFactor, conf->fXmin);
2156 To *x = (To*)( ((char*) (*(void**)iter) ) + offset );
2157 *x = (To)temp;
2158 }
2159 return 0;
2160 }
2161 };
2162
2163 template <typename From, typename To>
2164 struct ConvertBasicType<NoFactorMarker<From>,To> {
2165 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2166 {
2167 // Simple conversion from a 'From' on disk to a 'To' in memory.
2168 TConfNoFactor *conf = (TConfNoFactor *)config;
2169 From temp;
2170 const Int_t offset = config->fOffset;
2171 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2172 buf.ReadWithNbits(&temp, conf->fNbits);
2173 To *x = (To*)( ((char*) (*(void**)iter) ) + offset );
2174 *x = (To)temp;
2175 }
2176 return 0;
2177 }
2178 };
2179
2180 template <typename T>
2181 static INLINE_TEMPLATE_ARGS Int_t WriteBasicType(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2182 {
2183 const Int_t offset = config->fOffset;
2184
2185 for(; iter != end; iter = (char*)iter + sizeof(void*) ) {
2186 T *x = (T*)( ((char*) (*(void**)iter) ) + offset );
2187 buf << *x;
2188 }
2189 return 0;
2190 }
2191
2192 template <Int_t (*action)(TBuffer&,void *,const TConfiguration*)>
2193 static INLINE_TEMPLATE_ARGS Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TConfiguration *config)
2194 {
2195 for(void *iter = start; iter != end; iter = (char*)iter + sizeof(void*) ) {
2196 action(buf, *(void**)iter, config);
2197 }
2198 return 0;
2199 }
2200
2201 static INLINE_TEMPLATE_ARGS Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TConfiguration *config)
2202 {
2203 // Well the implementation is non trivial since we do not have a proxy for the container of _only_ the base class. For now
2204 // punt.
2205
2206 return GenericRead(buf,start,end,config);
2207 }
2208
2209 static INLINE_TEMPLATE_ARGS Int_t GenericRead(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2210 {
2211 Int_t n = ( ((void**)end) - ((void**)iter) );
2212 char **arr = (char**)iter;
2213 return ((TStreamerInfo*)config->fInfo)->ReadBuffer(buf, arr, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ n, config->fOffset, 1|2 );
2214 }
2215
2216 static INLINE_TEMPLATE_ARGS Int_t GenericWrite(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
2217 {
2218 Int_t n = ( ((void**)end) - ((void**)iter) );
2219 char **arr = (char**)iter;
2220 return ((TStreamerInfo*)config->fInfo)->WriteBufferAux(buf, arr, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, n, config->fOffset, 1|2 );
2221 }
2222
2223 };
2224
2225 struct AssociativeLooper {
2226
2227 template <typename T>
2228 static INLINE_TEMPLATE_ARGS void SimpleRead(TBuffer &buf, void *addr, Int_t nvalues)
2229 {
2230 buf.ReadFastArray((T*)addr, nvalues);
2231 }
2232
2233 static INLINE_TEMPLATE_ARGS void SimpleReadFloat16(TBuffer &buf, void *addr, Int_t nvalues)
2234 {
2235 buf.ReadFastArrayFloat16((float*)addr, nvalues);
2236 }
2237
2238 static INLINE_TEMPLATE_ARGS void SimpleReadDouble32(TBuffer &buf, void *addr, Int_t nvalues)
2239 {
2240 buf.ReadFastArrayDouble32((double*)addr, nvalues);
2241 }
2242
2243 template <typename T,void (*action)(TBuffer&,void *,Int_t)>
2244 static INLINE_TEMPLATE_ARGS Int_t ReadNumericalCollection(TBuffer &buf, void *addr, const TConfiguration *conf)
2245 {
2246 // Collection of numbers. Memberwise or not, it is all the same.
2247
2248 TConfigSTL *config = (TConfigSTL*)conf;
2249 UInt_t start, count;
2250 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
2251
2252 TClass *newClass = config->fNewClass;
2253 TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();
2254 TVirtualCollectionProxy::TPushPop helper( newProxy, ((char*)addr)+config->fOffset );
2255
2256 Int_t nvalues;
2257 buf.ReadInt(nvalues);
2258 void* alternative = newProxy->Allocate(nvalues,true);
2259 if (nvalues) {
2260 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
2261 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
2262 void *begin = &(startbuf[0]);
2263 void *end = &(endbuf[0]);
2264 config->fCreateIterators(alternative, &begin, &end, newProxy);
2265 // We can not get here with a split vector of pointer, so we can indeed assume
2266 // that actions->fConfiguration != null.
2267
2268 action(buf,begin,nvalues);
2269
2270 if (begin != &(startbuf[0])) {
2271 // assert(end != endbuf);
2272 config->fDeleteTwoIterators(begin,end);
2273 }
2274 }
2275 newProxy->Commit(alternative);
2276
2277 buf.CheckByteCount(start,count,config->fTypeName);
2278 return 0;
2279 }
2280
2281 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
2282 {
2283 return ReadNumericalCollection<bool,SimpleRead<bool> >(buf,addr,conf);
2284 }
2285
2286 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
2287 {
2288 return ReadNumericalCollection<Float_t,SimpleReadFloat16 >(buf,addr,conf);
2289 }
2290
2291 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
2292 {
2293 return ReadNumericalCollection<Double_t,SimpleReadDouble32 >(buf,addr,conf);
2294 }
2295
2296 template <typename T>
2297 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
2298 {
2299 return ReadNumericalCollection<T,SimpleRead<T> >(buf,addr,conf);
2300 }
2301
2302 template <typename From, typename To>
2303 struct ConvertRead {
2304 static INLINE_TEMPLATE_ARGS void Action(TBuffer &buf, void *addr, Int_t nvalues)
2305 {
2306 From *temp = new From[nvalues];
2307 buf.ReadFastArray(temp, nvalues);
2308 To *vec = (To*)addr;
2309 for(Int_t ind = 0; ind < nvalues; ++ind) {
2310 vec[ind] = (To)temp[ind];
2311 }
2312 delete [] temp;
2313 }
2314 };
2315
2316 template <typename From, typename To>
2317 struct ConvertRead<NoFactorMarker<From>,To> {
2318 static INLINE_TEMPLATE_ARGS void Action(TBuffer &buf, void *addr, Int_t nvalues)
2319 {
2320 From *temp = new From[nvalues];
2321 buf.ReadFastArrayWithNbits(temp, nvalues,0);
2322 To *vec = (To*)addr;
2323 for(Int_t ind = 0; ind < nvalues; ++ind) {
2324 vec[ind] = (To)temp[ind];
2325 }
2326 delete [] temp;
2327 }
2328 };
2329
2330 template <typename From, typename To>
2331 struct ConvertRead<WithFactorMarker<From>,To> {
2332 static INLINE_TEMPLATE_ARGS void Action(TBuffer &buf, void *addr, Int_t nvalues)
2333 {
2334 From *temp = new From[nvalues];
2335 double factor,min; // needs to be initialized.
2336 buf.ReadFastArrayWithFactor(temp, nvalues, factor, min);
2337 To *vec = (To*)addr;
2338 for(Int_t ind = 0; ind < nvalues; ++ind) {
2339 vec[ind] = (To)temp[ind];
2340 }
2341 delete [] temp;
2342 }
2343 };
2344
2345 template <typename From, typename To>
2346 struct ConvertCollectionBasicType {
2347 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
2348 {
2349 return ReadNumericalCollection<To,ConvertRead<From,To>::Action >(buf,addr,conf);
2350 }
2351 };
2352
2353 };
2354
2355 struct GenericLooper {
2356
2357 template <typename T>
2358 static INLINE_TEMPLATE_ARGS Int_t ReadBasicType(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2359 {
2360 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2361
2362 Next_t next = loopconfig->fNext;
2363 const Int_t offset = config->fOffset;
2364
2365 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
2366 void *iter = loopconfig->fCopyIterator(iterator,start);
2367 void *addr;
2368 while( (addr = next(iter,end)) ) {
2369 T *x = (T*)( ((char*)addr) + offset );
2370 buf >> *x;
2371 }
2372 if (iter != &iterator[0]) {
2373 loopconfig->fDeleteIterator(iter);
2374 }
2375 return 0;
2376 }
2377
2378 template <typename T>
2379 static INLINE_TEMPLATE_ARGS Int_t WriteBasicType(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2380 {
2381 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2382
2383 Next_t next = loopconfig->fNext;
2384 const Int_t offset = config->fOffset;
2385
2386 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
2387 void *iter = loopconfig->fCopyIterator(iterator,start);
2388 void *addr;
2389 while( (addr = next(iter,end)) ) {
2390 T *x = (T*)( ((char*)addr) + offset );
2391 buf << *x;
2392 }
2393 if (iter != &iterator[0]) {
2394 loopconfig->fDeleteIterator(iter);
2395 }
2396 return 0;
2397 }
2398
2399 template <Int_t (*iter_action)(TBuffer&,void *,const TConfiguration*)>
2400 static INLINE_TEMPLATE_ARGS Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2401 {
2402 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2403
2404 // const Int_t offset = config->fOffset;
2405 Next_t next = loopconfig->fNext;
2406
2407 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
2408 void *iter = loopconfig->fCopyIterator(&iterator,start);
2409 void *addr;
2410 while( (addr = next(iter,end)) ) {
2411 iter_action(buf, addr, config);
2412 }
2413 if (iter != &iterator[0]) {
2414 loopconfig->fDeleteIterator(iter);
2415 }
2416 return 0;
2417 }
2418
2419 template <typename From, typename To>
2420 struct Generic {
2421 static void ConvertAction(From *items, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2422 {
2423 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2424
2425 const Int_t offset = config->fOffset;
2426 Next_t next = loopconfig->fNext;
2427
2428 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
2429 void *iter = loopconfig->fCopyIterator(&iterator,start);
2430 void *addr;
2431 while( (addr = next(iter,end)) ) {
2432 To *x = (To*)( ((char*)addr) + offset );
2433 *x = (To)(*items);
2434 ++items;
2435 }
2436 if (iter != &iterator[0]) {
2437 loopconfig->fDeleteIterator(iter);
2438 }
2439 }
2440 };
2441
2442 template <typename From, typename To>
2443 struct Numeric {
2444 static void ConvertAction(From *items, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration * /* config */)
2445 {
2446 // The difference with ConvertAction is that we can modify the start
2447 // iterator and skip the copy. We also never have an offset.
2448
2449 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2450 Next_t next = loopconfig->fNext;
2451
2452 void *iter = start;
2453 void *addr;
2454 while( (addr = next(iter,end)) ) {
2455 To *x = (To*)(addr);
2456 *x = (To)(*items);
2457 ++items;
2458 }
2459 }
2460 };
2461
2462 template <typename From, typename To, template <typename F, typename T> class Converter = Generic >
2463 struct ConvertBasicType {
2464 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2465 {
2466 // Simple conversion from a 'From' on disk to a 'To' in memory.
2467
2468 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2469 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2470 Int_t nvalues = proxy->Size();
2471
2472 From *items = new From[nvalues];
2473 buf.ReadFastArray(items, nvalues);
2474 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2475 delete [] items;
2476 return 0;
2477 }
2478 };
2479
2480 template <typename To>
2481 struct ConvertBasicType<BitsMarker, To, Generic> {
2482 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2483 {
2484 // Simple conversion from a 'From' on disk to a 'To' in memory.
2485
2486 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2487 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2488 Int_t nvalues = proxy->Size();
2489
2490 UInt_t *items_storage = new UInt_t[nvalues];
2491 UInt_t *items = items_storage;
2492
2493 const Int_t offset = config->fOffset;
2494 Next_t next = loopconfig->fNext;
2495
2496 char iterator[TVirtualCollectionProxy::fgIteratorArenaSize];
2497 void *iter = loopconfig->fCopyIterator(&iterator,start);
2498 void *addr;
2499 while( (addr = next(iter,end)) ) {
2500 buf >> (*items);
2501 if (((*items) & kIsReferenced) != 0) {
2502 HandleReferencedTObject(buf, addr, config);
2503 }
2504 To *x = (To*)( ((char*)addr) + offset );
2505 *x = (To)(*items);
2506 ++items;
2507 }
2508 if (iter != &iterator[0]) {
2509 loopconfig->fDeleteIterator(iter);
2510 }
2511
2512 delete [] items_storage;
2513 return 0;
2514 }
2515 };
2516
2517 template <typename From, typename To, template <typename F, typename T> class Converter >
2518 struct ConvertBasicType<WithFactorMarker<From>,To,Converter > {
2519 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2520 {
2521 // Simple conversion from a 'From' on disk to a 'To' in memory.
2522
2523 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2524 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2525 Int_t nvalues = proxy->Size();
2526
2527 TConfSTLWithFactor *conf = (TConfSTLWithFactor *)config;
2528
2529 From *items = new From[nvalues];
2530 buf.ReadFastArrayWithFactor(items, nvalues, conf->fFactor, conf->fXmin);
2531 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2532 delete [] items;
2533 return 0;
2534 }
2535 };
2536
2537 template <typename From, typename To, template <typename F, typename T> class Converter >
2538 struct ConvertBasicType<NoFactorMarker<From>,To,Converter > {
2539 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
2540 {
2541 // Simple conversion from a 'From' on disk to a 'To' in memory.
2542
2543 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2544 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2545 Int_t nvalues = proxy->Size();
2546
2547 TConfSTLNoFactor *conf = (TConfSTLNoFactor *)config;
2548
2549 From *items = new From[nvalues];
2550 buf.ReadFastArrayWithNbits(items, nvalues, conf->fNbits);
2551 Converter<From,To>::ConvertAction(items,start,end,loopconfig,config);
2552 delete [] items;
2553 return 0;
2554 }
2555 };
2556
2557 static INLINE_TEMPLATE_ARGS Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TLoopConfiguration * loopconfig, const TConfiguration *config)
2558 {
2559 // Well the implementation is non trivial since we do not have a proxy for the container of _only_ the base class. For now
2560 // punt.
2561
2562 return GenericRead(buf,start,end,loopconfig, config);
2563 }
2564
2565 static INLINE_TEMPLATE_ARGS Int_t GenericRead(TBuffer &buf, void *, const void *, const TLoopConfiguration * loopconf, const TConfiguration *config)
2566 {
2567 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2568 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2569 return ((TStreamerInfo*)config->fInfo)->ReadBuffer(buf, *proxy, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, /*narr*/ proxy->Size(), config->fOffset, 1|2 );
2570 }
2571
2572 static INLINE_TEMPLATE_ARGS Int_t GenericWrite(TBuffer &buf, void *, const void *, const TLoopConfiguration * loopconf, const TConfiguration *config)
2573 {
2574 TGenericLoopConfig *loopconfig = (TGenericLoopConfig*)loopconf;
2575 TVirtualCollectionProxy *proxy = loopconfig->fProxy;
2576 return ((TStreamerInfo*)config->fInfo)->WriteBufferAux(buf, *proxy, &(config->fCompInfo), /*first*/ 0, /*last*/ 1, proxy->Size(), config->fOffset, 1|2 );
2577 }
2578
2579 template <typename T>
2580 static INLINE_TEMPLATE_ARGS void SimpleRead(TBuffer &buf, void *addr)
2581 {
2582 buf >> *(T*)addr;
2583 }
2584
2585 static INLINE_TEMPLATE_ARGS void SimpleReadFloat16(TBuffer &buf, void *addr)
2586 {
2587 buf.ReadWithNbits((float*)addr,12);
2588 }
2589
2590 static INLINE_TEMPLATE_ARGS void SimpleReadDouble32(TBuffer &buf, void *addr)
2591 {
2592 //we read a float and convert it to double
2593 Float_t afloat;
2594 buf >> afloat;
2595 *(double*)addr = (Double_t)afloat;
2596 }
2597
2598 template <typename ActionHolder>
2599 static INLINE_TEMPLATE_ARGS Int_t ReadNumericalCollection(TBuffer &buf, void *addr, const TConfiguration *conf)
2600 {
2601 // Collection of numbers. Memberwise or not, it is all the same.
2602
2603 TConfigSTL *config = (TConfigSTL*)conf;
2604 UInt_t start, count;
2605 /* Version_t vers = */ buf.ReadVersion(&start, &count, config->fOldClass);
2606
2607 TClass *newClass = config->fNewClass;
2608 TVirtualCollectionProxy *newProxy = newClass->GetCollectionProxy();
2609 TVirtualCollectionProxy::TPushPop helper( newProxy, ((char*)addr)+config->fOffset );
2610
2611 Int_t nvalues;
2612 buf.ReadInt(nvalues);
2613 void* alternative = newProxy->Allocate(nvalues,true);
2614 if (nvalues) {
2615 char startbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
2616 char endbuf[TVirtualCollectionProxy::fgIteratorArenaSize];
2617 void *begin = &(startbuf[0]);
2618 void *end = &(endbuf[0]);
2619 config->fCreateIterators(alternative, &begin, &end, newProxy);
2620 // We can not get here with a split vector of pointer, so we can indeed assume
2621 // that actions->fConfiguration != null.
2622
2623 TGenericLoopConfig loopconf(newProxy, /* read */ kTRUE);
2624 ActionHolder::Action(buf,begin,end,&loopconf,config);
2625
2626 if (begin != &(startbuf[0])) {
2627 // assert(end != endbuf);
2628 config->fDeleteTwoIterators(begin,end);
2629 }
2630 }
2631 newProxy->Commit(alternative);
2632
2633 buf.CheckByteCount(start,count,config->fTypeName);
2634 return 0;
2635 }
2636
2637 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
2638 {
2639 return ReadNumericalCollection<ConvertBasicType<bool,bool,Numeric > >(buf,addr,conf);
2640 }
2641
2642 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
2643 {
2644 return ReadNumericalCollection<ConvertBasicType<NoFactorMarker<float>,float,Numeric > >(buf,addr,conf);
2645 }
2646
2647 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
2648 {
2649 return ReadNumericalCollection<ConvertBasicType<float,double,Numeric > >(buf,addr,conf);
2650 // Could also use:
2651 // return ReadNumericalCollection<ConvertBasicType<NoFactorMarker<double>,double,Numeric > >(buf,addr,conf);
2652 }
2653
2654 template <typename T>
2655 static INLINE_TEMPLATE_ARGS Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
2656 {
2657 //TODO: Check whether we can implement this without loading the data in
2658 // a temporary variable and whether this is noticeably faster.
2659 return ReadNumericalCollection<ConvertBasicType<T,T,Numeric > >(buf,addr,conf);
2660 }
2661
2662 template <typename From, typename To>
2663 struct ConvertCollectionBasicType {
2664 static INLINE_TEMPLATE_ARGS Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
2665 {
2666 // return ReadNumericalCollection<To,ConvertRead<From,To>::Action >(buf,addr,conf);
2667 return ReadNumericalCollection<ConvertBasicType<From,To,Numeric > >(buf,addr,conf);
2668 }
2669 };
2670
2671 };
2672}
2673
2674template <typename Looper, typename From>
2675static TConfiguredAction GetCollectionReadConvertAction(Int_t newtype, TConfiguration *conf)
2676{
2677 switch (newtype) {
2678 case TStreamerInfo::kBool: return TConfiguredAction( Looper::template ConvertBasicType<From,bool>::Action, conf ); break;
2679 case TStreamerInfo::kChar: return TConfiguredAction( Looper::template ConvertBasicType<From,char>::Action, conf ); break;
2680 case TStreamerInfo::kShort: return TConfiguredAction( Looper::template ConvertBasicType<From,short>::Action, conf ); break;
2681 case TStreamerInfo::kInt: return TConfiguredAction( Looper::template ConvertBasicType<From,Int_t>::Action, conf ); break;
2682 case TStreamerInfo::kLong: return TConfiguredAction( Looper::template ConvertBasicType<From,Long_t>::Action, conf ); break;
2683 case TStreamerInfo::kLong64: return TConfiguredAction( Looper::template ConvertBasicType<From,Long64_t>::Action, conf ); break;
2684 case TStreamerInfo::kFloat: return TConfiguredAction( Looper::template ConvertBasicType<From,float>::Action, conf ); break;
2685 case TStreamerInfo::kFloat16: return TConfiguredAction( Looper::template ConvertBasicType<From,float>::Action, conf ); break;
2686 case TStreamerInfo::kDouble: return TConfiguredAction( Looper::template ConvertBasicType<From,double>::Action, conf ); break;
2687 case TStreamerInfo::kDouble32:return TConfiguredAction( Looper::template ConvertBasicType<From,double>::Action, conf ); break;
2688 case TStreamerInfo::kUChar: return TConfiguredAction( Looper::template ConvertBasicType<From,UChar_t>::Action, conf ); break;
2689 case TStreamerInfo::kUShort: return TConfiguredAction( Looper::template ConvertBasicType<From,UShort_t>::Action, conf ); break;
2690 case TStreamerInfo::kUInt: return TConfiguredAction( Looper::template ConvertBasicType<From,UInt_t>::Action, conf ); break;
2691 case TStreamerInfo::kULong: return TConfiguredAction( Looper::template ConvertBasicType<From,ULong_t>::Action, conf ); break;
2692 case TStreamerInfo::kULong64: return TConfiguredAction( Looper::template ConvertBasicType<From,ULong64_t>::Action, conf ); break;
2693 case TStreamerInfo::kBits: return TConfiguredAction( Looper::template ConvertBasicType<From,UInt_t>::Action, conf ); break;
2694 default:
2695 return TConfiguredAction( Looper::GenericRead, conf );
2696 break;
2697 }
2698 R__ASSERT(0); // We should never be here
2699 return TConfiguredAction();
2700}
2701
2702template <class Looper>
2703static TConfiguredAction GetNumericCollectionReadAction(Int_t type, TConfigSTL *conf)
2704{
2705 // If we ever support std::vector<Double32_t> fValues; //[...] we would get the info from the StreamerElement for fValues.
2706
2707 switch (type) {
2708 // Read basic types.
2709 case TStreamerInfo::kBool: return TConfiguredAction( Looper::ReadCollectionBool, conf ); break;
2710 case TStreamerInfo::kChar: return TConfiguredAction( Looper::template ReadCollectionBasicType<Char_t>, conf ); break;
2711 case TStreamerInfo::kShort: return TConfiguredAction( Looper::template ReadCollectionBasicType<Short_t>,conf ); break;
2712 case TStreamerInfo::kInt: return TConfiguredAction( Looper::template ReadCollectionBasicType<Int_t>, conf ); break;
2713 case TStreamerInfo::kLong: return TConfiguredAction( Looper::template ReadCollectionBasicType<Long_t>, conf ); break;
2714 case TStreamerInfo::kLong64: return TConfiguredAction( Looper::template ReadCollectionBasicType<Long64_t>, conf ); break;
2715 case TStreamerInfo::kFloat: return TConfiguredAction( Looper::template ReadCollectionBasicType<Float_t>, conf ); break;
2716 case TStreamerInfo::kDouble: return TConfiguredAction( Looper::template ReadCollectionBasicType<Double_t>, conf ); break;
2717 case TStreamerInfo::kUChar: return TConfiguredAction( Looper::template ReadCollectionBasicType<UChar_t>, conf ); break;
2718 case TStreamerInfo::kUShort: return TConfiguredAction( Looper::template ReadCollectionBasicType<UShort_t>, conf ); break;
2719 case TStreamerInfo::kUInt: return TConfiguredAction( Looper::template ReadCollectionBasicType<UInt_t>, conf ); break;
2720 case TStreamerInfo::kULong: return TConfiguredAction( Looper::template ReadCollectionBasicType<ULong_t>, conf ); break;
2721 case TStreamerInfo::kULong64: return TConfiguredAction( Looper::template ReadCollectionBasicType<ULong64_t>, conf ); break;
2722 case TStreamerInfo::kBits: Error("GetNumericCollectionReadAction","There is no support for kBits outside of a TObject."); break;
2723 case TStreamerInfo::kFloat16: {
2724 TConfigSTL *alternate = new TConfSTLNoFactor(conf,12);
2725 delete conf;
2726 return TConfiguredAction( Looper::ReadCollectionFloat16, alternate );
2727 // if (element->GetFactor() != 0) {
2728 // return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<float> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2729 // } else {
2730 // Int_t nbits = (Int_t)element->GetXmin();
2731 // if (!nbits) nbits = 12;
2732 // return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<float> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
2733 // }
2734 break;
2735 }
2736 case TStreamerInfo::kDouble32: {
2737 TConfigSTL *alternate = new TConfSTLNoFactor(conf,0);
2738 delete conf;
2739 return TConfiguredAction( Looper::ReadCollectionDouble32, alternate );
2740 // if (element->GetFactor() != 0) {
2741 // return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<double> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2742 // } else {
2743 // Int_t nbits = (Int_t)element->GetXmin();
2744 // if (!nbits) {
2745 // return TConfiguredAction( Looper::template ReadAction<ConvertBasicType<float,double> >, new TConfiguration(info,i,compinfo,offset) );
2746 // } else {
2747 // return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<double> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
2748 // }
2749 // }
2750 break;
2751 }
2752 }
2753 Fatal("GetNumericCollectionReadAction","Is confused about %d",type);
2754 R__ASSERT(0); // We should never be here
2755 return TConfiguredAction();
2756}
2757
2758template <typename Looper, typename From>
2759static TConfiguredAction GetConvertCollectionReadActionFrom(Int_t newtype, TConfiguration *conf)
2760{
2761 switch (newtype) {
2762 case TStreamerInfo::kBool: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,bool>::Action, conf ); break;
2763 case TStreamerInfo::kChar: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,char>::Action, conf ); break;
2764 case TStreamerInfo::kShort: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,short>::Action, conf ); break;
2765 case TStreamerInfo::kInt: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,Int_t>::Action, conf ); break;
2766 case TStreamerInfo::kLong: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,Long_t>::Action, conf ); break;
2767 case TStreamerInfo::kLong64: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,Long64_t>::Action, conf ); break;
2768 case TStreamerInfo::kFloat: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,float>::Action, conf ); break;
2769 case TStreamerInfo::kFloat16: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,float>::Action, conf ); break;
2770 case TStreamerInfo::kDouble: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,double>::Action, conf ); break;
2771 case TStreamerInfo::kDouble32:return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,double>::Action, conf ); break;
2772 case TStreamerInfo::kUChar: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,UChar_t>::Action, conf ); break;
2773 case TStreamerInfo::kUShort: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,UShort_t>::Action, conf ); break;
2774 case TStreamerInfo::kUInt: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,UInt_t>::Action, conf ); break;
2775 case TStreamerInfo::kULong: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,ULong_t>::Action, conf ); break;
2776 case TStreamerInfo::kULong64: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,ULong64_t>::Action, conf ); break;
2777 case TStreamerInfo::kBits: return TConfiguredAction( Looper::template ConvertCollectionBasicType<From,UInt_t>::Action, conf ); break;
2778 default:
2779 break;
2780 }
2781 Error("GetConvertCollectionReadActionFrom", "UNEXPECTED: newtype == %d", newtype);
2782 R__ASSERT(0); // We should never be here
2783 return TConfiguredAction();
2784}
2785
2786template <typename Looper>
2787static TConfiguredAction GetConvertCollectionReadAction(Int_t oldtype, Int_t newtype, TConfiguration *conf)
2788{
2789 switch (oldtype) {
2790 case TStreamerInfo::kBool:
2791 return GetConvertCollectionReadActionFrom<Looper,Bool_t>(newtype, conf );
2792 break;
2793 case TStreamerInfo::kChar:
2794 return GetConvertCollectionReadActionFrom<Looper,Char_t>(newtype, conf );
2795 break;
2796 case TStreamerInfo::kShort:
2797 return GetConvertCollectionReadActionFrom<Looper,Short_t>(newtype, conf );
2798 break;
2799 case TStreamerInfo::kInt:
2800 return GetConvertCollectionReadActionFrom<Looper,Int_t>(newtype, conf );
2801 break;
2802 case TStreamerInfo::kLong:
2803 return GetConvertCollectionReadActionFrom<Looper,Long_t>(newtype, conf );
2804 break;
2805 case TStreamerInfo::kLong64:
2806 return GetConvertCollectionReadActionFrom<Looper,Long64_t>(newtype, conf );
2807 break;
2808 case TStreamerInfo::kFloat:
2809 return GetConvertCollectionReadActionFrom<Looper,Float_t>( newtype, conf );
2810 break;
2811 case TStreamerInfo::kDouble:
2812 return GetConvertCollectionReadActionFrom<Looper,Double_t>(newtype, conf );
2813 break;
2814 case TStreamerInfo::kUChar:
2815 return GetConvertCollectionReadActionFrom<Looper,UChar_t>(newtype, conf );
2816 break;
2817 case TStreamerInfo::kUShort:
2818 return GetConvertCollectionReadActionFrom<Looper,UShort_t>(newtype, conf );
2819 break;
2820 case TStreamerInfo::kUInt:
2821 return GetConvertCollectionReadActionFrom<Looper,UInt_t>(newtype, conf );
2822 break;
2823 case TStreamerInfo::kULong:
2824 return GetConvertCollectionReadActionFrom<Looper,ULong_t>(newtype, conf );
2825 break;
2826 case TStreamerInfo::kULong64:
2827 return GetConvertCollectionReadActionFrom<Looper,ULong64_t>(newtype, conf );
2828 break;
2829 case TStreamerInfo::kFloat16:
2830 return GetConvertCollectionReadActionFrom<Looper,NoFactorMarker<Float16_t> >( newtype, conf );
2831 break;
2832 case TStreamerInfo::kDouble32:
2833 return GetConvertCollectionReadActionFrom<Looper,NoFactorMarker<Double32_t> >( newtype, conf );
2834 break;
2835 case TStreamerInfo::kBits:
2836 Error("GetConvertCollectionReadAction","There is no support for kBits outside of a TObject.");
2837 break;
2838 default:
2839 break;
2840 }
2841 Error("GetConvertCollectionReadAction", "UNEXPECTED: oldtype == %d", oldtype);
2842 R__ASSERT(0); // We should never be here
2843 return TConfiguredAction();
2844}
2845
2846template <class Looper>
2847static TConfiguredAction GetCollectionReadAction(TVirtualStreamerInfo *info, TStreamerElement *element, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset)
2848{
2849 switch (type) {
2850 // Read basic types.
2851 case TStreamerInfo::kBool: return TConfiguredAction( Looper::template ReadBasicType<Bool_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2852 case TStreamerInfo::kChar: return TConfiguredAction( Looper::template ReadBasicType<Char_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2853 case TStreamerInfo::kShort: return TConfiguredAction( Looper::template ReadBasicType<Short_t>,new TConfiguration(info,i,compinfo,offset) ); break;
2854 case TStreamerInfo::kInt: return TConfiguredAction( Looper::template ReadBasicType<Int_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2855 case TStreamerInfo::kLong: return TConfiguredAction( Looper::template ReadBasicType<Long_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2856 case TStreamerInfo::kLong64: return TConfiguredAction( Looper::template ReadBasicType<Long64_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2857 case TStreamerInfo::kFloat: return TConfiguredAction( Looper::template ReadBasicType<Float_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2858 case TStreamerInfo::kDouble: return TConfiguredAction( Looper::template ReadBasicType<Double_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2859 case TStreamerInfo::kUChar: return TConfiguredAction( Looper::template ReadBasicType<UChar_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2860 case TStreamerInfo::kUShort: return TConfiguredAction( Looper::template ReadBasicType<UShort_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2861 case TStreamerInfo::kUInt: return TConfiguredAction( Looper::template ReadBasicType<UInt_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2862 case TStreamerInfo::kULong: return TConfiguredAction( Looper::template ReadBasicType<ULong_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2863 case TStreamerInfo::kULong64: return TConfiguredAction( Looper::template ReadBasicType<ULong64_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2864 case TStreamerInfo::kBits: return TConfiguredAction( Looper::template ReadAction<TStreamerInfoActions::ReadBasicType<BitsMarker> > , new TBitsConfiguration(info,i,compinfo,offset) ); break;
2865 case TStreamerInfo::kFloat16: {
2866 if (element->GetFactor() != 0) {
2867 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<float> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2868 } else {
2869 Int_t nbits = (Int_t)element->GetXmin();
2870 if (!nbits) nbits = 12;
2871 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<float> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
2872 }
2873 break;
2874 }
2875 case TStreamerInfo::kDouble32: {
2876 if (element->GetFactor() != 0) {
2877 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_WithFactor<double> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2878 } else {
2879 Int_t nbits = (Int_t)element->GetXmin();
2880 if (!nbits) {
2881 return TConfiguredAction( Looper::template ReadAction<ConvertBasicType<float,double>::Action >, new TConfiguration(info,i,compinfo,offset) );
2882 } else {
2883 return TConfiguredAction( Looper::template ReadAction<ReadBasicType_NoFactor<double> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
2884 }
2885 }
2886 break;
2887 }
2888 case TStreamerInfo::kTNamed: return TConfiguredAction( Looper::template ReadAction<ReadTNamed >, new TConfiguration(info,i,compinfo,offset) ); break;
2889 // Idea: We should calculate the CanIgnoreTObjectStreamer here and avoid calling the
2890 // Streamer alltogether.
2891 case TStreamerInfo::kTObject: return TConfiguredAction( Looper::template ReadAction<ReadTObject >, new TConfiguration(info,i,compinfo,offset) ); break;
2892 case TStreamerInfo::kTString: return TConfiguredAction( Looper::template ReadAction<ReadTString >, new TConfiguration(info,i,compinfo,offset) ); break;
2893 case TStreamerInfo::kArtificial:
2894 case TStreamerInfo::kCacheNew:
2895 case TStreamerInfo::kCacheDelete:
2896 case TStreamerInfo::kSTL: return TConfiguredAction( Looper::GenericRead, new TGenericConfiguration(info,i,compinfo) ); break;
2897 case TStreamerInfo::kBase: return TConfiguredAction( Looper::ReadBase, new TGenericConfiguration(info,i,compinfo) ); break;
2898
2899 // Conversions.
2900 case TStreamerInfo::kConv + TStreamerInfo::kBool:
2901 return GetCollectionReadConvertAction<Looper,Bool_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2902 break;
2903 case TStreamerInfo::kConv + TStreamerInfo::kChar:
2904 return GetCollectionReadConvertAction<Looper,Char_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2905 break;
2906 case TStreamerInfo::kConv + TStreamerInfo::kShort:
2907 return GetCollectionReadConvertAction<Looper,Short_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2908 break;
2909 case TStreamerInfo::kConv + TStreamerInfo::kInt:
2910 return GetCollectionReadConvertAction<Looper,Int_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2911 break;
2912 case TStreamerInfo::kConv + TStreamerInfo::kLong:
2913 return GetCollectionReadConvertAction<Looper,Long_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2914 break;
2915 case TStreamerInfo::kConv + TStreamerInfo::kLong64:
2916 return GetCollectionReadConvertAction<Looper,Long64_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2917 break;
2918 case TStreamerInfo::kConv + TStreamerInfo::kFloat:
2919 return GetCollectionReadConvertAction<Looper,Float_t>( element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2920 break;
2921 case TStreamerInfo::kConv + TStreamerInfo::kDouble:
2922 return GetCollectionReadConvertAction<Looper,Double_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2923 break;
2924 case TStreamerInfo::kConv + TStreamerInfo::kUChar:
2925 return GetCollectionReadConvertAction<Looper,UChar_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2926 break;
2927 case TStreamerInfo::kConv + TStreamerInfo::kUShort:
2928 return GetCollectionReadConvertAction<Looper,UShort_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2929 break;
2930 case TStreamerInfo::kConv + TStreamerInfo::kUInt:
2931 return GetCollectionReadConvertAction<Looper,UInt_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2932 break;
2933 case TStreamerInfo::kConv + TStreamerInfo::kULong:
2934 return GetCollectionReadConvertAction<Looper,ULong_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2935 break;
2936 case TStreamerInfo::kConv + TStreamerInfo::kULong64:
2937 return GetCollectionReadConvertAction<Looper,ULong64_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2938 break;
2939 case TStreamerInfo::kConv + TStreamerInfo::kBits:
2940 return GetCollectionReadConvertAction<Looper,BitsMarker>(element->GetNewType(), new TBitsConfiguration(info,i,compinfo,offset) );
2941 break;
2942 case TStreamerInfo::kConv + TStreamerInfo::kFloat16: {
2943 if (element->GetFactor() != 0) {
2944 return GetCollectionReadConvertAction<Looper,WithFactorMarker<float> >(element->GetNewType(), new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2945 } else {
2946 Int_t nbits = (Int_t)element->GetXmin();
2947 if (!nbits) nbits = 12;
2948 return GetCollectionReadConvertAction<Looper,NoFactorMarker<float> >(element->GetNewType(), new TConfNoFactor(info,i,compinfo,offset,nbits) );
2949 }
2950 break;
2951 }
2952 case TStreamerInfo::kConv + TStreamerInfo::kDouble32: {
2953 if (element->GetFactor() != 0) {
2954 return GetCollectionReadConvertAction<Looper,WithFactorMarker<double> >(element->GetNewType(), new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
2955 } else {
2956 Int_t nbits = (Int_t)element->GetXmin();
2957 if (!nbits) {
2958 return GetCollectionReadConvertAction<Looper,Float_t>(element->GetNewType(), new TConfiguration(info,i,compinfo,offset) );
2959 } else {
2960 return GetCollectionReadConvertAction<Looper,NoFactorMarker<double> >(element->GetNewType(), new TConfNoFactor(info,i,compinfo,offset,nbits) );
2961 }
2962 }
2963 break;
2964 }
2965 default:
2966 return TConfiguredAction( Looper::GenericRead, new TGenericConfiguration(info,i,compinfo) );
2967 break;
2968 }
2969 R__ASSERT(0); // We should never be here
2970 return TConfiguredAction();
2971}
2972
2973template <class Looper>
2974static TConfiguredAction GetCollectionWriteAction(TVirtualStreamerInfo *info, TStreamerElement * /*element*/, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset) {
2975 switch (type) {
2976 // read basic types
2977 case TStreamerInfo::kBool: return TConfiguredAction( Looper::template WriteBasicType<Bool_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2978 case TStreamerInfo::kChar: return TConfiguredAction( Looper::template WriteBasicType<Char_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2979 case TStreamerInfo::kShort: return TConfiguredAction( Looper::template WriteBasicType<Short_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2980 case TStreamerInfo::kInt: return TConfiguredAction( Looper::template WriteBasicType<Int_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2981 case TStreamerInfo::kLong: return TConfiguredAction( Looper::template WriteBasicType<Long_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2982 case TStreamerInfo::kLong64: return TConfiguredAction( Looper::template WriteBasicType<Long64_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2983 case TStreamerInfo::kFloat: return TConfiguredAction( Looper::template WriteBasicType<Float_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2984 case TStreamerInfo::kDouble: return TConfiguredAction( Looper::template WriteBasicType<Double_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2985 case TStreamerInfo::kUChar: return TConfiguredAction( Looper::template WriteBasicType<UChar_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2986 case TStreamerInfo::kUShort: return TConfiguredAction( Looper::template WriteBasicType<UShort_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2987 case TStreamerInfo::kUInt: return TConfiguredAction( Looper::template WriteBasicType<UInt_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2988 case TStreamerInfo::kULong: return TConfiguredAction( Looper::template WriteBasicType<ULong_t>, new TConfiguration(info,i,compinfo,offset) ); break;
2989 case TStreamerInfo::kULong64: return TConfiguredAction( Looper::template WriteBasicType<ULong64_t>,new TConfiguration(info,i,compinfo,offset) ); break;
2990 // the simple type missing are kBits and kCounter.
2991 default:
2992 return TConfiguredAction( Looper::GenericWrite, new TConfiguration(info,i,compinfo,0 /* 0 because we call the legacy code */) );
2993 }
2994 R__ASSERT(0); // We should never be here
2995 return TConfiguredAction();
2996}
2997
2998
2999////////////////////////////////////////////////////////////////////////////////
3000/// loop on the TStreamerElement list
3001/// regroup members with same type
3002/// Store predigested information into local arrays. This saves a huge amount
3003/// of time compared to an explicit iteration on all elements.
3004
3005void TStreamerInfo::Compile()
3006{
3007 if (IsCompiled()) {
3008 //Error("Compile","can only be called once; this first call generates both the optimized and memberwise actions.");
3009 return;
3010 }
3011 R__LOCKGUARD(gInterpreterMutex);
3012
3013 // fprintf(stderr,"Running Compile for %s %d %d req=%d,%d\n",GetName(),fClassVersion,fOptimized,CanOptimize(),TestBit(kCannotOptimize));
3014
3015 // if (IsCompiled() && (!fOptimized || (CanOptimize() && !TestBit(kCannotOptimize)))) return;
3016 fOptimized = kFALSE;
3017 fNdata = 0;
3018 fNfulldata = 0;
3019
3020 TObjArray* infos = (TObjArray*) gROOT->GetListOfStreamerInfo();
3021 if (fNumber < 0) {
3022 ++fgCount;
3023 fNumber = fgCount;
3024 }
3025 if (fNumber >= infos->GetSize()) {
3026 infos->AddAtAndExpand(this, fNumber);
3027 } else {
3028 if (!infos->At(fNumber)) {
3029 infos->AddAt(this, fNumber);
3030 }
3031 }
3032
3033 assert(fComp == 0 && fCompFull == 0 && fCompOpt == 0);
3034
3035
3036 Int_t ndata = fElements->GetEntriesFast();
3037
3038
3039 if (fReadObjectWise) fReadObjectWise->fActions.clear();
3040 else fReadObjectWise = new TStreamerInfoActions::TActionSequence(this,ndata);
3041
3042 if (fWriteObjectWise) fWriteObjectWise->fActions.clear();
3043 else fWriteObjectWise = new TStreamerInfoActions::TActionSequence(this,ndata);
3044
3045 if (fReadMemberWise) fReadMemberWise->fActions.clear();
3046 else fReadMemberWise = new TStreamerInfoActions::TActionSequence(this,ndata);
3047
3048 if (fReadText) fReadText->fActions.clear();
3049 else fReadText = new TStreamerInfoActions::TActionSequence(this,ndata);
3050
3051 if (fWriteMemberWise) fWriteMemberWise->fActions.clear();
3052 else fWriteMemberWise = new TStreamerInfoActions::TActionSequence(this,ndata);
3053
3054 if (fReadMemberWiseVecPtr) fReadMemberWiseVecPtr->fActions.clear();
3055 else fReadMemberWiseVecPtr = new TStreamerInfoActions::TActionSequence(this, ndata, kTRUE);
3056
3057 if (fWriteMemberWiseVecPtr) fWriteMemberWiseVecPtr->fActions.clear();
3058 else fWriteMemberWiseVecPtr = new TStreamerInfoActions::TActionSequence(this, ndata, kTRUE);
3059
3060 if (fWriteText) fWriteText->fActions.clear();
3061 else fWriteText = new TStreamerInfoActions::TActionSequence(this,ndata);
3062
3063 if (!ndata) {
3064 // This may be the case for empty classes (e.g., TAtt3D).
3065 // We still need to properly set the size of emulated classes (i.e. add the virtual table)
3066 if (fClass->TestBit(TClass::kIsEmulation) && fNVirtualInfoLoc!=0) {
3067 fSize = sizeof(TStreamerInfo*);
3068 }
3069 fComp = new TCompInfo[1];
3070 fCompFull = new TCompInfo*[1];
3071 fCompOpt = new TCompInfo*[1];
3072 fCompOpt[0] = fCompFull[0] = &(fComp[0]);
3073 SetIsCompiled();
3074 return;
3075 }
3076
3077 // At most half of the elements can be used to hold optimized versions.
3078 // We use the bottom to hold the optimized-into elements and the non-optimized elements
3079 // and the top to hold the original copy of the optimized out elements.
3080 fNslots = ndata + ndata/2 + 1;
3081 Int_t optiOut = 0;
3082
3083 fComp = new TCompInfo[fNslots];
3084 fCompFull = new TCompInfo*[ndata];
3085 fCompOpt = new TCompInfo*[ndata];
3086
3087 TStreamerElement* element;
3088 TStreamerElement* previous = 0;
3089 Int_t keep = -1;
3090 Int_t i;
3091
3092 if (!CanOptimize()) {
3093 SetBit(kCannotOptimize);
3094 }
3095
3096 Bool_t isOptimized = kFALSE;
3097 Bool_t previousOptimized = kFALSE;
3098
3099 for (i = 0; i < ndata; ++i) {
3100 element = (TStreamerElement*) fElements->At(i);
3101 if (!element) {
3102 break;
3103 }
3104
3105 Int_t asize = element->GetSize();
3106 if (element->GetArrayLength()) {
3107 asize /= element->GetArrayLength();
3108 }
3109 fComp[fNdata].fType = element->GetType();
3110 fComp[fNdata].fNewType = element->GetNewType();
3111 fComp[fNdata].fOffset = element->GetOffset();
3112 fComp[fNdata].fLength = element->GetArrayLength();
3113 fComp[fNdata].fElem = element;
3114 fComp[fNdata].fMethod = element->GetMethod();
3115 fComp[fNdata].fClass = element->GetClassPointer();
3116 fComp[fNdata].fNewClass = element->GetNewClass();
3117 fComp[fNdata].fClassName = TString(element->GetTypeName()).Strip(TString::kTrailing, '*');
3118 fComp[fNdata].fStreamer = element->GetStreamer();
3119
3120 // try to group consecutive members of the same type
3121 if (!TestBit(kCannotOptimize)
3122 && (keep >= 0)
3123 && (element->GetType() > 0)
3124 && (element->GetType() < 10)
3125 && (fComp[fNdata].fType == fComp[fNdata].fNewType)
3126 && (fComp[keep].fMethod == 0)
3127 && (element->GetArrayDim() == 0)
3128 && (fComp[keep].fType < kObject)
3129 && (fComp[keep].fType != kCharStar) /* do not optimize char* */
3130 && (element->GetType() == (fComp[keep].fType%kRegrouped))
3131 && ((element->GetOffset()-fComp[keep].fOffset) == (fComp[keep].fLength)*asize)
3132 && ((fOldVersion<6) || !previous || /* In version of TStreamerInfo less than 6, the Double32_t were merged even if their annotation (aka factor) were different */
3133 ((element->GetFactor() == previous->GetFactor())
3134 && (element->GetXmin() == previous->GetXmin())
3135 && (element->GetXmax() == previous->GetXmax())
3136 )
3137 )
3138 && (element->TestBit(TStreamerElement::kCache) == previous->TestBit(TStreamerElement::kCache))
3139 && (element->TestBit(TStreamerElement::kWrite) == previous->TestBit(TStreamerElement::kWrite))
3140 // kWholeObject and kDoNotDelete do not apply to numerical elements.
3141 )
3142 {
3143 if (!previousOptimized) {
3144 // The element was not yet optimized we first need to copy it into
3145 // the set of original copies.
3146 fComp[fNslots - (++optiOut) ] = fComp[keep]; // Copy the optimized out elements.
3147 fCompFull[fNfulldata-1] = &(fComp[fNslots - optiOut]); // Reset the pointer in the full list.
3148 }
3149 fComp[fNslots - (++optiOut) ] = fComp[fNdata]; // Copy the optimized out elements.
3150 fCompFull[fNfulldata] = &(fComp[fNslots - optiOut]);
3151
3152 R__ASSERT( keep < (fNslots - optiOut) );
3153
3154 if (fComp[keep].fLength == 0) {
3155 fComp[keep].fLength++;
3156 }
3157 fComp[keep].fLength++;
3158 fComp[keep].fType = element->GetType() + kRegrouped;
3159 isOptimized = kTRUE;
3160 previousOptimized = kTRUE;
3161 } else if (element->GetType() < 0) {
3162
3163 // -- Deal with an ignored TObject base class.
3164 // Note: The only allowed negative value here is -1,
3165 // and signifies that Build() has found a TObject
3166 // base class and TClass::IgnoreTObjectStreamer() was
3167 // called. In this case the compiled version of the
3168 // elements omits the TObject base class element,
3169 // which has to be compensated for by TTree::Bronch()
3170 // when it is making branches for a split object.
3171 fComp[fNslots - (++optiOut) ] = fComp[fNdata]; // Copy the 'ignored' element.
3172 fCompFull[fNfulldata] = &(fComp[fNslots - optiOut]);
3173 keep = -1;
3174 previousOptimized = kFALSE;
3175
3176 } else {
3177 if (fComp[fNdata].fNewType != fComp[fNdata].fType) {
3178 if (fComp[fNdata].fNewType > 0) {
3179 if ( (fComp[fNdata].fNewType == kObjectp || fComp[fNdata].fNewType == kAnyp
3180 || fComp[fNdata].fNewType == kObject || fComp[fNdata].fNewType == kAny
3181 || fComp[fNdata].fNewType == kTObject || fComp[fNdata].fNewType == kTNamed || fComp[fNdata].fNewType == kTString)
3182 && (fComp[fNdata].fType == kObjectp || fComp[fNdata].fType == kAnyp
3183 || fComp[fNdata].fType == kObject || fComp[fNdata].fType == kAny
3184 || fComp[fNdata].fType == kTObject || fComp[fNdata].fType == kTNamed || fComp[fNdata].fType == kTString )
3185 ) {
3186 fComp[fNdata].fType = fComp[fNdata].fNewType;
3187 } else if (fComp[fNdata].fType != kCounter) {
3188 fComp[fNdata].fType += kConv;
3189 }
3190 } else {
3191 if (fComp[fNdata].fType == kCounter) {
3192 Warning("Compile", "Counter %s should not be skipped from class %s", element->GetName(), GetName());
3193 }
3194 fComp[fNdata].fType += kSkip;
3195 }
3196 }
3197 fCompOpt[fNdata] = &(fComp[fNdata]);
3198 fCompFull[fNfulldata] = &(fComp[fNdata]);
3199
3200 R__ASSERT( fNdata < (fNslots - optiOut) );
3201
3202 keep = fNdata;
3203 if (fComp[keep].fLength == 0) {
3204 fComp[keep].fLength = 1;
3205 }
3206 fNdata++;
3207 previousOptimized = kFALSE;
3208 }
3209 // The test 'fMethod[keep] == 0' fails to detect a variable size array
3210 // if the counter happens to have an offset of zero, so let's explicitly
3211 // prevent for here.
3212 if (element->HasCounter()) keep = -1;
3213 ++fNfulldata;
3214 previous = element;
3215 }
3216
3217 for (i = 0; i < fNdata; ++i) {
3218 if (!fCompOpt[i]->fElem || fCompOpt[i]->fElem->GetType()< 0) {
3219 continue;
3220 }
3221 AddReadAction(fReadObjectWise, i, fCompOpt[i]);
3222 AddWriteAction(fWriteObjectWise, i, fCompOpt[i]);
3223 }
3224 for (i = 0; i < fNfulldata; ++i) {
3225 if (!fCompFull[i]->fElem || fCompFull[i]->fElem->GetType()< 0) {
3226 continue;
3227 }
3228 AddReadAction(fReadMemberWise, i, fCompFull[i]);
3229 AddWriteAction(fWriteMemberWise, i, fCompFull[i]);
3230 AddReadMemberWiseVecPtrAction(fReadMemberWiseVecPtr, i, fCompFull[i]);
3231 AddWriteMemberWiseVecPtrAction(fWriteMemberWiseVecPtr, i, fCompFull[i]);
3232
3233 AddReadTextAction(fReadText, i, fCompFull[i]);
3234 AddWriteTextAction(fWriteText, i, fCompFull[i]);
3235 }
3236 ComputeSize();
3237
3238 fOptimized = isOptimized;
3239 SetIsCompiled();
3240
3241 if (gDebug > 0) {
3242 ls();
3243 }
3244}
3245
3246template <typename From>
3247static void AddReadConvertAction(TStreamerInfoActions::TActionSequence *sequence, Int_t newtype, TConfiguration *conf)
3248{
3249 switch (newtype) {
3250 case TStreamerInfo::kBool: sequence->AddAction( ConvertBasicType<From,bool>::Action, conf ); break;
3251 case TStreamerInfo::kChar: sequence->AddAction( ConvertBasicType<From,char>::Action, conf ); break;
3252 case TStreamerInfo::kShort: sequence->AddAction( ConvertBasicType<From,short>::Action, conf ); break;
3253 case TStreamerInfo::kInt: sequence->AddAction( ConvertBasicType<From,Int_t>::Action, conf ); break;
3254 case TStreamerInfo::kLong: sequence->AddAction( ConvertBasicType<From,Long_t>::Action,conf ); break;
3255 case TStreamerInfo::kLong64: sequence->AddAction( ConvertBasicType<From,Long64_t>::Action, conf ); break;
3256 case TStreamerInfo::kFloat: sequence->AddAction( ConvertBasicType<From,float>::Action, conf ); break;
3257 case TStreamerInfo::kFloat16: sequence->AddAction( ConvertBasicType<From,float>::Action, conf ); break;
3258 case TStreamerInfo::kDouble: sequence->AddAction( ConvertBasicType<From,double>::Action, conf ); break;
3259 case TStreamerInfo::kDouble32:sequence->AddAction( ConvertBasicType<From,double>::Action, conf ); break;
3260 case TStreamerInfo::kUChar: sequence->AddAction( ConvertBasicType<From,UChar_t>::Action, conf ); break;
3261 case TStreamerInfo::kUShort: sequence->AddAction( ConvertBasicType<From,UShort_t>::Action, conf ); break;
3262 case TStreamerInfo::kUInt: sequence->AddAction( ConvertBasicType<From,UInt_t>::Action, conf ); break;
3263 case TStreamerInfo::kULong: sequence->AddAction( ConvertBasicType<From,ULong_t>::Action, conf ); break;
3264 case TStreamerInfo::kULong64: sequence->AddAction( ConvertBasicType<From,ULong64_t>::Action,conf ); break;
3265 case TStreamerInfo::kBits: sequence->AddAction( ConvertBasicType<From,UInt_t>::Action, conf ); break;
3266 }
3267}
3268
3269////////////////////////////////////////////////////////////////////////////////
3270/// Add a read action for the given element.
3271
3272void TStreamerInfo::AddReadAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3273{
3274 TStreamerElement *element = compinfo->fElem;
3275
3276 if (element->TestBit(TStreamerElement::kWrite)) return;
3277
3278 switch (compinfo->fType) {
3279 // read basic types
3280 case TStreamerInfo::kBool: readSequence->AddAction( ReadBasicType<Bool_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3281 case TStreamerInfo::kChar: readSequence->AddAction( ReadBasicType<Char_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3282 case TStreamerInfo::kShort: readSequence->AddAction( ReadBasicType<Short_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3283 case TStreamerInfo::kInt: readSequence->AddAction( ReadBasicType<Int_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3284 case TStreamerInfo::kLong: readSequence->AddAction( ReadBasicType<Long_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3285 case TStreamerInfo::kLong64: readSequence->AddAction( ReadBasicType<Long64_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3286 case TStreamerInfo::kFloat: readSequence->AddAction( ReadBasicType<Float_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3287 case TStreamerInfo::kDouble: readSequence->AddAction( ReadBasicType<Double_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3288 case TStreamerInfo::kUChar: readSequence->AddAction( ReadBasicType<UChar_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3289 case TStreamerInfo::kUShort: readSequence->AddAction( ReadBasicType<UShort_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3290 case TStreamerInfo::kUInt: readSequence->AddAction( ReadBasicType<UInt_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3291 case TStreamerInfo::kULong: readSequence->AddAction( ReadBasicType<ULong_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3292 case TStreamerInfo::kULong64: readSequence->AddAction( ReadBasicType<ULong64_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3293 case TStreamerInfo::kBits: readSequence->AddAction( ReadBasicType<BitsMarker>, new TBitsConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3294 case TStreamerInfo::kFloat16: {
3295 if (element->GetFactor() != 0) {
3296 readSequence->AddAction( ReadBasicType_WithFactor<float>, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3297 } else {
3298 Int_t nbits = (Int_t)element->GetXmin();
3299 if (!nbits) nbits = 12;
3300 readSequence->AddAction( ReadBasicType_NoFactor<float>, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3301 }
3302 break;
3303 }
3304 case TStreamerInfo::kDouble32: {
3305 if (element->GetFactor() != 0) {
3306 readSequence->AddAction( ReadBasicType_WithFactor<double>, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3307 } else {
3308 Int_t nbits = (Int_t)element->GetXmin();
3309 if (!nbits) {
3310 readSequence->AddAction( ConvertBasicType<float,double>::Action, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3311 } else {
3312 readSequence->AddAction( ReadBasicType_NoFactor<double>, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3313 }
3314 }
3315 break;
3316 }
3317 case TStreamerInfo::kTNamed: readSequence->AddAction( ReadTNamed, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3318 // Idea: We should calculate the CanIgnoreTObjectStreamer here and avoid calling the
3319 // Streamer alltogether.
3320 case TStreamerInfo::kTObject: readSequence->AddAction( ReadTObject, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3321 case TStreamerInfo::kTString: readSequence->AddAction( ReadTString, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3322 case TStreamerInfo::kSTL: {
3323 TClass *newClass = element->GetNewClass();
3324 TClass *oldClass = element->GetClassPointer();
3325 Bool_t isSTLbase = element->IsBase() && element->IsA()!=TStreamerBase::Class();
3326
3327 if (element->GetArrayLength() <= 1) {
3328 if (fOldVersion<3){ // case of old TStreamerInfo
3329 if (newClass && newClass != oldClass) {
3330 if (element->GetStreamer()) {
3331 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseStreamerV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3332 } else {
3333 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseFastArrayV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase));
3334 }
3335 } else {
3336 if (element->GetStreamer()) {
3337 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseStreamerV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3338 } else {
3339 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseFastArrayV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase));
3340 }
3341 }
3342 } else {
3343 if (newClass && newClass != oldClass) {
3344 if (element->GetStreamer()) {
3345 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3346 } else {
3347 if (oldClass->GetCollectionProxy() == 0 || oldClass->GetCollectionProxy()->GetValueClass() || oldClass->GetCollectionProxy()->HasPointers() ) {
3348 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseChangedClass,ReadSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase));
3349 } else {
3350 switch (SelectLooper(*newClass->GetCollectionProxy())) {
3351 case kVectorLooper:
3352 readSequence->AddAction(GetConvertCollectionReadAction<VectorLooper>(oldClass->GetCollectionProxy()->GetType(), newClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase)));
3353 break;
3354 case kAssociativeLooper:
3355 readSequence->AddAction(GetConvertCollectionReadAction<AssociativeLooper>(oldClass->GetCollectionProxy()->GetType(), newClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase)));
3356 break;
3357 case kVectorPtrLooper:
3358 case kGenericLooper:
3359 default:
3360 // For now TBufferXML would force use to allocate the data buffer each time and copy into the real thing.
3361 readSequence->AddAction(GetConvertCollectionReadAction<GenericLooper>(oldClass->GetCollectionProxy()->GetType(), newClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase)));
3362 break;
3363 }
3364 }
3365 }
3366 } else {
3367 if (element->GetStreamer()) {
3368 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3369 } else {
3370 if (oldClass->GetCollectionProxy() == 0 || oldClass->GetCollectionProxy()->GetValueClass() || oldClass->GetCollectionProxy()->HasPointers() ) {
3371 readSequence->AddAction(ReadSTL<ReadSTLMemberWiseSameClass,ReadSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase));
3372 } else {
3373 switch (SelectLooper(*oldClass->GetCollectionProxy())) {
3374 case kVectorLooper:
3375 readSequence->AddAction(GetNumericCollectionReadAction<VectorLooper>(oldClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase)));
3376 break;
3377 case kAssociativeLooper:
3378 readSequence->AddAction(GetNumericCollectionReadAction<AssociativeLooper>(oldClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase)));
3379 break;
3380 case kVectorPtrLooper:
3381 case kGenericLooper:
3382 default:
3383 // For now TBufferXML would force use to allocate the data buffer each time and copy into the real thing.
3384 readSequence->AddAction(GetNumericCollectionReadAction<GenericLooper>(oldClass->GetCollectionProxy()->GetType(), new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase)));
3385 break;
3386 }
3387 }
3388 }
3389 }
3390 }
3391 } else {
3392 if (fOldVersion<3){ // case of old TStreamerInfo
3393 if (newClass && newClass != oldClass) {
3394 if (element->GetStreamer()) {
3395 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseStreamerV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3396 } else {
3397 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseFastArrayV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetTypeName(),isSTLbase));
3398 }
3399 } else {
3400 if (element->GetStreamer()) {
3401 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseStreamerV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3402 } else {
3403 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseFastArrayV2>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetTypeName(),isSTLbase));
3404 }
3405 }
3406 } else {
3407 if (newClass && newClass != oldClass) {
3408 if (element->GetStreamer()) {
3409 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3410 } else {
3411 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseChangedClass,ReadSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetTypeName(),isSTLbase));
3412 }
3413 } else {
3414 if (element->GetStreamer()) {
3415 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3416 } else {
3417 readSequence->AddAction(ReadSTL<ReadArraySTLMemberWiseSameClass,ReadSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetTypeName(),isSTLbase));
3418 }
3419 }
3420 }
3421 }
3422 break;
3423 }
3424
3425 case TStreamerInfo::kConv + TStreamerInfo::kBool:
3426 AddReadConvertAction<Bool_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3427 break;
3428 case TStreamerInfo::kConv + TStreamerInfo::kChar:
3429 AddReadConvertAction<Char_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3430 break;
3431 case TStreamerInfo::kConv + TStreamerInfo::kShort:
3432 AddReadConvertAction<Short_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3433 break;
3434 case TStreamerInfo::kConv + TStreamerInfo::kInt:
3435 AddReadConvertAction<Int_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3436 break;
3437 case TStreamerInfo::kConv + TStreamerInfo::kLong:
3438 AddReadConvertAction<Long_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3439 break;
3440 case TStreamerInfo::kConv + TStreamerInfo::kLong64:
3441 AddReadConvertAction<Long64_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3442 break;
3443 case TStreamerInfo::kConv + TStreamerInfo::kFloat:
3444 AddReadConvertAction<Float_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3445 break;
3446 case TStreamerInfo::kConv + TStreamerInfo::kDouble:
3447 AddReadConvertAction<Double_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3448 break;
3449 case TStreamerInfo::kConv + TStreamerInfo::kUChar:
3450 AddReadConvertAction<UChar_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3451 break;
3452 case TStreamerInfo::kConv + TStreamerInfo::kUShort:
3453 AddReadConvertAction<UShort_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3454 break;
3455 case TStreamerInfo::kConv + TStreamerInfo::kUInt:
3456 AddReadConvertAction<UInt_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3457 break;
3458 case TStreamerInfo::kConv + TStreamerInfo::kULong:
3459 AddReadConvertAction<ULong_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3460 break;
3461 case TStreamerInfo::kConv + TStreamerInfo::kULong64:
3462 AddReadConvertAction<ULong64_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3463 break;
3464 case TStreamerInfo::kConv + TStreamerInfo::kBits:
3465 AddReadConvertAction<BitsMarker>(readSequence, compinfo->fNewType, new TBitsConfiguration(this,i,compinfo,compinfo->fOffset) );
3466 break;
3467 case TStreamerInfo::kConv + TStreamerInfo::kFloat16: {
3468 if (element->GetFactor() != 0) {
3469 AddReadConvertAction<WithFactorMarker<float> >(readSequence, compinfo->fNewType, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3470 } else {
3471 Int_t nbits = (Int_t)element->GetXmin();
3472 if (!nbits) nbits = 12;
3473 AddReadConvertAction<NoFactorMarker<float> >(readSequence, compinfo->fNewType, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3474 }
3475 break;
3476 }
3477 case TStreamerInfo::kConv + TStreamerInfo::kDouble32: {
3478 if (element->GetFactor() != 0) {
3479 AddReadConvertAction<WithFactorMarker<double> >(readSequence, compinfo->fNewType, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3480 } else {
3481 Int_t nbits = (Int_t)element->GetXmin();
3482 if (!nbits) {
3483 AddReadConvertAction<Float_t>(readSequence, compinfo->fNewType, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3484 } else {
3485 AddReadConvertAction<NoFactorMarker<double> >(readSequence, compinfo->fNewType, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3486 }
3487 }
3488 break;
3489 }
3490 default:
3491 readSequence->AddAction( GenericReadAction, new TGenericConfiguration(this,i,compinfo) );
3492 break;
3493 }
3494 if (element->TestBit(TStreamerElement::kCache)) {
3495 TConfiguredAction action( readSequence->fActions.back() ); // Action is moved, we must pop it next.
3496 readSequence->fActions.pop_back();
3497 readSequence->AddAction( UseCache, new TConfigurationUseCache(this,action,element->TestBit(TStreamerElement::kRepeat)) );
3498 }
3499}
3500
3501////////////////////////////////////////////////////////////////////////////////
3502/// Add a read text action for the given element.
3503
3504void TStreamerInfo::AddReadTextAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3505{
3506 TStreamerElement *element = compinfo->fElem;
3507
3508 if (element->TestBit(TStreamerElement::kWrite))
3509 return;
3510
3511 Bool_t generic = kFALSE, isBase = kFALSE;
3512
3513 switch (compinfo->fType) {
3514 case TStreamerInfo::kTObject:
3515 if (element->IsBase())
3516 isBase = kTRUE;
3517 // readSequence->AddAction( ReadTextTObjectBase, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3518 else
3519 readSequence->AddAction(ReadTextTObject, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3520 break;
3521
3522 case TStreamerInfo::kTNamed:
3523 if (element->IsBase())
3524 isBase = kTRUE;
3525 // generic = kTRUE; // for the base class one cannot call TClass::Streamer() as performed for the normal object
3526 else
3527 readSequence->AddAction(ReadTextTNamed, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3528 break;
3529
3530 case TStreamerInfo::kObject: // Class derived from TObject
3531 case TStreamerInfo::kAny: // Class NOT derived from TObject
3532 case TStreamerInfo::kOffsetL + TStreamerInfo::kObject:
3533 case TStreamerInfo::kAny + TStreamerInfo::kOffsetL:
3534 readSequence->AddAction(ReadTextObject, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3535 break;
3536
3537 case TStreamerInfo::kSTLp: // Pointer to container with no virtual table (stl) and no comment
3538 case TStreamerInfo::kSTLp +
3539 TStreamerInfo::kOffsetL: // array of pointers to container with no virtual table (stl) and no comment
3540 readSequence->AddAction(ReadSTLp<true>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3541 break;
3542
3543 case TStreamerInfo::kStreamLoop:
3544 case TStreamerInfo::kOffsetL + TStreamerInfo::kStreamLoop:
3545 readSequence->AddAction(ReadStreamerLoop<true>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3546 break;
3547
3548 case TStreamerInfo::kBase: isBase = kTRUE; break;
3549
3550 case TStreamerInfo::kStreamer:
3551 readSequence->AddAction(ReadTextStreamer, new TGenericConfiguration(this, i, compinfo));
3552 break;
3553
3554 default: generic = kTRUE; break;
3555 }
3556
3557 if (isBase) {
3558 if (compinfo->fStreamer) {
3559 readSequence->AddAction(ReadTextStreamer, new TGenericConfiguration(this, i, compinfo));
3560 } else {
3561 readSequence->AddAction(ReadTextBaseClass, new TGenericConfiguration(this, i, compinfo));
3562 }
3563 } else if (generic)
3564 readSequence->AddAction(GenericReadAction, new TGenericConfiguration(this, i, compinfo));
3565}
3566
3567////////////////////////////////////////////////////////////////////////////////
3568/// Add a read action for the given element.
3569/// This is for streaming via a TClonesArray (or a vector of pointers of this type).
3570
3571void TStreamerInfo::AddReadMemberWiseVecPtrAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3572{
3573 TStreamerElement *element = compinfo->fElem;
3574
3575 if (element->TestBit(TStreamerElement::kWrite)) return;
3576
3577 if (element->TestBit(TStreamerElement::kCache)) {
3578 TConfiguredAction action( GetCollectionReadAction<VectorLooper>(this,element,compinfo->fType,i,compinfo,compinfo->fOffset) );
3579 readSequence->AddAction( UseCacheVectorPtrLoop, new TConfigurationUseCache(this,action,element->TestBit(TStreamerElement::kRepeat)) );
3580 } else {
3581 readSequence->AddAction( GetCollectionReadAction<VectorPtrLooper>(this,element,compinfo->fType,i,compinfo,compinfo->fOffset) );
3582 }
3583}
3584
3585////////////////////////////////////////////////////////////////////////////////
3586
3587void TStreamerInfo::AddWriteAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3588{
3589 TStreamerElement *element = compinfo->fElem;
3590 if (element->TestBit(TStreamerElement::kCache) && !element->TestBit(TStreamerElement::kWrite)) {
3591 // Skip element cached for reading purposes.
3592 return;
3593 }
3594 if (element->GetType() >= kArtificial && !element->TestBit(TStreamerElement::kWrite)) {
3595 // Skip artificial element used for reading purposes.
3596 return;
3597 }
3598 switch (compinfo->fType) {
3599 // write basic types
3600 case TStreamerInfo::kBool: writeSequence->AddAction( WriteBasicType<Bool_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3601 case TStreamerInfo::kChar: writeSequence->AddAction( WriteBasicType<Char_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3602 case TStreamerInfo::kShort: writeSequence->AddAction( WriteBasicType<Short_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3603 case TStreamerInfo::kInt: writeSequence->AddAction( WriteBasicType<Int_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3604 case TStreamerInfo::kLong: writeSequence->AddAction( WriteBasicType<Long_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3605 case TStreamerInfo::kLong64: writeSequence->AddAction( WriteBasicType<Long64_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3606 case TStreamerInfo::kFloat: writeSequence->AddAction( WriteBasicType<Float_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3607 case TStreamerInfo::kDouble: writeSequence->AddAction( WriteBasicType<Double_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3608 case TStreamerInfo::kUChar: writeSequence->AddAction( WriteBasicType<UChar_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3609 case TStreamerInfo::kUShort: writeSequence->AddAction( WriteBasicType<UShort_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3610 case TStreamerInfo::kUInt: writeSequence->AddAction( WriteBasicType<UInt_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3611 case TStreamerInfo::kULong: writeSequence->AddAction( WriteBasicType<ULong_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3612 case TStreamerInfo::kULong64: writeSequence->AddAction( WriteBasicType<ULong64_t>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3613 // case TStreamerInfo::kBits: writeSequence->AddAction( WriteBasicType<BitsMarker>, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3614 /*case TStreamerInfo::kFloat16: {
3615 if (element->GetFactor() != 0) {
3616 writeSequence->AddAction( WriteBasicType_WithFactor<float>, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3617 } else {
3618 Int_t nbits = (Int_t)element->GetXmin();
3619 if (!nbits) nbits = 12;
3620 writeSequence->AddAction( WriteBasicType_NoFactor<float>, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3621 }
3622 break;
3623 } */
3624 /*case TStreamerInfo::kDouble32: {
3625 if (element->GetFactor() != 0) {
3626 writeSequence->AddAction( WriteBasicType_WithFactor<double>, new TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3627 } else {
3628 Int_t nbits = (Int_t)element->GetXmin();
3629 if (!nbits) {
3630 writeSequence->AddAction( ConvertBasicType<float,double>, new TConfiguration(this,i,compinfo,compinfo->fOffset) );
3631 } else {
3632 writeSequence->AddAction( WriteBasicType_NoFactor<double>, new TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3633 }
3634 }
3635 break;
3636 } */
3637 //case TStreamerInfo::kTNamed: writeSequence->AddAction( WriteTNamed, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3638 // Idea: We should calculate the CanIgnoreTObjectStreamer here and avoid calling the
3639 // Streamer alltogether.
3640 //case TStreamerInfo::kTObject: writeSequence->AddAction( WriteTObject, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3641 //case TStreamerInfo::kTString: writeSequence->AddAction( WriteTString, new TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3642 /*case TStreamerInfo::kSTL: {
3643 TClass *newClass = element->GetNewClass();
3644 TClass *oldClass = element->GetClassPointer();
3645 Bool_t isSTLbase = element->IsBase() && element->IsA()!=TStreamerBase::Class();
3646
3647 if (element->GetArrayLength() <= 1) {
3648 if (newClass && newClass != oldClass) {
3649 if (element->GetStreamer()) {
3650 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseChangedClass,WriteSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3651 } else {
3652 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseChangedClass,WriteSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase));
3653 }
3654 } else {
3655 if (element->GetStreamer()) {
3656 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseSameClass,WriteSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3657 } else {
3658 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseSameClass,WriteSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase));
3659 }
3660 }
3661 } else {
3662 if (newClass && newClass != oldClass) {
3663 if (element->GetStreamer()) {
3664 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseChangedClass,WriteSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3665 } else {
3666 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseChangedClass,WriteSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetTypeName(),isSTLbase));
3667 }
3668 } else {
3669 if (element->GetStreamer()) {
3670 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseSameClass,WriteSTLObjectWiseStreamer>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3671 } else {
3672 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseSameClass,WriteSTLObjectWiseFastArray>, new TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetTypeName(),isSTLbase));
3673 }
3674 }
3675 }
3676 break;
3677 } */
3678 default:
3679 writeSequence->AddAction( GenericWriteAction, new TGenericConfiguration(this,i,compinfo) );
3680 break;
3681 }
3682#if defined(CDJ_NO_COMPILE)
3683 if (element->TestBit(TStreamerElement::kCache)) {
3684 TConfiguredAction action( writeSequence->fActions.back() ); // Action is moved, we must pop it next.
3685 writeSequence->fActions.pop_back();
3686 writeSequence->AddAction( UseCache, new TConfigurationUseCache(this,action,element->TestBit(TStreamerElement::kRepeat)) );
3687 }
3688#endif
3689}
3690
3691////////////////////////////////////////////////////////////////////////////////
3692
3693void TStreamerInfo::AddWriteTextAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3694{
3695 TStreamerElement *element = compinfo->fElem;
3696 if (element->TestBit(TStreamerElement::kCache) && !element->TestBit(TStreamerElement::kWrite)) {
3697 // Skip element cached for reading purposes.
3698 return;
3699 }
3700 if (element->GetType() >= kArtificial && !element->TestBit(TStreamerElement::kWrite)) {
3701 // Skip artificial element used for reading purposes.
3702 return;
3703 }
3704
3705 Bool_t generic = kFALSE, isBase = kFALSE;
3706
3707 switch (compinfo->fType) {
3708 // write basic types
3709 case TStreamerInfo::kBool:
3710 writeSequence->AddAction(WriteBasicType<Bool_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3711 break;
3712 case TStreamerInfo::kChar:
3713 writeSequence->AddAction(WriteBasicType<Char_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3714 break;
3715 case TStreamerInfo::kShort:
3716 writeSequence->AddAction(WriteBasicType<Short_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3717 break;
3718 case TStreamerInfo::kInt:
3719 writeSequence->AddAction(WriteBasicType<Int_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3720 break;
3721 case TStreamerInfo::kLong:
3722 writeSequence->AddAction(WriteBasicType<Long_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3723 break;
3724 case TStreamerInfo::kLong64:
3725 writeSequence->AddAction(WriteBasicType<Long64_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3726 break;
3727 case TStreamerInfo::kFloat:
3728 writeSequence->AddAction(WriteBasicType<Float_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3729 break;
3730 case TStreamerInfo::kDouble:
3731 writeSequence->AddAction(WriteBasicType<Double_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3732 break;
3733 case TStreamerInfo::kUChar:
3734 writeSequence->AddAction(WriteBasicType<UChar_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3735 break;
3736 case TStreamerInfo::kUShort:
3737 writeSequence->AddAction(WriteBasicType<UShort_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3738 break;
3739 case TStreamerInfo::kUInt:
3740 writeSequence->AddAction(WriteBasicType<UInt_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3741 break;
3742 case TStreamerInfo::kULong:
3743 writeSequence->AddAction(WriteBasicType<ULong_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3744 break;
3745 case TStreamerInfo::kULong64:
3746 writeSequence->AddAction(WriteBasicType<ULong64_t>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3747 break;
3748
3749 case TStreamerInfo::kTObject:
3750 if (element->IsBase())
3751 isBase = kTRUE;
3752 else
3753 writeSequence->AddAction(WriteTextTObject, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3754 break;
3755
3756 case TStreamerInfo::kTNamed:
3757 if (element->IsBase())
3758 isBase = kTRUE;
3759 else
3760 writeSequence->AddAction(WriteTextTNamed, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3761 break;
3762
3763 case TStreamerInfo::kSTLp: // Pointer to container with no virtual table (stl) and no comment
3764 case TStreamerInfo::kSTLp +
3765 TStreamerInfo::kOffsetL: // array of pointers to container with no virtual table (stl) and no comment
3766 writeSequence->AddAction(WriteSTLp<true>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3767 break;
3768
3769 case TStreamerInfo::kStreamLoop:
3770 case TStreamerInfo::kOffsetL + TStreamerInfo::kStreamLoop:
3771 writeSequence->AddAction(WriteStreamerLoop<true>, new TConfiguration(this, i, compinfo, compinfo->fOffset));
3772 break;
3773
3774 case TStreamerInfo::kBase: isBase = kTRUE; break;
3775
3776 case TStreamerInfo::kStreamer:
3777 writeSequence->AddAction(WriteTextStreamer, new TGenericConfiguration(this, i, compinfo));
3778 break;
3779
3780 // case TStreamerInfo::kBits: writeSequence->AddAction( WriteBasicType<BitsMarker>, new
3781 // TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3782 /*case TStreamerInfo::kFloat16: {
3783 if (element->GetFactor() != 0) {
3784 writeSequence->AddAction( WriteBasicType_WithFactor<float>, new
3785 TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3786 } else {
3787 Int_t nbits = (Int_t)element->GetXmin();
3788 if (!nbits) nbits = 12;
3789 writeSequence->AddAction( WriteBasicType_NoFactor<float>, new
3790 TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3791 }
3792 break;
3793 } */
3794 /*case TStreamerInfo::kDouble32: {
3795 if (element->GetFactor() != 0) {
3796 writeSequence->AddAction( WriteBasicType_WithFactor<double>, new
3797 TConfWithFactor(this,i,compinfo,compinfo->fOffset,element->GetFactor(),element->GetXmin()) );
3798 } else {
3799 Int_t nbits = (Int_t)element->GetXmin();
3800 if (!nbits) {
3801 writeSequence->AddAction( ConvertBasicType<float,double>, new
3802 TConfiguration(this,i,compinfo,compinfo->fOffset) );
3803 } else {
3804 writeSequence->AddAction( WriteBasicType_NoFactor<double>, new
3805 TConfNoFactor(this,i,compinfo,compinfo->fOffset,nbits) );
3806 }
3807 }
3808 break;
3809 } */
3810 // case TStreamerInfo::kTNamed: writeSequence->AddAction( WriteTNamed, new
3811 // TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3812 // Idea: We should calculate the CanIgnoreTObjectStreamer here and avoid calling the
3813 // Streamer alltogether.
3814 // case TStreamerInfo::kTObject: writeSequence->AddAction( WriteTObject, new
3815 // TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3816 // case TStreamerInfo::kTString: writeSequence->AddAction( WriteTString, new
3817 // TConfiguration(this,i,compinfo,compinfo->fOffset) ); break;
3818 /*case TStreamerInfo::kSTL: {
3819 TClass *newClass = element->GetNewClass();
3820 TClass *oldClass = element->GetClassPointer();
3821 Bool_t isSTLbase = element->IsBase() && element->IsA()!=TStreamerBase::Class();
3822
3823 if (element->GetArrayLength() <= 1) {
3824 if (newClass && newClass != oldClass) {
3825 if (element->GetStreamer()) {
3826 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseChangedClass,WriteSTLObjectWiseStreamer>, new
3827 TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3828 } else {
3829 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseChangedClass,WriteSTLObjectWiseFastArray>, new
3830 TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,newClass,element->GetTypeName(),isSTLbase));
3831 }
3832 } else {
3833 if (element->GetStreamer()) {
3834 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseSameClass,WriteSTLObjectWiseStreamer>, new
3835 TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3836 } else {
3837 writeSequence->AddAction(WriteSTL<WriteSTLMemberWiseSameClass,WriteSTLObjectWiseFastArray>, new
3838 TConfigSTL(this,i,compinfo,compinfo->fOffset,1,oldClass,element->GetTypeName(),isSTLbase));
3839 }
3840 }
3841 } else {
3842 if (newClass && newClass != oldClass) {
3843 if (element->GetStreamer()) {
3844 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseChangedClass,WriteSTLObjectWiseStreamer>, new
3845 TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3846 } else {
3847 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseChangedClass,WriteSTLObjectWiseFastArray>, new
3848 TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,newClass,element->GetTypeName(),isSTLbase));
3849 }
3850 } else {
3851 if (element->GetStreamer()) {
3852 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseSameClass,WriteSTLObjectWiseStreamer>, new
3853 TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetStreamer(),element->GetTypeName(),isSTLbase));
3854 } else {
3855 writeSequence->AddAction(WriteSTL<WriteArraySTLMemberWiseSameClass,WriteSTLObjectWiseFastArray>, new
3856 TConfigSTL(this,i,compinfo,compinfo->fOffset,element->GetArrayLength(),oldClass,element->GetTypeName(),isSTLbase));
3857 }
3858 }
3859 }
3860 break;
3861 } */
3862 default: generic = kTRUE; break;
3863 }
3864
3865 if (isBase) {
3866 if (compinfo->fStreamer) {
3867 writeSequence->AddAction(WriteTextStreamer, new TGenericConfiguration(this, i, compinfo));
3868 } else {
3869 writeSequence->AddAction(WriteTextBaseClass, new TGenericConfiguration(this, i, compinfo));
3870 }
3871
3872 } else
3873
3874 // use generic write action when special handling is not provided
3875 if (generic)
3876 writeSequence->AddAction(GenericWriteAction, new TGenericConfiguration(this, i, compinfo));
3877
3878#if defined(CDJ_NO_COMPILE)
3879 if (element->TestBit(TStreamerElement::kCache)) {
3880 TConfiguredAction action(writeSequence->fActions.back()); // Action is moved, we must pop it next.
3881 writeSequence->fActions.pop_back();
3882 writeSequence->AddAction(UseCache,
3883 new TConfigurationUseCache(this, action, element->TestBit(TStreamerElement::kRepeat)));
3884 }
3885#endif
3886}
3887
3888////////////////////////////////////////////////////////////////////////////////
3889/// This is for streaming via a TClonesArray (or a vector of pointers of this type).
3890
3891void TStreamerInfo::AddWriteMemberWiseVecPtrAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t i, TStreamerInfo::TCompInfo *compinfo)
3892{
3893 TStreamerElement *element = compinfo->fElem;
3894 if (element->TestBit(TStreamerElement::kCache) && !element->TestBit(TStreamerElement::kWrite)) {
3895 // Skip element cached for reading purposes.
3896 return;
3897 }
3898 if (element->GetType() >= kArtificial && !element->TestBit(TStreamerElement::kWrite)) {
3899 // Skip artificial element used for reading purposes.
3900 return;
3901 }
3902
3903#if defined(CDJ_NO_COMPILE)
3904 if (element->TestBit(TStreamerElement::kCache)) {
3905 TConfiguredAction action( GetCollectionWriteAction<VectorLooper>(this,element,compinfo->fType,i,compinfo,compinfo->fOffset) );
3906 writeSequence->AddAction( UseCacheVectorPtrLoop, new TConfigurationUseCache(this,action,element->TestBit(TStreamerElement::kRepeat)) );
3907 } else {
3908 writeSequence->Addaction( GetCollectionWriteAction<VectorPtrLooper>(this,element,compinfo->fType,i,compinfo,compinfo->fOffset) );
3909 }
3910#else
3911 writeSequence->AddAction( VectorPtrLooper::GenericWrite, new TGenericConfiguration(this,i,compinfo) );
3912#endif
3913
3914}
3915
3916////////////////////////////////////////////////////////////////////////////////
3917/// Create the bundle of the actions necessary for the streaming memberwise of the content described by 'info' into the collection described by 'proxy'
3918
3919TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
3920{
3921 if (info == 0) {
3922 return new TStreamerInfoActions::TActionSequence(0,0);
3923 }
3924
3925 TStreamerInfo *sinfo = static_cast<TStreamerInfo*>(info);
3926
3927 UInt_t ndata = info->GetElements()->GetEntriesFast();
3928 TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(info,ndata);
3929 if (IsDefaultVector(proxy))
3930 {
3931 if (proxy.HasPointers()) {
3932 // Instead of the creating a new one let's copy the one from the StreamerInfo.
3933 delete sequence;
3934
3935 sequence = sinfo->GetReadMemberWiseActions(kTRUE)->CreateCopy();
3936
3937 return sequence;
3938 }
3939
3940 // We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
3941 Long_t increment = proxy.GetIncrement();
3942 sequence->fLoopConfig = new TVectorLoopConfig(&proxy, increment, /* read */ kTRUE);
3943 } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLunorderedset
3944 || proxy.GetCollectionType() == ROOT::kSTLmultiset || proxy.GetCollectionType() == ROOT::kSTLunorderedmultiset
3945 || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap
3946 || proxy.GetCollectionType() == ROOT::kSTLunorderedmap || proxy.GetCollectionType() == ROOT::kSTLunorderedmultimap)
3947 {
3948 Long_t increment = proxy.GetIncrement();
3949 sequence->fLoopConfig = new TVectorLoopConfig(&proxy, increment, /* read */ kTRUE);
3950 // sequence->fLoopConfig = new TAssocLoopConfig(proxy);
3951 } else {
3952 sequence->fLoopConfig = new TGenericLoopConfig(&proxy, /* read */ kTRUE);
3953 }
3954 for (UInt_t i = 0; i < ndata; ++i) {
3955 TStreamerElement *element = (TStreamerElement*) info->GetElements()->At(i);
3956 if (!element) {
3957 break;
3958 }
3959 if (element->GetType() < 0) {
3960 // -- Skip an ignored TObject base class.
3961 // Note: The only allowed negative value here is -1, and signifies that Build() has found a TObject
3962 // base class and TClass::IgnoreTObjectStreamer() was called. In this case the compiled version of the
3963 // elements omits the TObject base class element, which has to be compensated for by TTree::Bronch()
3964 // when it is making branches for a split object.
3965 continue;
3966 }
3967 if (element->TestBit(TStreamerElement::kWrite)) {
3968 // Skip element that only for writing.
3969 continue;
3970 }
3971 TStreamerBase *baseEl = dynamic_cast<TStreamerBase*>(element);
3972 if (baseEl) {
3973 if (!baseEl->TestBit(TStreamerElement::kWarned) && baseEl->GetErrorMessage()[0]) {
3974 // There was a problem with the checksum, the user likely did not
3975 // increment the version number of the derived class when the
3976 // base class changed. Since we will be member wise streaming
3977 // this class, let's warn the user that something is wrong.
3978 ::Warning("CreateReadMemberWiseActions","%s",
3979 baseEl->GetErrorMessage());
3980 baseEl->SetBit(TStreamerElement::kWarned);
3981 }
3982 }
3983
3984 TStreamerInfo::TCompInfo_t *compinfo = sinfo->fCompFull[i];
3985
3986 Int_t oldType = element->GetType();
3987 Int_t newType = element->GetNewType();
3988
3989 Int_t offset = element->GetOffset();
3990 if (newType != oldType) {
3991 if (newType > 0) {
3992 if (oldType != TVirtualStreamerInfo::kCounter) {
3993 oldType += TVirtualStreamerInfo::kConv;
3994 }
3995 } else {
3996 oldType += TVirtualStreamerInfo::kSkip;
3997 }
3998 }
3999 switch (SelectLooper(proxy)) {
4000 case kAssociativeLooper:
4001// } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
4002// || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) {
4003// sequence->AddAction( GenericAssocCollectionAction, new TConfigSTL(info,i,compinfo,offset,0,proxy.GetCollectionClass(),0,0) );
4004 case kVectorLooper:
4005 case kVectorPtrLooper:
4006 // We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
4007 if (element->TestBit(TStreamerElement::kCache)) {
4008 TConfiguredAction action( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4009 sequence->AddAction( UseCacheVectorLoop, new TConfigurationUseCache(info,action,element->TestBit(TStreamerElement::kRepeat)) );
4010 } else {
4011 sequence->AddAction( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset));
4012 }
4013 break;
4014 case kGenericLooper:
4015 default:
4016 // The usual collection case.
4017 if (element->TestBit(TStreamerElement::kCache)) {
4018 TConfiguredAction action( GetCollectionReadAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4019 sequence->AddAction( UseCacheGenericCollection, new TConfigurationUseCache(info,action,element->TestBit(TStreamerElement::kRepeat)) );
4020 } else {
4021 sequence->AddAction( GetCollectionReadAction<GenericLooper>(info,element,oldType,i,compinfo,offset) );
4022 }
4023 break;
4024 }
4025 }
4026 return sequence;
4027}
4028
4029////////////////////////////////////////////////////////////////////////////////
4030/// Create the bundle of the actions necessary for the streaming memberwise of the content described by 'info' into the collection described by 'proxy'
4031
4032TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
4033{
4034 if (info == 0) {
4035 return new TStreamerInfoActions::TActionSequence(0,0);
4036 }
4037
4038 UInt_t ndata = info->GetElements()->GetEntriesFast();
4039 TStreamerInfo *sinfo = static_cast<TStreamerInfo*>(info);
4040 TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(info,ndata);
4041
4042 if (IsDefaultVector(proxy))
4043 {
4044 if (proxy.HasPointers()) {
4045 // Instead of the creating a new one let's copy the one from the StreamerInfo.
4046 delete sequence;
4047
4048 sequence = sinfo->GetWriteMemberWiseActions(kTRUE)->CreateCopy();
4049
4050 return sequence;
4051 }
4052
4053 // We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
4054 Long_t increment = proxy.GetIncrement();
4055 sequence->fLoopConfig = new TVectorLoopConfig(&proxy, increment, /* read */ kFALSE);
4056 /*} else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
4057 || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap)
4058 {
4059 Long_t increment = proxy.GetIncrement();
4060 sequence->fLoopConfig = new TVectorLoopConfig(increment);
4061 // sequence->fLoopConfig = new TAssocLoopConfig(proxy); */
4062 } else {
4063 sequence->fLoopConfig = new TGenericLoopConfig(&proxy, /* read */ kFALSE);
4064 }
4065 for (UInt_t i = 0; i < ndata; ++i) {
4066 TStreamerElement *element = (TStreamerElement*) info->GetElements()->At(i);
4067 if (!element) {
4068 break;
4069 }
4070 if (element->GetType() < 0) {
4071 // -- Skip an ignored TObject base class.
4072 // Note: The only allowed negative value here is -1, and signifies that Build() has found a TObject
4073 // base class and TClass::IgnoreTObjectStreamer() was called. In this case the compiled version of the
4074 // elements omits the TObject base class element, which has to be compensated for by TTree::Bronch()
4075 // when it is making branches for a split object.
4076 continue;
4077 }
4078 if (element->TestBit(TStreamerElement::kCache) && !element->TestBit(TStreamerElement::kWrite)) {
4079 // Skip element cached for reading purposes.
4080 continue;
4081 }
4082 if (element->GetType() >= TVirtualStreamerInfo::kArtificial && !element->TestBit(TStreamerElement::kWrite)) {
4083 // Skip artificial element used for reading purposes.
4084 continue;
4085 }
4086 TStreamerInfo::TCompInfo *compinfo = sinfo->fCompFull[i];
4087 Int_t oldType = element->GetType();
4088 Int_t offset = element->GetOffset();
4089#if defined(CDJ_NO_COMPILE)
4090 Int_t newType = element->GetNewType();
4091
4092 if (newType != oldType) {
4093 if (newType > 0) {
4094 if (oldType != TVirtualStreamerInfo::kCounter) {
4095 oldType += TVirtualStreamerInfo::kConv;
4096 }
4097 } else {
4098 oldType += TVirtualStreamerInfo::kSkip;
4099 }
4100 }
4101 if ( IsDefaultVector(proxy)
4102 /*|| (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
4103 || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) */ )
4104 {
4105
4106 // We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
4107 if (element->TestBit(TStreamerElement::kCache)) {
4108 TConfiguredAction action( GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4109 sequence->AddAction( UseCacheVectorLoop, new TConfigurationUseCache(info,action,element->TestBit(TStreamerElement::kRepeat)) );
4110 } else {
4111 sequence->AddAction(GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset));
4112 }
4113
4114 // } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
4115 // || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) {
4116 // sequence->AddAction( GenericAssocCollectionAction, new TConfigSTL(info,i,compinfo,offset,0,proxy.GetCollectionClass(),0,0) );
4117 } else {
4118 // The usual collection case.
4119 if (element->TestBit(TStreamerElement::kCache)) {
4120 TConfiguredAction action( GetWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4121 sequence->AddAction( UseCacheGenericCollection, new TConfigurationUseCache(info,action,element->TestBit(TStreamerElement::kRepeat)) );
4122 } else {
4123 switch (oldType) {
4124 // read basic types
4125 case TVirtualStreamerInfo::kBool: sequence->AddAction( WriteBasicTypeGenericLoop<Bool_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4126 case TVirtualStreamerInfo::kChar: sequence->AddAction( WriteBasicTypeGenericLoop<Char_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4127 case TVirtualStreamerInfo::kShort: sequence->AddAction( WriteBasicTypeGenericLoop<Short_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4128 case TVirtualStreamerInfo::kInt: sequence->AddAction( WriteBasicTypeGenericLoop<Int_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4129 case TVirtualStreamerInfo::kLong: sequence->AddAction( WriteBasicTypeGenericLoop<Long_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4130 case TVirtualStreamerInfo::kLong64: sequence->AddAction( WriteBasicTypeGenericLoop<Long64_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4131 case TVirtualStreamerInfo::kFloat: sequence->AddAction( WriteBasicTypeGenericLoop<Float_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4132 case TVirtualStreamerInfo::kDouble: sequence->AddAction( WriteBasicTypeGenericLoop<Double_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4133 case TVirtualStreamerInfo::kUChar: sequence->AddAction( WriteBasicTypeGenericLoop<UChar_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4134 case TVirtualStreamerInfo::kUShort: sequence->AddAction( WriteBasicTypeGenericLoop<UShort_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4135 case TVirtualStreamerInfo::kUInt: sequence->AddAction( WriteBasicTypeGenericLoop<UInt_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4136 case TVirtualStreamerInfo::kULong: sequence->AddAction( WriteBasicTypeGenericLoop<ULong_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4137 case TVirtualStreamerInfo::kULong64: sequence->AddAction( WriteBasicTypeGenericLoop<ULong64_t>, new TConfiguration(info,i,compinfo,offset) ); break;
4138 // case TVirtualStreamerInfo::kBits: sequence->AddAction( WriteBasicTypeGenericLoop<BitsMarker>, new TConfiguration(info,i,compinfo,offset) ); break;
4139 case TVirtualStreamerInfo::kFloat16: {
4140 if (element->GetFactor() != 0) {
4141 sequence->AddAction( GenericLooper<WriteBasicType_WithFactor<float> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
4142 } else {
4143 Int_t nbits = (Int_t)element->GetXmin();
4144 if (!nbits) nbits = 12;
4145 sequence->AddAction( GenericLooper<WriteBasicType_NoFactor<float> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
4146 }
4147 break;
4148 }
4149 case TVirtualStreamerInfo::kDouble32: {
4150 if (element->GetFactor() != 0) {
4151 sequence->AddAction( GenericLooper<WriteBasicType_WithFactor<double> >, new TConfWithFactor(info,i,compinfo,offset,element->GetFactor(),element->GetXmin()) );
4152 } else {
4153 Int_t nbits = (Int_t)element->GetXmin();
4154 if (!nbits) {
4155 sequence->AddAction( GenericLooper<ConvertBasicType<float,double> >, new TConfiguration(info,i,compinfo,offset) );
4156 } else {
4157 sequence->AddAction( GenericLooper<WriteBasicType_NoFactor<double> >, new TConfNoFactor(info,i,compinfo,offset,nbits) );
4158 }
4159 }
4160 break;
4161 }
4162 case TVirtualStreamerInfo::kTNamed: sequence->AddAction( GenericLooper<WriteTNamed >, new TConfiguration(info,i,compinfo,offset) ); break;
4163 // Idea: We should calculate the CanIgnoreTObjectStreamer here and avoid calling the
4164 // Streamer alltogether.
4165 case TVirtualStreamerInfo::kTObject: sequence->AddAction( GenericLooper<WriteTObject >, new TConfiguration(info,i,compinfo,offset) ); break;
4166 case TVirtualStreamerInfo::kTString: sequence->AddAction( GenericLooper<WriteTString >, new TConfiguration(info,i,compinfo,offset) ); break;
4167 default:
4168 sequence->AddAction( GenericCollectionWriteAction, new TConfigSTL(info,i,0 /* the offset will be used from TStreamerInfo */,0,proxy.GetCollectionClass(),0,0) );
4169 break;
4170 }
4171 }
4172 }
4173#else
4174 if ( IsDefaultVector(proxy)
4175 /*|| (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
4176 || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap)*/ )
4177 {
4178 sequence->AddAction( GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,compinfo,offset) );
4179 } else {
4180 // NOTE: TBranch::FillLeavesCollection[Member] is not yet ready to handle the sequence
4181 // as it does not create/use a TStaging as expected ... but then again it might
4182 // not be the right things to expect ...
4183 // sequence->AddAction( GetCollectionWriteAction<GenericLooper>(info,element,oldType,i,compinfo,offset) );
4184 sequence->AddAction( GenericLooper::GenericWrite, new TConfigSTL(info,i,compinfo,0 /* the offset will be used from TStreamerInfo */,0,proxy.GetCollectionClass(),0,0) );
4185 }
4186#endif
4187 }
4188 return sequence;
4189}
4190
4191void TStreamerInfoActions::TActionSequence::AddToOffset(Int_t delta)
4192{
4193 // Add the (potentially negative) delta to all the configuration's offset. This is used by
4194 // TBranchElement in the case of split sub-object.
4195
4196 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4197 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4198 iter != end;
4199 ++iter)
4200 {
4201 // (fElemId == -1) indications that the action is a Push or Pop DataCache.
4202 if (iter->fConfiguration->fElemId != (UInt_t)-1 &&
4203 !iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4204 iter->fConfiguration->AddToOffset(delta);
4205 }
4206}
4207
4208void TStreamerInfoActions::TActionSequence::SetMissing()
4209{
4210 // Add the (potentially negative) delta to all the configuration's offset. This is used by
4211 // TBranchElement in the case of split sub-object.
4212
4213 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4214 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4215 iter != end;
4216 ++iter)
4217 {
4218 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4219 iter->fConfiguration->SetMissing();
4220 }
4221}
4222
4223TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::CreateCopy()
4224{
4225 // Create a copy of this sequence.
4226
4227 TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(fStreamerInfo, fActions.size(), IsForVectorPtrLooper());
4228
4229 sequence->fLoopConfig = fLoopConfig ? fLoopConfig->Copy() : 0;
4230
4231 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4232 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4233 iter != end;
4234 ++iter)
4235 {
4236 TConfiguration *conf = iter->fConfiguration->Copy();
4237 sequence->AddAction( iter->fAction, conf );
4238 }
4239 return sequence;
4240}
4241
4242void TStreamerInfoActions::TActionSequence::AddToSubSequence(TStreamerInfoActions::TActionSequence *sequence,
4243 const TStreamerInfoActions::TIDs &element_ids,
4244 Int_t offset,
4245 TStreamerInfoActions::TActionSequence::SequenceGetter_t create)
4246{
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,
4251 sequence->fLoopConfig ? sequence->fLoopConfig->GetCollectionProxy() : nullptr,
4252 nullptr);
4253 if (element_ids[id].fNestedIDs->fOnfileObject) {
4254 auto conf = new TConfigurationPushDataCache(element_ids[id].fNestedIDs->fInfo, element_ids[id].fNestedIDs->fOnfileObject, offset);
4255 if ( sequence->fLoopConfig )
4256 sequence->AddAction( PushDataCacheGenericCollection, conf );
4257 else if ( sequence->IsForVectorPtrLooper() )
4258 sequence->AddAction( PushDataCacheVectorPtr, conf );
4259 else
4260 sequence->AddAction( PushDataCache, conf );
4261 }
4262
4263 original->AddToSubSequence(sequence, element_ids[id].fNestedIDs->fIDs, element_ids[id].fNestedIDs->fOffset, create);
4264
4265 if (element_ids[id].fNestedIDs->fOnfileObject) {
4266 auto conf =
4267 new TConfigurationPushDataCache(element_ids[id].fNestedIDs->fInfo, nullptr, element_ids[id].fNestedIDs->fOffset);
4268 if ( sequence->fLoopConfig )
4269 sequence->AddAction( PopDataCacheGenericCollection, conf );
4270 else if ( sequence->IsForVectorPtrLooper() )
4271 sequence->AddAction( PopDataCacheVectorPtr, conf );
4272 else
4273 sequence->AddAction( PopDataCache, conf );
4274 }
4275 } else {
4276 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4277 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4278 iter != end;
4279 ++iter)
4280 {
4281 TConfiguration *conf = iter->fConfiguration->Copy();
4282 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4283 conf->AddToOffset(offset);
4284 sequence->AddAction( iter->fAction, conf );
4285 }
4286 }
4287 } else {
4288 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4289 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4290 iter != end;
4291 ++iter) {
4292 if ( iter->fConfiguration->fElemId == (UInt_t)element_ids[id].fElemID ) {
4293 TConfiguration *conf = iter->fConfiguration->Copy();
4294 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4295 conf->AddToOffset(offset);
4296 sequence->AddAction( iter->fAction, conf );
4297 }
4298 }
4299 }
4300 }
4301}
4302
4303TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::CreateSubSequence(const TIDs &element_ids, size_t offset,
4304 TStreamerInfoActions::TActionSequence::SequenceGetter_t create)
4305{
4306 // Create a sequence containing the subset of the action corresponding to the SteamerElement whose ids is contained in the vector.
4307 // 'offset' is the location of this 'class' within the object (address) that will be passed to ReadBuffer when using this sequence.
4308
4309 TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(fStreamerInfo, element_ids.size(), IsForVectorPtrLooper());
4310
4311 sequence->fLoopConfig = fLoopConfig ? fLoopConfig->Copy() : 0;
4312
4313 AddToSubSequence(sequence, element_ids, offset, create);
4314
4315 return sequence;
4316}
4317
4318TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::CreateSubSequence(const std::vector<Int_t> &element_ids, size_t offset)
4319{
4320 // Create a sequence containing the subset of the action corresponding to the SteamerElement whose ids is contained in the vector.
4321 // 'offset' is the location of this 'class' within the object (address) that will be passed to ReadBuffer when using this sequence.
4322
4323 TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(fStreamerInfo, element_ids.size(), IsForVectorPtrLooper());
4324
4325 sequence->fLoopConfig = fLoopConfig ? fLoopConfig->Copy() : 0;
4326
4327 for(UInt_t id = 0; id < element_ids.size(); ++id) {
4328 if ( element_ids[id] < 0 ) {
4329 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4330 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4331 iter != end;
4332 ++iter)
4333 {
4334 TConfiguration *conf = iter->fConfiguration->Copy();
4335 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4336 conf->AddToOffset(offset);
4337 sequence->AddAction( iter->fAction, conf );
4338 }
4339 } else {
4340 TStreamerInfoActions::ActionContainer_t::iterator end = fActions.end();
4341 for(TStreamerInfoActions::ActionContainer_t::iterator iter = fActions.begin();
4342 iter != end;
4343 ++iter) {
4344 if ( iter->fConfiguration->fElemId == (UInt_t)element_ids[id] ) {
4345 TConfiguration *conf = iter->fConfiguration->Copy();
4346 if (!iter->fConfiguration->fInfo->GetElements()->At(iter->fConfiguration->fElemId)->TestBit(TStreamerElement::kCache))
4347 conf->AddToOffset(offset);
4348 sequence->AddAction( iter->fAction, conf );
4349 }
4350 }
4351 }
4352 }
4353 return sequence;
4354}
4355
4356#if !defined(R__WIN32) && !defined(_AIX)
4357
4358#include <dlfcn.h>
4359
4360#endif
4361
4362typedef void (*voidfunc)();
4363static const char *R__GetSymbolName(voidfunc func)
4364{
4365#if defined(R__WIN32) || defined(__CYGWIN__) || defined(_AIX)
4366 return "not available on this platform";
4367#if 0
4368 MEMORY_BASIC_INFORMATION mbi;
4369 if (!VirtualQuery (func, &mbi, sizeof (mbi)))
4370 {
4371 return 0;
4372 }
4373
4374 HMODULE hMod = (HMODULE) mbi.AllocationBase;
4375 static char moduleName[MAX_PATH];
4376
4377 if (!GetModuleFileNameA (hMod, moduleName, sizeof (moduleName)))
4378 {
4379 return 0;
4380 }
4381 return moduleName;
4382#endif
4383#else
4384 Dl_info info;
4385 if (dladdr((void*)func,&info)==0) {
4386 // Not in a known share library, let's give up
4387 return "name not found";
4388 } else {
4389 //fprintf(stdout,"Found address in %s\n",info.dli_fname);
4390 return info.dli_sname;
4391 }
4392#endif
4393}
4394
4395void TStreamerInfoActions::TActionSequence::Print(Option_t *opt) const
4396{
4397 // Add the (potentially negative) delta to all the configuration's offset. This is used by
4398 // TTBranchElement in the case of split sub-object.
4399 // If opt contains 'func', also print the (mangled) name of the function that will be executed.
4400
4401 if (fLoopConfig) {
4402 fLoopConfig->Print();
4403 }
4404 TStreamerInfoActions::ActionContainer_t::const_iterator end = fActions.end();
4405 for(TStreamerInfoActions::ActionContainer_t::const_iterator iter = fActions.begin();
4406 iter != end;
4407 ++iter)
4408 {
4409 iter->fConfiguration->Print();
4410 if (strstr(opt,"func")) {
4411 printf("StreamerInfoAction func: %s\n",R__GetSymbolName((voidfunc)iter->fAction));
4412 }
4413 }
4414}
4415
4416
b
#define b(i)
Definition RSha256.hxx:100
create
virtual RooAbsTestStatistic * create(const char *name, const char *title, RooAbsReal &real, RooAbsData &data, const RooArgSet &projDeps, Configuration const &cfg)=0
UShort_t
unsigned short UShort_t
Definition RtypesCore.h:40
Int_t
int Int_t
Definition RtypesCore.h:45
kMaxInt
constexpr Int_t kMaxInt
Definition RtypesCore.h:112
Version_t
short Version_t
Definition RtypesCore.h:65
Long_t
long Long_t
Definition RtypesCore.h:54
UInt_t
unsigned int UInt_t
Definition RtypesCore.h:46
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
Option_t
const char Option_t
Definition RtypesCore.h:66
R__ASSERT
#define R__ASSERT(e)
Definition TError.h:118
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:185
Warning
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
Fatal
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
Definition TError.cxx:244
offset
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 offset
Definition TGWin32VirtualXProxy.cxx:245
r
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
Definition TGWin32VirtualXProxy.cxx:168
length
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 length
Definition TGWin32VirtualXProxy.cxx:245
id
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Definition TGWin32VirtualXProxy.cxx:94
type
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 Atom_t Time_t type
Definition TGWin32VirtualXProxy.cxx:249
xmin
float xmin
Definition THbookFile.cxx:95
gInterpreterMutex
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition TInterpreter.h:46
kIsReferenced
@ kIsReferenced
Definition TObject.h:372
gDebug
Int_t gDebug
Definition TROOT.cxx:595
gROOT
#define gROOT
Definition TROOT.h:406
GetNumericCollectionReadAction
static TConfiguredAction GetNumericCollectionReadAction(Int_t type, TConfigSTL *conf)
Definition TStreamerInfoActions.cxx:2703
voidfunc
void(* voidfunc)()
Definition TStreamerInfoActions.cxx:4362
AddReadConvertAction
static void AddReadConvertAction(TStreamerInfoActions::TActionSequence *sequence, Int_t newtype, TConfiguration *conf)
Definition TStreamerInfoActions.cxx:3247
GetCollectionReadConvertAction
static TConfiguredAction GetCollectionReadConvertAction(Int_t newtype, TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2675
GetCollectionReadAction
static TConfiguredAction GetCollectionReadAction(TVirtualStreamerInfo *info, TStreamerElement *element, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset)
Definition TStreamerInfoActions.cxx:2847
kRegrouped
static const Int_t kRegrouped
Definition TStreamerInfoActions.cxx:28
INLINE_TEMPLATE_ARGS
#define INLINE_TEMPLATE_ARGS
Definition TStreamerInfoActions.cxx:41
R__GetSymbolName
static const char * R__GetSymbolName(voidfunc func)
Definition TStreamerInfoActions.cxx:4363
GetConvertCollectionReadAction
static TConfiguredAction GetConvertCollectionReadAction(Int_t oldtype, Int_t newtype, TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2787
GetCollectionWriteAction
static TConfiguredAction GetCollectionWriteAction(TVirtualStreamerInfo *info, TStreamerElement *, Int_t type, UInt_t i, TStreamerInfo::TCompInfo_t *compinfo, Int_t offset)
Definition TStreamerInfoActions.cxx:2974
GetConvertCollectionReadActionFrom
static TConfiguredAction GetConvertCollectionReadActionFrom(Int_t newtype, TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2759
ReadBasicType
#define ReadBasicType(name)
Definition TStreamerInfoReadBuffer.cxx:61
WriteBasicType
#define WriteBasicType(name)
Definition TStreamerInfoWriteBuffer.cxx:38
ReadBuffer
void ReadBuffer(char *&buffer) override
R__LOCKGUARD
#define R__LOCKGUARD(mutex)
Definition TVirtualMutex.h:95
Float_t
TBufferFile::kStreamedMemberWise
@ kStreamedMemberWise
Definition TBufferFile.h:69
TBufferText
Base class for text-based streamers like TBufferJSON or TBufferXML Special actions list will use meth...
Definition TBufferText.h:20
TBuffer
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TBuffer::ReadWithNbits
virtual void ReadWithNbits(Float_t *ptr, Int_t nbits)=0
TBuffer::ReadWithFactor
virtual void ReadWithFactor(Float_t *ptr, Double_t factor, Double_t minvalue)=0
TBuffer::ReadVersion
virtual Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr)=0
TBuffer::ReadVersionForMemberWise
virtual Version_t ReadVersionForMemberWise(const TClass *cl=nullptr)=0
TBuffer::ReadProcessID
virtual TProcessID * ReadProcessID(UShort_t pidf)=0
Return the current Process-ID.
Definition TBuffer.cxx:344
TBuffer::WriteVersionMemberWise
virtual UInt_t WriteVersionMemberWise(const TClass *cl, Bool_t useBcnt=kFALSE)=0
TBuffer::SetByteCount
virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion=kFALSE)=0
TBuffer::ReadInt
virtual void ReadInt(Int_t &i)=0
TBuffer::GetParent
TObject * GetParent() const
Return pointer to parent of this buffer.
Definition TBuffer.cxx:262
TBuffer::GetPidOffset
virtual UShort_t GetPidOffset() const =0
TBuffer::kCannotHandleMemberWiseStreaming
@ kCannotHandleMemberWiseStreaming
Definition TBuffer.h:76
TBuffer::ReadFastArrayDouble32
virtual void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=nullptr)=0
TBuffer::CheckByteCount
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
TBuffer::ReadFastArray
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
TBuffer::ReadClassBuffer
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
TBuffer::ApplySequence
virtual Int_t ApplySequence(const TStreamerInfoActions::TActionSequence &sequence, void *object)=0
TBuffer::ReadFastArrayWithNbits
virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits)=0
TBuffer::SetBufferOffset
void SetBufferOffset(Int_t offset=0)
Definition TBuffer.h:93
TBuffer::WriteFastArray
virtual void WriteFastArray(const Bool_t *b, Long64_t n)=0
TBuffer::ReadFastArrayWithFactor
virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue)=0
TBuffer::WriteVersion
virtual UInt_t WriteVersion(const TClass *cl, Bool_t useBcnt=kFALSE)=0
TBuffer::ReadFastArrayFloat16
virtual void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=nullptr)=0
TBuffer::Length
Int_t Length() const
Definition TBuffer.h:100
TBuffer::StreamObject
virtual void StreamObject(void *obj, const std::type_info &typeinfo, const TClass *onFileClass=nullptr)=0
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
TClass::Streamer
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=nullptr) const
Definition TClass.h:603
TClass::CanSplit
Bool_t CanSplit() const
Return true if the data member of this TClass can be saved separately.
Definition TClass.cxx:2319
TClass::NewArray
void * NewArray(Long_t nElements, ENewType defConstructor=kClassNew) const
Return a pointer to a newly allocated array of objects of this class.
Definition TClass.cxx:5193
TClass::New
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
Definition TClass.cxx:4978
TClass::Size
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
TClass::DeleteArray
void DeleteArray(void *ary, Bool_t dtorOnly=kFALSE)
Explicitly call operator delete[] for an array.
Definition TClass.cxx:5529
TClass::GetStreamerInfo
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4599
TClass::GetCollectionProxy
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2897
TClass::GetConversionStreamerInfo
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...
Definition TClass.cxx:7086
TClass::kHasCustomStreamerMember
@ kHasCustomStreamerMember
Definition TClass.h:106
TClass::kIsEmulation
@ kIsEmulation
Definition TClass.h:102
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition TCollection.h:184
TFile
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:53
TFile::GetVersion
Int_t GetVersion() const
Definition TFile.h:245
TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
TNamed::GetTitle
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
TNamed::Class
static TClass * Class()
TObjArray
An array of TObjects.
Definition TObjArray.h:31
TObjArray::GetEntriesFast
Int_t GetEntriesFast() const
Definition TObjArray.h:58
TObjArray::AddAt
void AddAt(TObject *obj, Int_t idx) override
Add object at position ids.
Definition TObjArray.cxx:254
TObjArray::AddAtAndExpand
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
Definition TObjArray.cxx:235
TObjArray::At
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
TObject
Mother of all ROOT objects.
Definition TObject.h:41
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:201
TObject::GetUniqueID
virtual UInt_t GetUniqueID() const
Return the unique object id.
Definition TObject.cxx:457
TObject::kIsOnHeap
@ kIsOnHeap
object is on heap
Definition TObject.h:81
TObject::kNotDeleted
@ kNotDeleted
object has not been deleted
Definition TObject.h:82
TObject::ClassName
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:973
TObject::Class
static TClass * Class()
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
TObject::SetUniqueID
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition TObject.cxx:791
TProcessID
A TProcessID identifies a ROOT job in a unique way in time and space.
Definition TProcessID.h:74
TProcessID::PutObjectWithID
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...
Definition TProcessID.cxx:383
TStreamerBase::GetErrorMessage
const char * GetErrorMessage() const
Definition TStreamerElement.h:176
TStreamerBase::Class
static TClass * Class()
TStreamerElement::GetNewType
Int_t GetNewType() const
Definition TStreamerElement.h:116
TStreamerElement::GetSize
virtual Int_t GetSize() const
Returns size of this element in bytes.
Definition TStreamerElement.cxx:374
TStreamerElement::GetType
Int_t GetType() const
Definition TStreamerElement.h:118
TStreamerElement::GetFullName
virtual const char * GetFullName() const
Return element name including dimensions, if any Note that this function stores the name into a stati...
Definition TStreamerElement.cxx:337
TStreamerElement::GetClassPointer
virtual TClass * GetClassPointer() const
Returns a pointer to the TClass of this element.
Definition TStreamerElement.cxx:292
TStreamerElement::GetMethod
virtual ULongptr_t GetMethod() const
Definition TStreamerElement.h:113
TStreamerElement::GetArrayDim
Int_t GetArrayDim() const
Definition TStreamerElement.h:105
TStreamerElement::GetStreamer
TMemberStreamer * GetStreamer() const
Return the local streamer object.
Definition TStreamerElement.cxx:382
TStreamerElement::GetXmax
Double_t GetXmax() const
Definition TStreamerElement.h:126
TStreamerElement::GetNewClass
TClass * GetNewClass() const
Definition TStreamerElement.h:117
TStreamerElement::GetArrayLength
Int_t GetArrayLength() const
Definition TStreamerElement.h:106
TStreamerElement::GetFactor
Double_t GetFactor() const
Definition TStreamerElement.h:124
TStreamerElement::GetTypeName
const char * GetTypeName() const
Definition TStreamerElement.h:122
TStreamerElement::IsA
TClass * IsA() const override
Definition TStreamerElement.h:146
TStreamerElement::GetXmin
Double_t GetXmin() const
Definition TStreamerElement.h:125
TStreamerElement::GetOffset
Int_t GetOffset() const
Definition TStreamerElement.h:119
TStreamerElement::IsBase
virtual Bool_t IsBase() const
Return kTRUE if the element represent a base class.
Definition TStreamerElement.cxx:429
TStreamerElement::HasCounter
virtual Bool_t HasCounter() const
Definition TStreamerElement.h:129
TStreamerElement::GetSequenceType
void GetSequenceType(TString &type) const
Fill type with the string representation of sequence information including 'cached',...
Definition TStreamerElement.cxx:354
TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions
static TActionSequence * CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
Definition TStreamerInfoActions.cxx:3919
TStreamerInfoActions::TActionSequence::fLoopConfig
TLoopConfiguration * fLoopConfig
If this is a bundle of memberwise streaming action, this configures the looping.
Definition TStreamerInfoActions.h:211
TStreamerInfoActions::TActionSequence::Print
void Print(Option_t *="") const override
This method must be overridden when a class wants to print itself.
Definition TStreamerInfoActions.cxx:4395
TStreamerInfoActions::TActionSequence::CreateWriteMemberWiseActions
static TActionSequence * CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
Definition TStreamerInfoActions.cxx:4032
TStreamerInfoActions::TActionSequence::SequenceGetter_t
SequencePtr(*)(TStreamerInfo *info, TVirtualCollectionProxy *collectionProxy, TClass *originalClass) SequenceGetter_t
Definition TStreamerInfoActions.h:185
TStreamerInfoActions::TActionSequence::AddToSubSequence
void AddToSubSequence(TActionSequence *sequence, const TIDs &element_ids, Int_t offset, SequenceGetter_t create)
Definition TStreamerInfoActions.cxx:4242
TStreamerInfoActions::TActionSequence::CreateSubSequence
TActionSequence * CreateSubSequence(const std::vector< Int_t > &element_ids, size_t offset)
Definition TStreamerInfoActions.cxx:4318
TStreamerInfoActions::TActionSequence::AddAction
void AddAction(action_t action, TConfiguration *conf)
Definition TStreamerInfoActions.h:199
TStreamerInfoActions::TAssocLoopConfig::Copy
TLoopConfiguration * Copy() const override
Definition TStreamerInfoActions.cxx:1059
TStreamerInfoActions::TAssocLoopConfig::TAssocLoopConfig
TAssocLoopConfig(TVirtualCollectionProxy *proxy, Bool_t)
Definition TStreamerInfoActions.cxx:1052
TStreamerInfoActions::TAssocLoopConfig::GetFirstAddress
void * GetFirstAddress(void *start, const void *) const override
Definition TStreamerInfoActions.cxx:1061
TStreamerInfoActions::TConfNoFactor::TConfNoFactor
TConfNoFactor(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, Int_t nbits)
Definition TStreamerInfoActions.cxx:914
TStreamerInfoActions::TConfSTLNoFactor::TConfSTLNoFactor
TConfSTLNoFactor(TConfigSTL *orig, Int_t nbits)
Definition TStreamerInfoActions.cxx:1021
TStreamerInfoActions::TConfSTLWithFactor::TConfSTLWithFactor
TConfSTLWithFactor(TConfigSTL *orig, Double_t factor, Double_t xmin)
Definition TStreamerInfoActions.cxx:1013
TStreamerInfoActions::TConfWithFactor::TConfWithFactor
TConfWithFactor(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, Double_t factor, Double_t xmin)
Definition TStreamerInfoActions.cxx:895
TStreamerInfoActions::TConfigSTL::TConfigSTL
TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TMemberStreamer *streamer, const char *type_name, Bool_t isbase)
Definition TStreamerInfoActions.cxx:997
TStreamerInfoActions::TConfigSTL::TConfigSTL
TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TClass *newClass, TMemberStreamer *streamer, const char *type_name, Bool_t isbase)
Definition TStreamerInfoActions.cxx:1001
TStreamerInfoActions::TConfigSTL::fCreateWriteIterators
TVirtualCollectionProxy::CreateIterators_t fCreateWriteIterators
Definition TStreamerInfoActions.cxx:984
TStreamerInfoActions::TConfigSTL::TConfigSTL
TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, const char *type_name, Bool_t isbase)
Definition TStreamerInfoActions.cxx:989
TStreamerInfoActions::TConfigSTL::fCreateIterators
TVirtualCollectionProxy::CreateIterators_t fCreateIterators
Definition TStreamerInfoActions.cxx:983
TStreamerInfoActions::TConfigSTL::fDeleteIterator
TVirtualCollectionProxy::DeleteIterator_t fDeleteIterator
Definition TStreamerInfoActions.cxx:986
TStreamerInfoActions::TConfigSTL::fDeleteTwoIterators
TVirtualCollectionProxy::DeleteTwoIterators_t fDeleteTwoIterators
Definition TStreamerInfoActions.cxx:987
TStreamerInfoActions::TConfigSTL::fCopyIterator
TVirtualCollectionProxy::CopyIterator_t fCopyIterator
Definition TStreamerInfoActions.cxx:985
TStreamerInfoActions::TConfigSTL::TConfigSTL
TConfigSTL(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset, UInt_t length, TClass *oldClass, TClass *newClass, const char *type_name, Bool_t isbase)
Definition TStreamerInfoActions.cxx:993
TStreamerInfoActions::TConfigurationPushDataCache::TConfigurationPushDataCache
TConfigurationPushDataCache(TVirtualStreamerInfo *info, TVirtualArray *onfileObject, Int_t offset)
Definition TStreamerInfoActions.cxx:1473
TStreamerInfoActions::TConfigurationPushDataCache::PrintDebug
void PrintDebug(TBuffer &buffer, void *object) const override
Definition TStreamerInfoActions.cxx:1487
TStreamerInfoActions::TConfigurationUseCache::PrintDebug
void PrintDebug(TBuffer &b, void *addr) const override
Definition TStreamerInfoActions.cxx:1560
TStreamerInfoActions::TConfigurationUseCache::TConfigurationUseCache
TConfigurationUseCache(TVirtualStreamerInfo *info, TConfiguredAction &action, Bool_t repeat)
Definition TStreamerInfoActions.cxx:1558
TStreamerInfoActions::TConfiguration
Base class of the Configurations.
Definition TStreamerInfoActions.h:29
TStreamerInfoActions::TConfiguration::PrintDebug
virtual void PrintDebug(TBuffer &buffer, void *object) const
Definition TStreamerInfoActions.cxx:111
TStreamerInfoActions::TConfiguration::fInfo
TVirtualStreamerInfo * fInfo
TStreamerInfo form which the action is derived.
Definition TStreamerInfoActions.h:33
TStreamerInfoActions::TConfiguration::fOffset
Int_t fOffset
Offset within the object.
Definition TStreamerInfoActions.h:36
TStreamerInfoActions::TConfiguration::fCompInfo
TCompInfo_t * fCompInfo
Access to compiled information (for legacy code)
Definition TStreamerInfoActions.h:35
TStreamerInfoActions::TConfiguration::fLength
UInt_t fLength
Number of element in a fixed length array.
Definition TStreamerInfoActions.h:37
TStreamerInfoActions::TConfiguration::fElemId
UInt_t fElemId
Identifier of the TStreamerElement.
Definition TStreamerInfoActions.h:34
TStreamerInfoActions::TConfiguredAction::PrintDebug
void PrintDebug(TBuffer &buffer, void *object) const
Definition TStreamerInfoActions.cxx:88
TStreamerInfoActions::TGenericLoopConfig::Copy
TLoopConfiguration * Copy() const override
Definition TStreamerInfoActions.cxx:1106
TStreamerInfoActions::TGenericLoopConfig::GetFirstAddress
void * GetFirstAddress(void *start_collection, const void *end_collection) const override
Definition TStreamerInfoActions.cxx:1108
TStreamerInfoActions::TGenericLoopConfig::fCopyIterator
TVirtualCollectionProxy::CopyIterator_t fCopyIterator
Definition TStreamerInfoActions.cxx:1094
TStreamerInfoActions::TGenericLoopConfig::fDeleteIterator
TVirtualCollectionProxy::DeleteIterator_t fDeleteIterator
Definition TStreamerInfoActions.cxx:1095
TStreamerInfoActions::TGenericLoopConfig::TGenericLoopConfig
TGenericLoopConfig(TVirtualCollectionProxy *proxy, Bool_t read)
Definition TStreamerInfoActions.cxx:1097
TStreamerInfoActions::TLoopConfiguration
Base class of the Configurations for the member wise looping routines.
Definition TStreamerInfoActions.h:53
TStreamerInfoActions::TLoopConfiguration::GetCollectionProxy
virtual TVirtualCollectionProxy * GetCollectionProxy() const
Definition TStreamerInfoActions.h:65
TStreamerInfoActions::TLoopConfiguration::Copy
virtual TLoopConfiguration * Copy() const =0
TStreamerInfoActions::TVectorLoopConfig::Copy
TLoopConfiguration * Copy() const override
Definition TStreamerInfoActions.cxx:1046
TStreamerInfoActions::TVectorLoopConfig::GetFirstAddress
void * GetFirstAddress(void *start, const void *) const override
Definition TStreamerInfoActions.cxx:1039
TStreamerInfoActions::TVectorLoopConfig::TVectorLoopConfig
TVectorLoopConfig(TVirtualCollectionProxy *proxy, Long_t increment, Bool_t)
Definition TStreamerInfoActions.cxx:1031
TStreamerInfo::TCompInfo::fClass
TClass * fClass
Not Owned.
Definition TStreamerInfo.h:53
TStreamerInfo::TCompInfo::fStreamer
TMemberStreamer * fStreamer
Not Owned.
Definition TStreamerInfo.h:56
TStreamerInfo::TCompInfo::fElem
TStreamerElement * fElem
Not Owned.
Definition TStreamerInfo.h:51
TStreamerInfo::TCompInfo::fNewClass
TClass * fNewClass
Not Owned.
Definition TStreamerInfo.h:54
TStreamerInfo
Describes a persistent version of a class.
Definition TStreamerInfo.h:39
TStreamerInfo::fNVirtualInfoLoc
Int_t fNVirtualInfoLoc
! Number of virtual info location to update.
Definition TStreamerInfo.h:102
TStreamerInfo::ReadBufferSTL
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.
Definition TStreamerInfoReadBuffer.cxx:1737
TStreamerInfo::AddWriteAction
void AddWriteAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t index, TCompInfo *compinfo)
Definition TStreamerInfoActions.cxx:3587
TStreamerInfo::fNfulldata
Int_t fNfulldata
!number of elements
Definition TStreamerInfo.h:94
TStreamerInfo::fComp
TCompInfo * fComp
![fNslots with less than fElements->GetEntries()*1.5 used] Compiled info
Definition TStreamerInfo.h:96
TStreamerInfo::GetWriteMemberWiseActions
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions(Bool_t forCollection)
Definition TStreamerInfo.h:211
TStreamerInfo::fWriteMemberWiseVecPtr
TStreamerInfoActions::TActionSequence * fWriteMemberWiseVecPtr
! List of write action resulting from the compilation for use in member wise streaming.
Definition TStreamerInfo.h:110
TStreamerInfo::fReadText
TStreamerInfoActions::TActionSequence * fReadText
! List of text read action resulting from the compilation, used for JSON.
Definition TStreamerInfo.h:107
TStreamerInfo::ls
void ls(Option_t *option="") const override
List the TStreamerElement list and also the precomputed tables if option contains the string "incOrig...
Definition TStreamerInfo.cxx:4677
TStreamerInfo::AddReadTextAction
void AddReadTextAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read text action for the given element.
Definition TStreamerInfoActions.cxx:3504
TStreamerInfo::fCompFull
TCompInfo ** fCompFull
![fElements->GetEntries()]
Definition TStreamerInfo.h:98
TStreamerInfo::fElements
TObjArray * fElements
Array of TStreamerElements.
Definition TStreamerInfo.h:100
TStreamerInfo::kArtificial
@ kArtificial
Cache the value in memory than is not part of the object but is accessible via a SchemaRule.
Definition TStreamerInfo.h:175
TStreamerInfo::kUChar
@ kUChar
Equal to TDataType's kchar.
Definition TStreamerInfo.h:165
TStreamerInfo::AddReadMemberWiseVecPtrAction
void AddReadMemberWiseVecPtrAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read action for the given element.
Definition TStreamerInfoActions.cxx:3571
TStreamerInfo::fReadMemberWise
TStreamerInfoActions::TActionSequence * fReadMemberWise
! List of read action resulting from the compilation for use in member wise streaming.
Definition TStreamerInfo.h:105
TStreamerInfo::fNdata
Int_t fNdata
!number of optimized elements
Definition TStreamerInfo.h:93
TStreamerInfo::fReadMemberWiseVecPtr
TStreamerInfoActions::TActionSequence * fReadMemberWiseVecPtr
! List of read action resulting from the compilation for use in member wise streaming.
Definition TStreamerInfo.h:106
TStreamerInfo::fReadObjectWise
TStreamerInfoActions::TActionSequence * fReadObjectWise
! List of read action resulting from the compilation.
Definition TStreamerInfo.h:104
TStreamerInfo::fClass
TClass * fClass
!pointer to class
Definition TStreamerInfo.h:99
TStreamerInfo::fCompOpt
TCompInfo ** fCompOpt
![fNdata]
Definition TStreamerInfo.h:97
TStreamerInfo::GetClass
TClass * GetClass() const override
Definition TStreamerInfo.h:199
TStreamerInfo::fgCount
static std::atomic< Int_t > fgCount
Number of TStreamerInfo instances.
Definition TStreamerInfo.h:113
TStreamerInfo::AddWriteTextAction
void AddWriteTextAction(TStreamerInfoActions::TActionSequence *writeSequence, Int_t index, TCompInfo *compinfo)
Definition TStreamerInfoActions.cxx:3693
TStreamerInfo::ComputeSize
void ComputeSize()
Compute total size of all persistent elements of the class.
Definition TStreamerInfo.cxx:3128
TStreamerInfo::AddReadAction
void AddReadAction(TStreamerInfoActions::TActionSequence *readSequence, Int_t index, TCompInfo *compinfo)
Add a read action for the given element.
Definition TStreamerInfoActions.cxx:3272
TStreamerInfo::AddWriteMemberWiseVecPtrAction
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).
Definition TStreamerInfoActions.cxx:3891
TStreamerInfo::fNumber
Int_t fNumber
!Unique identifier
Definition TStreamerInfo.h:91
TStreamerInfo::fWriteObjectWise
TStreamerInfoActions::TActionSequence * fWriteObjectWise
! List of write action resulting from the compilation.
Definition TStreamerInfo.h:108
TStreamerInfo::fSize
Int_t fSize
!size of the persistent class
Definition TStreamerInfo.h:92
TStreamerInfo::Compile
void Compile() override
loop on the TStreamerElement list regroup members with same type Store predigested information into l...
Definition TStreamerInfoActions.cxx:3005
TStreamerInfo::ReadBufferSkip
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.
Definition TStreamerInfoReadBuffer.cxx:182
TStreamerInfo::fWriteMemberWise
TStreamerInfoActions::TActionSequence * fWriteMemberWise
! List of write action resulting from the compilation for use in member wise streaming.
Definition TStreamerInfo.h:109
TStreamerInfo::fNslots
Int_t fNslots
!total number of slots in fComp.
Definition TStreamerInfo.h:95
TStreamerInfo::fOldVersion
Version_t fOldVersion
! Version of the TStreamerInfo object read from the file
Definition TStreamerInfo.h:101
TStreamerInfo::fWriteText
TStreamerInfoActions::TActionSequence * fWriteText
! List of text write action resulting for the compilation, used for JSON.
Definition TStreamerInfo.h:111
TStreamerInfo::GetReadMemberWiseActions
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Bool_t forCollection)
Definition TStreamerInfo.h:208
TString
Basic string class.
Definition TString.h:139
TString::Strip
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition TString.cxx:1163
TString::Data
const char * Data() const
Definition TString.h:376
TString::kTrailing
@ kTrailing
Definition TString.h:276
TVirtualArray
Wrapper around an object and giving indirect access to its content even if the object is not of a cla...
Definition TVirtualArray.h:27
TVirtualArray::fClass
TClassRef fClass
Definition TVirtualArray.h:31
TVirtualCollectionProxy::TPushPop
RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++...
Definition TVirtualCollectionProxy.h:75
TVirtualCollectionProxy
Defines a common interface to inspect/change the contents of an object that represents a collection.
Definition TVirtualCollectionProxy.h:52
TVirtualCollectionProxy::GetProperties
virtual Int_t GetProperties() const
Return miscallenous properties of the proxy (see TVirtualCollectionProxy::EProperty)
Definition TVirtualCollectionProxy.h:108
TVirtualCollectionProxy::GetIncrement
virtual ULong_t GetIncrement() const =0
Return the offset between two consecutive in-memory values (which depends on the sizeof() and alignme...
TVirtualCollectionProxy::GetReadMemberWiseActions
virtual TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version)=0
TVirtualCollectionProxy::CreateIterators_t
void(* CreateIterators_t)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
*begin_arena and *end_arena should contain the location of a memory arena of size fgIteratorArenaSize...
Definition TVirtualCollectionProxy.h:215
TVirtualCollectionProxy::GetType
virtual EDataType GetType() const =0
If the value type is a fundamental data type, return its type (see enumeration EDataType).
TVirtualCollectionProxy::kCustomAlloc
@ kCustomAlloc
The collection has a custom allocator.
Definition TVirtualCollectionProxy.h:71
TVirtualCollectionProxy::CopyIterator_t
void *(* CopyIterator_t)(void *dest, const void *source)
Copy the iterator source into dest.
Definition TVirtualCollectionProxy.h:227
TVirtualCollectionProxy::Next_t
void *(* Next_t)(void *iter, const void *end)
iter and end should be pointers to an iterator to be incremented and an iterator that points to the e...
Definition TVirtualCollectionProxy.h:236
TVirtualCollectionProxy::GetValueClass
virtual TClass * GetValueClass() const =0
If the value type is a user-defined class, return a pointer to the TClass representing the value type...
TVirtualCollectionProxy::Commit
virtual void Commit(void *)=0
Commits pending elements in a staging area (see Allocate() for more information).
TVirtualCollectionProxy::GetCollectionType
virtual Int_t GetCollectionType() const =0
Return the type of the proxied collection (see enumeration TClassEdit::ESTLType)
TVirtualCollectionProxy::GetFunctionNext
virtual Next_t GetFunctionNext(Bool_t read=kTRUE)=0
Return a pointer to a function that can advance an iterator (see Next_t).
TVirtualCollectionProxy::GetFunctionDeleteTwoIterators
virtual DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read=kTRUE)=0
TVirtualCollectionProxy::Size
virtual UInt_t Size() const =0
Return the current number of elements in the container.
TVirtualCollectionProxy::DeleteTwoIterators_t
void(* DeleteTwoIterators_t)(void *begin, void *end)
Definition TVirtualCollectionProxy.h:245
TVirtualCollectionProxy::DeleteIterator_t
void(* DeleteIterator_t)(void *iter)
If the size of the iterator is greater than fgIteratorArenaSize, call delete on the addresses; otherw...
Definition TVirtualCollectionProxy.h:244
TVirtualCollectionProxy::fgIteratorArenaSize
static const Int_t fgIteratorArenaSize
The size of a small buffer that can be allocated on the stack to store iterator-specific information.
Definition TVirtualCollectionProxy.h:207
TVirtualCollectionProxy::GetFunctionCreateIterators
virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE)=0
Return a pointer to a function that can create an iterator pair, where each iterator points to the be...
TVirtualCollectionProxy::Allocate
virtual void * Allocate(UInt_t n, Bool_t forceDelete)=0
Allocates space for storing at least n elements.
TVirtualCollectionProxy::GetConversionReadMemberWiseActions
virtual TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version)=0
TVirtualCollectionProxy::GetFunctionDeleteIterator
virtual DeleteIterator_t GetFunctionDeleteIterator(Bool_t read=kTRUE)=0
Return a pointer to a function that can delete an iterator (pair) (see DeleteIterator_t).
TVirtualCollectionProxy::GetFunctionCopyIterator
virtual CopyIterator_t GetFunctionCopyIterator(Bool_t read=kTRUE)=0
Return a pointer to a function that can copy an iterator (see CopyIterator_t).
TVirtualCollectionProxy::HasPointers
virtual Bool_t HasPointers() const =0
Return true if the content is of type 'pointer to'.
TVirtualCollectionProxy::GetCollectionClass
virtual TClass * GetCollectionClass() const
Return a pointer to the TClass representing the proxied container class.
Definition TVirtualCollectionProxy.h:98
TVirtualCollectionPtrIterators::Next
static void * Next(void *iter, const void *end)
Definition TVirtualCollectionIterators.h:283
TVirtualCollectionPtrIterators::CopyIterator
static void * CopyIterator(void *dest, const void *source)
Definition TVirtualCollectionIterators.h:301
TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition TVirtualStreamerInfo.h:44
TVirtualStreamerInfo::GetStreamMemberWise
static Bool_t GetStreamMemberWise()
Return whether the TStreamerInfos will save the collections in "member-wise" order whenever possible.
Definition TVirtualStreamerInfo.cxx:155
TVirtualStreamerInfo::IsA
TClass * IsA() const override
Definition TVirtualStreamerInfo.h:206
TVirtualStreamerInfo::CanOptimize
static Bool_t CanOptimize()
static function returning true if optimization can be on
Definition TVirtualStreamerInfo.cxx:86
TVirtualStreamerInfo::GetElements
virtual TObjArray * GetElements() const =0
TVirtualStreamerInfo::GetClassVersion
virtual Int_t GetClassVersion() const =0
fTypeName
struct void * fTypeName
Definition cppyy.h:9
x
Double_t x[n]
Definition legend1.C:17
n
const Int_t n
Definition legend1.C:16
ROOT::kSTLbitset
@ kSTLbitset
Definition ESTLType.h:37
ROOT::kSTLmap
@ kSTLmap
Definition ESTLType.h:33
ROOT::kSTLunorderedmultiset
@ kSTLunorderedmultiset
Definition ESTLType.h:43
ROOT::kSTLset
@ kSTLset
Definition ESTLType.h:35
ROOT::kSTLmultiset
@ kSTLmultiset
Definition ESTLType.h:36
ROOT::kSTLvector
@ kSTLvector
Definition ESTLType.h:30
ROOT::kSTLunorderedmultimap
@ kSTLunorderedmultimap
Definition ESTLType.h:45
ROOT::kSTLunorderedset
@ kSTLunorderedset
Definition ESTLType.h:42
ROOT::kSTLunorderedmap
@ kSTLunorderedmap
Definition ESTLType.h:44
ROOT::kSTLmultimap
@ kSTLmultimap
Definition ESTLType.h:34
TStreamerInfoActions::ReadSTLObjectWiseStreamer
void ReadSTLObjectWiseStreamer(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t, UInt_t)
Definition TStreamerInfoActions.cxx:1366
TStreamerInfoActions::PushDataCacheVectorPtr
Int_t PushDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1509
TStreamerInfoActions::WriteTextStreamer
Int_t WriteTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:283
TStreamerInfoActions::PopDataCache
Int_t PopDataCache(TBuffer &b, void *, const TConfiguration *)
Definition TStreamerInfoActions.cxx:1534
TStreamerInfoActions::ReadSTLMemberWiseChangedClass
void ReadSTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Definition TStreamerInfoActions.cxx:1266
TStreamerInfoActions::ReadSTLObjectWiseFastArrayV2
void ReadSTLObjectWiseFastArrayV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
Definition TStreamerInfoActions.cxx:1371
TStreamerInfoActions::ReadBasicType< BitsMarker >
Int_t ReadBasicType< BitsMarker >(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:235
TStreamerInfoActions::ReadStreamerLoop
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...
Definition TStreamerInfoActions.cxx:638
TStreamerInfoActions::WriteTextBaseClass
Int_t WriteTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:275
TStreamerInfoActions::GenericWriteAction
Int_t GenericWriteAction(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:198
TStreamerInfoActions::ReadArraySTLMemberWiseChangedClass
void ReadArraySTLMemberWiseChangedClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Definition TStreamerInfoActions.cxx:1310
TStreamerInfoActions::PopDataCacheVectorPtr
Int_t PopDataCacheVectorPtr(TBuffer &b, void *, const void *, const TConfiguration *)
Definition TStreamerInfoActions.cxx:1540
TStreamerInfoActions::ReadTextStreamer
Int_t ReadTextStreamer(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:315
TStreamerInfoActions::GenericReadAction
Int_t GenericReadAction(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:191
TStreamerInfoActions::WriteTextTObject
Int_t WriteTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:267
TStreamerInfoActions::ReadBasicType_WithFactor
Int_t ReadBasicType_WithFactor(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:900
TStreamerInfoActions::ReadTextBaseClass
Int_t ReadTextBaseClass(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:307
TStreamerInfoActions::UseCacheVectorPtrLoop
Int_t UseCacheVectorPtrLoop(TBuffer &b, void *start, const void *end, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1604
TStreamerInfoActions::ReadSTL
Int_t ReadSTL(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1399
TStreamerInfoActions::ReadTextTObject
Int_t ReadTextTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:300
TStreamerInfoActions::PushDataCache
Int_t PushDataCache(TBuffer &b, void *, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1498
TStreamerInfoActions::UseCache
Int_t UseCache(TBuffer &b, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1582
TStreamerInfoActions::TIDs
std::vector< TIDNode > TIDs
Definition TStreamerInfoActions.h:138
TStreamerInfoActions::WriteLoopInvalid
Int_t WriteLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1691
TStreamerInfoActions::ReadSTLMemberWiseSameClass
void ReadSTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Definition TStreamerInfoActions.cxx:1122
TStreamerInfoActions::WriteTextTNamed
Int_t WriteTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:259
TStreamerInfoActions::ReadTextObject
Int_t ReadTextObject(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:293
TStreamerInfoActions::UseCacheVectorLoop
Int_t UseCacheVectorLoop(TBuffer &b, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1630
TStreamerInfoActions::ReadTextTNamed
Int_t ReadTextTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:335
TStreamerInfoActions::WriteSTLp
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...
Definition TStreamerInfoActions.cxx:345
TStreamerInfoActions::ReadSTLObjectWiseFastArray
void ReadSTLObjectWiseFastArray(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t, UInt_t)
Definition TStreamerInfoActions.cxx:1360
TStreamerInfoActions::ReadTNamed
Int_t ReadTNamed(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:950
TStreamerInfoActions::ReadBasicType_NoFactor
Int_t ReadBasicType_NoFactor(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:919
TStreamerInfoActions::IsDefaultVector
bool IsDefaultVector(TVirtualCollectionProxy &proxy)
Definition TStreamerInfoActions.cxx:47
TStreamerInfoActions::ReadLoopInvalid
Int_t ReadLoopInvalid(TBuffer &, void *, const void *, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1685
TStreamerInfoActions::ReadTObject
Int_t ReadTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:940
TStreamerInfoActions::ReadSTLObjectWiseStreamerV2
void ReadSTLObjectWiseStreamerV2(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers, UInt_t start)
Definition TStreamerInfoActions.cxx:1384
TStreamerInfoActions::ReadArraySTLMemberWiseSameClass
void ReadArraySTLMemberWiseSameClass(TBuffer &buf, void *addr, const TConfiguration *conf, Version_t vers)
Definition TStreamerInfoActions.cxx:1188
TStreamerInfoActions::HandleReferencedTObject
void HandleReferencedTObject(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:214
TStreamerInfoActions::PopDataCacheGenericCollection
Int_t PopDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *, const TConfiguration *)
Definition TStreamerInfoActions.cxx:1546
TStreamerInfoActions::WriteStreamerLoop
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...
Definition TStreamerInfoActions.cxx:505
TStreamerInfoActions::PushDataCacheGenericCollection
Int_t PushDataCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1520
TStreamerInfoActions::ReadTextTObjectBase
Int_t ReadTextTObjectBase(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:327
TStreamerInfoActions::SelectLooper
ESelectLooper SelectLooper(TVirtualCollectionProxy &proxy)
Definition TStreamerInfoActions.cxx:1699
TStreamerInfoActions::ReadSTLp
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...
Definition TStreamerInfoActions.cxx:408
TStreamerInfoActions::ReadTString
Int_t ReadTString(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:930
TStreamerInfoActions::UseCacheGenericCollection
Int_t UseCacheGenericCollection(TBuffer &b, void *, const void *, const TLoopConfiguration *loopconfig, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1656
TStreamerInfoActions::Next_t
TVirtualCollectionProxy::Next_t Next_t
Definition TStreamerInfoActions.h:68
v
@ v
Definition rootcling_impl.cxx:3687
TStreamerInfoActions::AssociativeLooper::ConvertCollectionBasicType::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2347
TStreamerInfoActions::AssociativeLooper::ConvertRead::Action
static void Action(TBuffer &buf, void *addr, Int_t nvalues)
Definition TStreamerInfoActions.cxx:2304
TStreamerInfoActions::AssociativeLooper::SimpleRead
static void SimpleRead(TBuffer &buf, void *addr, Int_t nvalues)
Definition TStreamerInfoActions.cxx:2228
TStreamerInfoActions::AssociativeLooper::ReadCollectionDouble32
static Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2291
TStreamerInfoActions::AssociativeLooper::SimpleReadDouble32
static void SimpleReadDouble32(TBuffer &buf, void *addr, Int_t nvalues)
Definition TStreamerInfoActions.cxx:2238
TStreamerInfoActions::AssociativeLooper::ReadCollectionBasicType
static Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2297
TStreamerInfoActions::AssociativeLooper::ReadCollectionFloat16
static Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2286
TStreamerInfoActions::AssociativeLooper::SimpleReadFloat16
static void SimpleReadFloat16(TBuffer &buf, void *addr, Int_t nvalues)
Definition TStreamerInfoActions.cxx:2233
TStreamerInfoActions::AssociativeLooper::ReadCollectionBool
static Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2281
TStreamerInfoActions::AssociativeLooper::ReadNumericalCollection
static Int_t ReadNumericalCollection(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2244
TStreamerInfoActions::ConvertBasicType< BitsMarker, To >::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1427
TStreamerInfoActions::ConvertBasicType< NoFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1457
TStreamerInfoActions::ConvertBasicType< WithFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1444
TStreamerInfoActions::ConvertBasicType::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1415
TStreamerInfoActions::GenericLooper::ConvertBasicType< BitsMarker, To, Generic >::Action
static Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2482
TStreamerInfoActions::GenericLooper::ConvertBasicType< NoFactorMarker< From >, To, Converter >::Action
static Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2539
TStreamerInfoActions::GenericLooper::ConvertBasicType< WithFactorMarker< From >, To, Converter >::Action
static Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2519
TStreamerInfoActions::GenericLooper::ConvertBasicType::Action
static Int_t Action(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2464
TStreamerInfoActions::GenericLooper::ConvertCollectionBasicType::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2664
TStreamerInfoActions::GenericLooper::Generic::ConvertAction
static void ConvertAction(From *items, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2421
TStreamerInfoActions::GenericLooper::Numeric::ConvertAction
static void ConvertAction(From *items, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *)
Definition TStreamerInfoActions.cxx:2444
TStreamerInfoActions::GenericLooper::ReadBasicType
static Int_t ReadBasicType(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2358
TStreamerInfoActions::GenericLooper::ReadCollectionFloat16
static Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2642
TStreamerInfoActions::GenericLooper::ReadBase
static Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2557
TStreamerInfoActions::GenericLooper::WriteBasicType
static Int_t WriteBasicType(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2379
TStreamerInfoActions::GenericLooper::GenericRead
static Int_t GenericRead(TBuffer &buf, void *, const void *, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2565
TStreamerInfoActions::GenericLooper::ReadCollectionBool
static Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2637
TStreamerInfoActions::GenericLooper::SimpleReadFloat16
static void SimpleReadFloat16(TBuffer &buf, void *addr)
Definition TStreamerInfoActions.cxx:2585
TStreamerInfoActions::GenericLooper::ReadNumericalCollection
static Int_t ReadNumericalCollection(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2599
TStreamerInfoActions::GenericLooper::GenericWrite
static Int_t GenericWrite(TBuffer &buf, void *, const void *, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2572
TStreamerInfoActions::GenericLooper::ReadCollectionBasicType
static Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2655
TStreamerInfoActions::GenericLooper::SimpleRead
static void SimpleRead(TBuffer &buf, void *addr)
Definition TStreamerInfoActions.cxx:2580
TStreamerInfoActions::GenericLooper::ReadAction
static Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconf, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2400
TStreamerInfoActions::GenericLooper::SimpleReadDouble32
static void SimpleReadDouble32(TBuffer &buf, void *addr)
Definition TStreamerInfoActions.cxx:2590
TStreamerInfoActions::GenericLooper::ReadCollectionDouble32
static Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2647
TStreamerInfoActions::TBitsConfiguration::TBitsConfiguration
TBitsConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset=0)
Definition TStreamerInfoActions.cxx:157
TStreamerInfoActions::TBitsConfiguration::PrintDebug
void PrintDebug(TBuffer &, void *) const override
Definition TStreamerInfoActions.cxx:158
TStreamerInfoActions::TGenericConfiguration::TGenericConfiguration
TGenericConfiguration(TVirtualStreamerInfo *info, UInt_t id, TCompInfo_t *compinfo, Int_t offset=0)
Definition TStreamerInfoActions.cxx:141
TStreamerInfoActions::TGenericConfiguration::PrintDebug
void PrintDebug(TBuffer &, void *) const override
Definition TStreamerInfoActions.cxx:142
TStreamerInfoActions::VectorLooper::ConvertBasicType< BitsMarker, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1753
TStreamerInfoActions::VectorLooper::ConvertBasicType< NoFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1793
TStreamerInfoActions::VectorLooper::ConvertBasicType< WithFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1775
TStreamerInfoActions::VectorLooper::ConvertBasicType::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1736
TStreamerInfoActions::VectorLooper::ConvertCollectionBasicType::Action
static Int_t Action(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2016
TStreamerInfoActions::VectorLooper::ReadAction
static Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1823
TStreamerInfoActions::VectorLooper::WriteBasicType
static Int_t WriteBasicType(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1810
TStreamerInfoActions::VectorLooper::GenericWrite
static Int_t GenericWrite(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1888
TStreamerInfoActions::VectorLooper::ReadCollectionDouble32
static Int_t ReadCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1988
TStreamerInfoActions::VectorLooper::ConvertCollectionDouble32
static Int_t ConvertCollectionDouble32(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:2069
TStreamerInfoActions::VectorLooper::ReadCollectionBasicType
static Int_t ReadCollectionBasicType(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1905
TStreamerInfoActions::VectorLooper::ReadCollectionBool
static Int_t ReadCollectionBool(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1931
TStreamerInfoActions::VectorLooper::ReadBasicType
static Int_t ReadBasicType(TBuffer &buf, void *iter, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1722
TStreamerInfoActions::VectorLooper::ReadBase
static Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1834
TStreamerInfoActions::VectorLooper::ReadCollectionFloat16
static Int_t ReadCollectionFloat16(TBuffer &buf, void *addr, const TConfiguration *conf)
Definition TStreamerInfoActions.cxx:1962
TStreamerInfoActions::VectorLooper::GenericRead
static Int_t GenericRead(TBuffer &buf, void *start, const void *end, const TLoopConfiguration *loopconfig, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:1872
TStreamerInfoActions::VectorPtrLooper::ConvertBasicType< BitsMarker, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2127
TStreamerInfoActions::VectorPtrLooper::ConvertBasicType< NoFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2165
TStreamerInfoActions::VectorPtrLooper::ConvertBasicType< WithFactorMarker< From >, To >::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2148
TStreamerInfoActions::VectorPtrLooper::ConvertBasicType::Action
static Int_t Action(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2111
TStreamerInfoActions::VectorPtrLooper::ReadAction
static Int_t ReadAction(TBuffer &buf, void *start, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2193
TStreamerInfoActions::VectorPtrLooper::ReadBase
static Int_t ReadBase(TBuffer &buf, void *start, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2201
TStreamerInfoActions::VectorPtrLooper::ReadBasicType
static Int_t ReadBasicType(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2098
TStreamerInfoActions::VectorPtrLooper::GenericRead
static Int_t GenericRead(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2209
TStreamerInfoActions::VectorPtrLooper::WriteBasicType
static Int_t WriteBasicType(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2181
TStreamerInfoActions::VectorPtrLooper::GenericWrite
static Int_t GenericWrite(TBuffer &buf, void *iter, const void *end, const TConfiguration *config)
Definition TStreamerInfoActions.cxx:2216