Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TGenCollectionStreamer.cxx
Go to the documentation of this file.
1// @(#)root/io:$Id$
2// Author: Markus Frank 28/10/04
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/*
13\class TGenCollectionStreamer
14\ingroup IO
15
16Streamer around an arbitrary container, which implements basic
17functionality and iteration.
18
19In particular this is used to implement splitting and abstract
20element access of any container. Access to compiled code is necessary
21to implement the abstract iteration sequence and functionality like
22size(), clear(), resize(). resize() may be a void operation.
23**/
24
25#include "TGenCollectionStreamer.h"
26#include "TClassEdit.h"
27#include "TError.h"
28#include "TROOT.h"
29#include "TStreamerInfo.h"
30#include "TStreamerElement.h"
31#include "TVirtualCollectionIterators.h"
32
33TGenCollectionStreamer::TGenCollectionStreamer(const TGenCollectionStreamer& copy)
34 : TGenCollectionProxy(copy), fReadBufferFunc(&TGenCollectionStreamer::ReadBufferDefault)
35{
36 // Build a Streamer for an emulated vector whose type is 'name'.
37}
38
39TGenCollectionStreamer::TGenCollectionStreamer(Info_t info, size_t iter_size)
40 : TGenCollectionProxy(info, iter_size), fReadBufferFunc(&TGenCollectionStreamer::ReadBufferDefault)
41{
42 // Build a Streamer for a collection whose type is described by 'collectionClass'.
43}
44
45TGenCollectionStreamer::TGenCollectionStreamer(const ::ROOT::TCollectionProxyInfo &info, TClass *cl)
46 : TGenCollectionProxy(info, cl), fReadBufferFunc(&TGenCollectionStreamer::ReadBufferDefault)
47{
48 // Build a Streamer for a collection whose type is described by 'collectionClass'.
49}
50
51TGenCollectionStreamer::~TGenCollectionStreamer()
52{
53 // Standard destructor.
54}
55
56TVirtualCollectionProxy* TGenCollectionStreamer::Generate() const
57{
58 // Virtual copy constructor.
59 if (!fValue.load()) Initialize(kFALSE);
60 return new TGenCollectionStreamer(*this);
61}
62
63template <typename T>
64T* getaddress(TGenCollectionProxy::StreamHelper &itm);
65
66template <>
67bool* getaddress<bool>(TGenCollectionProxy::StreamHelper &itm)
68{
69 return &itm.boolean;
70}
71
72template <>
73Char_t* getaddress<Char_t>(TGenCollectionProxy::StreamHelper &itm)
74{
75 return &itm.s_char;
76}
77
78template <>
79Short_t* getaddress<Short_t>(TGenCollectionProxy::StreamHelper &itm)
80{
81 return &itm.s_short;
82}
83
84template <>
85Int_t* getaddress<Int_t>(TGenCollectionProxy::StreamHelper &itm)
86{
87 return &itm.s_int;
88}
89
90template <>
91Long_t* getaddress<Long_t>(TGenCollectionProxy::StreamHelper &itm)
92{
93 return &itm.s_long;
94}
95
96template <>
97Long64_t* getaddress<Long64_t>(TGenCollectionProxy::StreamHelper &itm)
98{
99 return &itm.s_longlong;
100}
101
102template <>
103Float_t* getaddress<Float_t>(TGenCollectionProxy::StreamHelper &itm)
104{
105 return &itm.flt;
106}
107
108template <>
109Double_t* getaddress<Double_t>(TGenCollectionProxy::StreamHelper &itm)
110{
111 return &itm.dbl;
112}
113
114template <>
115UChar_t* getaddress<UChar_t>(TGenCollectionProxy::StreamHelper &itm)
116{
117 return &itm.u_char;
118}
119
120template <>
121UShort_t* getaddress<UShort_t>(TGenCollectionProxy::StreamHelper &itm)
122{
123 return &itm.u_short;
124}
125
126template <>
127UInt_t* getaddress<UInt_t>(TGenCollectionProxy::StreamHelper &itm)
128{
129 return &itm.u_int;
130}
131
132template <>
133ULong_t* getaddress<ULong_t>(TGenCollectionProxy::StreamHelper &itm)
134{
135 return &itm.u_long;
136}
137
138template <>
139ULong64_t* getaddress<ULong64_t>(TGenCollectionProxy::StreamHelper &itm)
140{
141 return &itm.u_longlong;
142}
143
144template <typename From, typename To>
145void ConvertArray(TGenCollectionProxy::StreamHelper *read, TGenCollectionProxy::StreamHelper *write, int nElements)
146{
147 From *r = getaddress<From>( *read );
148 To *w = getaddress<To>( *write );
149 for(int i = 0; i < nElements; ++i) {
150 // getvalue<To>( write[i] ) = (To) getvalue<From>( read[i] );
151 w[i] = (To)r[i];
152 }
153}
154
155template <typename From>
156void DispatchConvertArray(int writeType, TGenCollectionProxy::StreamHelper *read, TGenCollectionProxy::StreamHelper *write, int nElements)
157{
158 switch(writeType) {
159 case kBool_t:
160 ConvertArray<From,bool>(read,write,nElements);
161 break;
162 case kChar_t:
163 ConvertArray<From,Char_t>(read,write,nElements);
164 break;
165 case kShort_t:
166 ConvertArray<From,Short_t>(read,write,nElements);
167 break;
168 case kInt_t:
169 ConvertArray<From,Int_t>(read,write,nElements);
170 break;
171 case kLong_t:
172 ConvertArray<From,Long64_t>(read,write,nElements);
173 break;
174 case kLong64_t:
175 ConvertArray<From,Long64_t>(read,write,nElements);
176 break;
177 case kFloat_t:
178 ConvertArray<From,Float_t>(read,write,nElements);
179 break;
180 case kFloat16_t:
181 ConvertArray<From,Float16_t>(read,write,nElements);
182 break;
183 case kDouble_t:
184 ConvertArray<From,Double_t>(read,write,nElements);
185 break;
186 case kUChar_t:
187 ConvertArray<From,UChar_t>(read,write,nElements);
188 break;
189 case kUShort_t:
190 ConvertArray<From,UShort_t>(read,write,nElements);
191 break;
192 case kUInt_t:
193 ConvertArray<From,UInt_t>(read,write,nElements);
194 break;
195 case kULong_t:
196 ConvertArray<From,ULong_t>(read,write,nElements);
197 break;
198 case kULong64_t:
199 ConvertArray<From,ULong64_t>(read,write,nElements);
200 break;
201 case kDouble32_t:
202 ConvertArray<From,Double32_t>(read,write,nElements);
203 break;
204 case kchar:
205 case kNoType_t:
206 case kOther_t:
207 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", writeType);
208 }
209}
210
211void TGenCollectionStreamer::ReadPrimitives(int nElements, TBuffer &b, const TClass *onFileClass)
212{
213 // Primitive input streamer.
214 size_t len = fValDiff * nElements;
215 char buffer[8096];
216 Bool_t feed = false;
217 void* memory = 0;
218 StreamHelper* itmstore = 0;
219 StreamHelper* itmconv = 0;
220 fEnv->fSize = nElements;
221 switch (fSTL_type) {
222 case ROOT::kSTLvector:
223 if (fVal->fKind != kBool_t) {
224 fResize(fEnv->fObject,fEnv->fSize);
225 fEnv->fIdx = 0;
226
227 TVirtualVectorIterators iterators(fFunctionCreateIterators);
228 iterators.CreateIterators(fEnv->fObject);
229 itmstore = (StreamHelper*)iterators.fBegin;
230 fEnv->fStart = itmstore;
231 break;
232 }
233 default:
234 feed = true;
235 itmstore = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
236 break;
237 }
238 fEnv->fStart = itmstore;
239
240 StreamHelper *itmread;
241 int readkind;
242 if (onFileClass) {
243 readkind = onFileClass->GetCollectionProxy()->GetType();
244 itmconv = (StreamHelper*) ::operator new( nElements * onFileClass->GetCollectionProxy()->GetIncrement() );
245 itmread = itmconv;
246 } else {
247 itmread = itmstore;
248 readkind = fVal->fKind;
249 }
250 switch (readkind) {
251 case kBool_t:
252 b.ReadFastArray(&itmread->boolean , nElements);
253 break;
254 case kChar_t:
255 b.ReadFastArray(&itmread->s_char , nElements);
256 break;
257 case kShort_t:
258 b.ReadFastArray(&itmread->s_short , nElements);
259 break;
260 case kInt_t:
261 b.ReadFastArray(&itmread->s_int , nElements);
262 break;
263 case kLong_t:
264 b.ReadFastArray(&itmread->s_long , nElements);
265 break;
266 case kLong64_t:
267 b.ReadFastArray(&itmread->s_longlong, nElements);
268 break;
269 case kFloat_t:
270 b.ReadFastArray(&itmread->flt , nElements);
271 break;
272 case kFloat16_t:
273 b.ReadFastArrayFloat16(&itmread->flt, nElements);
274 break;
275 case kDouble_t:
276 b.ReadFastArray(&itmread->dbl , nElements);
277 break;
278 case kUChar_t:
279 b.ReadFastArray(&itmread->u_char , nElements);
280 break;
281 case kUShort_t:
282 b.ReadFastArray(&itmread->u_short , nElements);
283 break;
284 case kUInt_t:
285 b.ReadFastArray(&itmread->u_int , nElements);
286 break;
287 case kULong_t:
288 b.ReadFastArray(&itmread->u_long , nElements);
289 break;
290 case kULong64_t:
291 b.ReadFastArray(&itmread->u_longlong, nElements);
292 break;
293 case kDouble32_t:
294 b.ReadFastArrayDouble32(&itmread->dbl, nElements);
295 break;
296 case kchar:
297 case kNoType_t:
298 case kOther_t:
299 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", readkind);
300 }
301 if (onFileClass) {
302 switch (readkind) {
303 case kBool_t:
304 DispatchConvertArray<bool>(fVal->fKind, itmread, itmstore, nElements);
305 break;
306 case kChar_t:
307 DispatchConvertArray<Char_t>(fVal->fKind, itmread, itmstore, nElements);
308 break;
309 case kShort_t:
310 DispatchConvertArray<Short_t>(fVal->fKind, itmread, itmstore, nElements);
311 break;
312 case kInt_t:
313 DispatchConvertArray<Int_t>(fVal->fKind, itmread, itmstore, nElements);
314 break;
315 case kLong_t:
316 DispatchConvertArray<Long_t>(fVal->fKind, itmread, itmstore, nElements);
317 break;
318 case kLong64_t:
319 DispatchConvertArray<Long64_t>(fVal->fKind, itmread, itmstore, nElements);
320 break;
321 case kFloat_t:
322 DispatchConvertArray<Float_t>(fVal->fKind, itmread, itmstore, nElements);
323 break;
324 case kFloat16_t:
325 DispatchConvertArray<Float16_t>(fVal->fKind, itmread, itmstore, nElements);
326 break;
327 case kDouble_t:
328 DispatchConvertArray<Double_t>(fVal->fKind, itmread, itmstore, nElements);
329 break;
330 case kUChar_t:
331 DispatchConvertArray<UChar_t>(fVal->fKind, itmread, itmstore, nElements);
332 break;
333 case kUShort_t:
334 DispatchConvertArray<UShort_t>(fVal->fKind, itmread, itmstore, nElements);
335 break;
336 case kUInt_t:
337 DispatchConvertArray<UInt_t>(fVal->fKind, itmread, itmstore, nElements);
338 break;
339 case kULong_t:
340 DispatchConvertArray<ULong_t>(fVal->fKind, itmread, itmstore, nElements);
341 break;
342 case kULong64_t:
343 DispatchConvertArray<ULong64_t>(fVal->fKind, itmread, itmstore, nElements);
344 break;
345 case kDouble32_t:
346 DispatchConvertArray<Double_t>(fVal->fKind, itmread, itmstore, nElements);
347 break;
348 case kchar:
349 case kNoType_t:
350 case kOther_t:
351 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", readkind);
352 }
353 ::operator delete((void*)itmconv);
354 }
355 if (feed) { // need to feed in data...
356 fEnv->fStart = fFeed(itmstore,fEnv->fObject,fEnv->fSize);
357 if (memory) {
358 ::operator delete(memory);
359 }
360 }
361}
362
363void TGenCollectionStreamer::ReadObjects(int nElements, TBuffer &b, const TClass *onFileClass)
364{
365 // Object input streamer.
366 Bool_t vsn3 = b.GetInfo() && b.GetInfo()->GetOldVersion() <= 3;
367 size_t len = fValDiff * nElements;
368 StreamHelper* itm = 0;
369 char buffer[8096];
370 void* memory = 0;
371
372 TClass* onFileValClass = (onFileClass ? onFileClass->GetCollectionProxy()->GetValueClass() : 0);
373
374 fEnv->fSize = nElements;
375 switch (fSTL_type) {
376 // Simple case: contiguous memory. get address of first, then jump.
377 case ROOT::kSTLvector:
378#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
379 fResize(fEnv->fObject,fEnv->fSize);
380 fEnv->fIdx = 0;
381
382 {
383 TVirtualVectorIterators iterators(fFunctionCreateIterators);
384 iterators.CreateIterators(fEnv->fObject);
385 itm = (StreamHelper*)iterators.fBegin;
386 }
387 fEnv->fStart = itm;
388 switch (fVal->fCase) {
389 case kIsClass:
390 DOLOOP(b.StreamObject(i, fVal->fType, onFileValClass ));
391 case EProperty(kBIT_ISSTRING):
392 DOLOOP(i->read_std_string(b));
393 case EProperty(kIsPointer | kIsClass):
394 DOLOOP(i->set(b.ReadObjectAny(fVal->fType)));
395 case EProperty(kIsPointer | kBIT_ISSTRING):
396 DOLOOP(i->read_std_string_pointer(b));
397 case EProperty(kIsPointer | kBIT_ISTSTRING | kIsClass):
398 DOLOOP(i->read_tstring_pointer(vsn3, b));
399 }
400#undef DOLOOP
401 break;
402
403 // No contiguous memory, but resize is possible
404 // Hence accessing objects using At(i) should be not too much an overhead
405 case ROOT::kSTLlist:
406 case ROOT::kSTLforwardlist:
407 case ROOT::kSTLdeque:
408#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
409 fResize(fEnv->fObject,fEnv->fSize);
410 fEnv->fIdx = 0;
411 fEnv->fStart = 0;
412 switch (fVal->fCase) {
413 case kIsClass:
414 DOLOOP(b.StreamObject(i, fVal->fType, onFileValClass));
415 case kBIT_ISSTRING:
416 DOLOOP(i->read_std_string(b));
417 case kIsPointer | kIsClass:
418 DOLOOP(i->set(b.ReadObjectAny(fVal->fType)));
419 case kIsPointer | kBIT_ISSTRING:
420 DOLOOP(i->read_std_string_pointer(b));
421 case kIsPointer | kBIT_ISTSTRING | kIsClass:
422 DOLOOP(i->read_tstring_pointer(vsn3, b));
423 }
424#undef DOLOOP
425 break;
426
427 // Rather troublesome case: Objects can only be fed into the container
428 // Once they are created. Need to take memory from stack or heap.
429 case ROOT::kSTLmultiset:
430 case ROOT::kSTLset:
431 case ROOT::kSTLunorderedset:
432 case ROOT::kSTLunorderedmultiset:
433#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;}}
434 fEnv->fStart = itm = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
435 fConstruct(itm,nElements);
436 switch (fVal->fCase) {
437 case kIsClass:
438 DOLOOP(b.StreamObject(i, fVal->fType, onFileValClass));
439 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
440 fDestruct(fEnv->fStart,fEnv->fSize);
441 break;
442 case EProperty(kBIT_ISSTRING):
443 DOLOOP(i->read_std_string(b))
444 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
445 fDestruct(fEnv->fStart,fEnv->fSize);
446 break;
447 case EProperty(kIsPointer | kIsClass):
448 DOLOOP(i->set(b.ReadObjectAny(fVal->fType)));
449 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
450 break;
451 case EProperty(kIsPointer | kBIT_ISSTRING):
452 DOLOOP(i->read_std_string_pointer(b))
453 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
454 break;
455 case EProperty(kIsPointer | kBIT_ISTSTRING | kIsClass):
456 DOLOOP(i->read_tstring_pointer(vsn3, b));
457 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
458 break;
459 }
460#undef DOLOOP
461 break;
462 default:
463 break;
464 }
465 if (memory) {
466 ::operator delete(memory);
467 }
468}
469
470void TGenCollectionStreamer::ReadPairFromMap(int nElements, TBuffer &b)
471{
472 // Input streamer to convert a map into another collection
473
474 Bool_t vsn3 = b.GetInfo() && b.GetInfo()->GetOldVersion() <= 3;
475 size_t len = fValDiff * nElements;
476 StreamHelper* itm = 0;
477 char buffer[8096];
478 void* memory = 0;
479
480 TStreamerInfo *pinfo = (TStreamerInfo*)fVal->fType->GetStreamerInfo();
481 R__ASSERT(pinfo);
482 R__ASSERT(fVal->fCase == kIsClass);
483
484 int nested = 0;
485 std::vector<std::string> inside;
486 TClassEdit::GetSplit(pinfo->GetName(), inside, nested);
487 Value first(inside[1],kFALSE);
488 Value second(inside[2],kFALSE);
489 fValOffset = ((TStreamerElement*)pinfo->GetElements()->At(1))->GetOffset();
490
491 fEnv->fSize = nElements;
492 switch (fSTL_type) {
493 // Simple case: contiguous memory. get address of first, then jump.
494 case ROOT::kSTLvector:
495#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
496 fResize(fEnv->fObject,fEnv->fSize);
497 fEnv->fIdx = 0;
498
499 {
500 TVirtualVectorIterators iterators(fFunctionCreateIterators);
501 iterators.CreateIterators(fEnv->fObject);
502 itm = (StreamHelper*)iterators.fBegin;
503 }
504 fEnv->fStart = itm;
505 switch (fVal->fCase) {
506 case kIsClass:
507 DOLOOP(
508 ReadMapHelper(i, &first, vsn3, b);
509 ReadMapHelper((StreamHelper*)(((char*)i) + fValOffset), &second, vsn3, b)
510 );
511 }
512#undef DOLOOP
513 break;
514
515 // No contiguous memory, but resize is possible
516 // Hence accessing objects using At(i) should be not too much an overhead
517 case ROOT::kSTLlist:
518 case ROOT::kSTLforwardlist:
519 case ROOT::kSTLdeque:
520#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
521 fResize(fEnv->fObject,fEnv->fSize);
522 fEnv->fIdx = 0;
523 {
524 TVirtualVectorIterators iterators(fFunctionCreateIterators);
525 iterators.CreateIterators(fEnv->fObject);
526 fEnv->fStart = iterators.fBegin;
527 }
528 switch (fVal->fCase) {
529 case kIsClass:
530 DOLOOP(
531 char **where = (char**)(void*) & i;
532 b.ApplySequence(*(pinfo->GetReadObjectWiseActions()), where);
533 );
534 }
535#undef DOLOOP
536 break;
537
538 // Rather troublesome case: Objects can only be fed into the container
539 // Once they are created. Need to take memory from stack or heap.
540 case ROOT::kSTLmultiset:
541 case ROOT::kSTLset:
542 case ROOT::kSTLunorderedset:
543 case ROOT::kSTLunorderedmultiset:
544#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;}}
545 fEnv->fStart = itm = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
546 fConstruct(itm,nElements);
547 switch (fVal->fCase) {
548 case kIsClass:
549 DOLOOP(
550 char **where = (char**)(void*) & i;
551 b.ApplySequence(*(pinfo->GetReadObjectWiseActions()), where);
552 );
553 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
554 fDestruct(fEnv->fStart,fEnv->fSize);
555 break;
556 }
557#undef DOLOOP
558 break;
559 default:
560 break;
561 }
562 if (memory) {
563 ::operator delete(memory);
564 }
565}
566
567
568void TGenCollectionStreamer::ReadMapHelper(StreamHelper *i, Value *v, Bool_t vsn3, TBuffer &b)
569{
570 // helper class to read std::map
571
572 float f;
573
574 switch (v->fCase) {
575 case kIsFundamental: // Only handle primitives this way
576 case kIsEnum:
577 switch (int(v->fKind)) {
578 case kBool_t:
579 b >> i->boolean;
580 break;
581 case kChar_t:
582 b >> i->s_char;
583 break;
584 case kShort_t:
585 b >> i->s_short;
586 break;
587 case kInt_t:
588 b >> i->s_int;
589 break;
590 case kLong_t:
591 b >> i->s_long;
592 break;
593 case kLong64_t:
594 b >> i->s_longlong;
595 break;
596 case kFloat_t:
597 b >> i->flt;
598 break;
599 case kFloat16_t:
600 b >> f;
601 i->flt = float(f);
602 break;
603 case kDouble_t:
604 b >> i->dbl;
605 break;
606 case kUChar_t:
607 b >> i->u_char;
608 break;
609 case kUShort_t:
610 b >> i->u_short;
611 break;
612 case kUInt_t:
613 b >> i->u_int;
614 break;
615 case kULong_t:
616 b >> i->u_long;
617 break;
618 case kULong64_t:
619 b >> i->u_longlong;
620 break;
621 case kDouble32_t:
622 b >> f;
623 i->dbl = double(f);
624 break;
625 case kchar:
626 case kNoType_t:
627 case kOther_t:
628 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", v->fKind);
629 }
630 break;
631 case kIsClass:
632 b.StreamObject(i, v->fType);
633 break;
634 case kBIT_ISSTRING:
635 i->read_std_string(b);
636 break;
637 case kIsPointer | kIsClass:
638 i->set(b.ReadObjectAny(v->fType));
639 break;
640 case kIsPointer | kBIT_ISSTRING:
641 i->read_std_string_pointer(b);
642 break;
643 case kIsPointer | kBIT_ISTSTRING | kIsClass:
644 i->read_tstring_pointer(vsn3, b);
645 break;
646 }
647}
648
649template <typename To>
650To readOneValue(TBuffer &b, int readtype) {
651 TGenCollectionProxy::StreamHelper itm;
652 TGenCollectionProxy::StreamHelper *i = &itm;
653 switch (readtype) {
654 case kBool_t:
655 b >> i->boolean;
656 return (To)i->boolean;
657 break;
658 case kChar_t:
659 b >> i->s_char;
660 return (To)i->s_char;
661 break;
662 case kShort_t:
663 b >> i->s_short;
664 return (To)i->s_short;
665 break;
666 case kInt_t:
667 b >> i->s_int;
668 return (To)i->s_int;
669 break;
670 case kLong_t:
671 b >> i->s_long;
672 return (To)i->s_long;
673 break;
674 case kLong64_t:
675 b >> i->s_longlong;
676 return (To)i->s_longlong;
677 break;
678 case kFloat_t:
679 b >> i->flt;
680 return (To)i->flt;
681 break;
682 case kFloat16_t:
683 b >> i->flt;
684 return (To)i->flt;
685 break;
686 case kDouble_t:
687 b >> i->dbl;
688 return (To)i->dbl;
689 break;
690 case kUChar_t:
691 b >> i->u_char;
692 return (To)i->u_char;
693 break;
694 case kUShort_t:
695 b >> i->u_short;
696 return (To)i->u_short;
697 break;
698 case kUInt_t:
699 b >> i->u_int;
700 return (To)i->u_int;
701 break;
702 case kULong_t:
703 b >> i->u_long;
704 return (To)i->u_long;
705 break;
706 case kULong64_t:
707 b >> i->u_longlong;
708 return (To)i->u_longlong;
709 break;
710 case kDouble32_t: {
711 float f;
712 b >> f;
713 i->dbl = double(f);
714 return (To)i->dbl;
715 break;
716 }
717 case kchar:
718 case kNoType_t:
719 case kOther_t:
720 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", readtype);
721 }
722 return 0;
723}
724
725
726void TGenCollectionStreamer::ReadMap(int nElements, TBuffer &b, const TClass *onFileClass)
727{
728 // Map input streamer.
729 Bool_t vsn3 = b.GetInfo() && b.GetInfo()->GetOldVersion() <= 3;
730 size_t len = fValDiff * nElements;
731 Value *v;
732 char buffer[8096], *addr, *temp;
733 void* memory = 0;
734 StreamHelper* i;
735 float f;
736 fEnv->fSize = nElements;
737 fEnv->fStart = (len < sizeof(buffer) ? buffer : memory =::operator new(len));
738 addr = temp = (char*)fEnv->fStart;
739 fConstruct(addr,nElements);
740
741 int onFileValueKind[2];
742 if (onFileClass) {
743 TClass *onFileValueClass = onFileClass->GetCollectionProxy()->GetValueClass();
744 TVirtualStreamerInfo *sourceInfo = onFileValueClass->GetStreamerInfo();
745 onFileValueKind[0] = ((TStreamerElement*)sourceInfo->GetElements()->At(0))->GetType();
746 onFileValueKind[1] = ((TStreamerElement*)sourceInfo->GetElements()->At(1))->GetType();
747 }
748 for (int loop, idx = 0; idx < nElements; ++idx) {
749 addr = temp + fValDiff * idx;
750 v = fKey;
751 for (loop = 0; loop < 2; loop++) {
752 i = (StreamHelper*)addr;
753 switch (v->fCase) {
754 case kIsFundamental: // Only handle primitives this way
755 case kIsEnum:
756 if (onFileClass) {
757 int readtype = (int)(onFileValueKind[loop]);
758 switch (int(v->fKind)) {
759 case kBool_t:
760 i->boolean = readOneValue<bool>(b,readtype);
761 break;
762 case kChar_t:
763 i->s_char = readOneValue<Char_t>(b,readtype);
764 break;
765 case kShort_t:
766 i->s_short = readOneValue<Short_t>(b,readtype);
767 break;
768 case kInt_t:
769 i->s_int = readOneValue<Int_t>(b,readtype);
770 break;
771 case kLong_t:
772 i->s_long = readOneValue<Long_t>(b,readtype);
773 break;
774 case kLong64_t:
775 i->s_longlong = readOneValue<Long64_t>(b,readtype);
776 break;
777 case kFloat_t:
778 i->flt = readOneValue<Float_t>(b,readtype);
779 break;
780 case kFloat16_t:
781 i->flt = readOneValue<Float16_t>(b,readtype);
782 break;
783 case kDouble_t:
784 i->dbl = readOneValue<Double_t>(b,readtype);
785 break;
786 case kUChar_t:
787 i->u_char = readOneValue<UChar_t>(b,readtype);
788 break;
789 case kUShort_t:
790 i->u_short = readOneValue<UShort_t>(b,readtype);
791 break;
792 case kUInt_t:
793 i->u_int = readOneValue<UInt_t>(b,readtype);
794 break;
795 case kULong_t:
796 i->u_long = readOneValue<ULong_t>(b,readtype);
797 break;
798 case kULong64_t:
799 i->u_longlong = readOneValue<ULong64_t>(b,readtype);
800 break;
801 case kDouble32_t:
802 i->dbl = readOneValue<Double32_t>(b,readtype);
803 break;
804 case kchar:
805 case kNoType_t:
806 case kOther_t:
807 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", v->fKind);
808 }
809 } else {
810 switch (int(v->fKind)) {
811 case kBool_t:
812 b >> i->boolean;
813 break;
814 case kChar_t:
815 b >> i->s_char;
816 break;
817 case kShort_t:
818 b >> i->s_short;
819 break;
820 case kInt_t:
821 b >> i->s_int;
822 break;
823 case kLong_t:
824 b >> i->s_long;
825 break;
826 case kLong64_t:
827 b >> i->s_longlong;
828 break;
829 case kFloat_t:
830 b >> i->flt;
831 break;
832 case kFloat16_t:
833 b >> f;
834 i->flt = float(f);
835 break;
836 case kDouble_t:
837 b >> i->dbl;
838 break;
839 case kUChar_t:
840 b >> i->u_char;
841 break;
842 case kUShort_t:
843 b >> i->u_short;
844 break;
845 case kUInt_t:
846 b >> i->u_int;
847 break;
848 case kULong_t:
849 b >> i->u_long;
850 break;
851 case kULong64_t:
852 b >> i->u_longlong;
853 break;
854 case kDouble32_t:
855 b >> f;
856 i->dbl = double(f);
857 break;
858 case kchar:
859 case kNoType_t:
860 case kOther_t:
861 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", v->fKind);
862 }
863 }
864 break;
865 case kIsClass:
866 b.StreamObject(i, v->fType);
867 break;
868 case EProperty(kBIT_ISSTRING):
869 i->read_std_string(b);
870 break;
871 case EProperty(kIsPointer | kIsClass):
872 i->set(b.ReadObjectAny(v->fType));
873 break;
874 case EProperty(kIsPointer | kBIT_ISSTRING):
875 i->read_std_string_pointer(b);
876 break;
877 case EProperty(kIsPointer | kBIT_ISTSTRING | kIsClass):
878 i->read_tstring_pointer(vsn3, b);
879 break;
880 }
881 v = fVal;
882 addr += fValOffset;
883 }
884 }
885 fFeed(fEnv->fStart,fEnv->fObject,fEnv->fSize);
886 fDestruct(fEnv->fStart,fEnv->fSize);
887 if (memory) {
888 ::operator delete(memory);
889 }
890}
891
892void TGenCollectionStreamer::WritePrimitives(int nElements, TBuffer &b)
893{
894 // Primitive output streamer.
895 size_t len = fValDiff * nElements;
896 char buffer[8192];
897 void* memory = 0;
898 StreamHelper* itm = 0;
899 switch (fSTL_type) {
900 case ROOT::kSTLvector:
901 if (fVal->fKind != kBool_t) {
902 itm = (StreamHelper*)(fEnv->fStart = fFirst.invoke(fEnv));
903 break;
904 }
905 default:
906 fEnv->fStart = itm = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
907 fCollect(fEnv->fObject,itm);
908 break;
909 }
910 switch (int(fVal->fKind)) {
911 case kBool_t:
912 b.WriteFastArray(&itm->boolean , nElements);
913 break;
914 case kChar_t:
915 b.WriteFastArray(&itm->s_char , nElements);
916 break;
917 case kShort_t:
918 b.WriteFastArray(&itm->s_short , nElements);
919 break;
920 case kInt_t:
921 b.WriteFastArray(&itm->s_int , nElements);
922 break;
923 case kLong_t:
924 b.WriteFastArray(&itm->s_long , nElements);
925 break;
926 case kLong64_t:
927 b.WriteFastArray(&itm->s_longlong, nElements);
928 break;
929 case kFloat_t:
930 b.WriteFastArray(&itm->flt , nElements);
931 break;
932 case kFloat16_t:
933 b.WriteFastArrayFloat16(&itm->flt, nElements);
934 break;
935 case kDouble_t:
936 b.WriteFastArray(&itm->dbl , nElements);
937 break;
938 case kUChar_t:
939 b.WriteFastArray(&itm->u_char , nElements);
940 break;
941 case kUShort_t:
942 b.WriteFastArray(&itm->u_short , nElements);
943 break;
944 case kUInt_t:
945 b.WriteFastArray(&itm->u_int , nElements);
946 break;
947 case kULong_t:
948 b.WriteFastArray(&itm->u_long , nElements);
949 break;
950 case kULong64_t:
951 b.WriteFastArray(&itm->u_longlong, nElements);
952 break;
953 case kDouble32_t:
954 b.WriteFastArrayDouble32(&itm->dbl, nElements);
955 break;
956 case kchar:
957 case kNoType_t:
958 case kOther_t:
959 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", fVal->fKind);
960 }
961 if (memory) {
962 ::operator delete(memory);
963 }
964}
965
966void TGenCollectionStreamer::WriteObjects(int nElements, TBuffer &b)
967{
968 // Object output streamer.
969 StreamHelper* itm = 0;
970 switch (fSTL_type) {
971 // Simple case: contiguous memory. get address of first, then jump.
972 case ROOT::kSTLvector:
973#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
974 itm = (StreamHelper*)fFirst.invoke(fEnv);
975 switch (fVal->fCase) {
976 case kIsClass:
977 DOLOOP(b.StreamObject(i, fVal->fType));
978 break;
979 case kBIT_ISSTRING:
980 DOLOOP(TString(i->c_str()).Streamer(b));
981 break;
982 case kIsPointer | kIsClass:
983 DOLOOP(b.WriteObjectAny(i->ptr(), fVal->fType));
984 break;
985 case kBIT_ISSTRING | kIsPointer:
986 DOLOOP(i->write_std_string_pointer(b));
987 break;
988 case kBIT_ISTSTRING | kIsClass | kIsPointer:
989 DOLOOP(i->write_tstring_pointer(b));
990 break;
991 }
992#undef DOLOOP
993 break;
994
995 // No contiguous memory, but resize is possible
996 // Hence accessing objects using At(i) should be not too much an overhead
997 case ROOT::kSTLlist:
998 case ROOT::kSTLforwardlist:
999 case ROOT::kSTLdeque:
1000 case ROOT::kSTLmultiset:
1001 case ROOT::kSTLset:
1002 case ROOT::kSTLunorderedset:
1003 case ROOT::kSTLunorderedmultiset:
1004#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
1005 switch (fVal->fCase) {
1006 case kIsClass:
1007 DOLOOP(b.StreamObject(i, fVal->fType));
1008 case kBIT_ISSTRING:
1009 DOLOOP(TString(i->c_str()).Streamer(b));
1010 case kIsPointer | kIsClass:
1011 DOLOOP(b.WriteObjectAny(i->ptr(), fVal->fType));
1012 case kBIT_ISSTRING | kIsPointer:
1013 DOLOOP(i->write_std_string_pointer(b));
1014 case kBIT_ISTSTRING | kIsClass | kIsPointer:
1015 DOLOOP(i->write_tstring_pointer(b));
1016 }
1017#undef DOLOOP
1018 break;
1019 default:
1020 break;
1021 }
1022}
1023
1024void TGenCollectionStreamer::WriteMap(int nElements, TBuffer &b)
1025{
1026 // Map output streamer
1027 StreamHelper* i;
1028 Value *v;
1029
1030 for (int loop, idx = 0; idx < nElements; ++idx) {
1031 char* addr = (char*)TGenCollectionProxy::At(idx);
1032 v = fKey;
1033 for (loop = 0; loop < 2; ++loop) {
1034 i = (StreamHelper*)addr;
1035 switch (v->fCase) {
1036 case kIsFundamental: // Only handle primitives this way
1037 case kIsEnum:
1038 switch (int(v->fKind)) {
1039 case kBool_t:
1040 b << i->boolean;
1041 break;
1042 case kChar_t:
1043 b << i->s_char;
1044 break;
1045 case kShort_t:
1046 b << i->s_short;
1047 break;
1048 case kInt_t:
1049 b << i->s_int;
1050 break;
1051 case kLong_t:
1052 b << i->s_long;
1053 break;
1054 case kLong64_t:
1055 b << i->s_longlong;
1056 break;
1057 case kFloat_t:
1058 b << i->flt;
1059 break;
1060 case kFloat16_t:
1061 b << float(i->flt);
1062 break;
1063 case kDouble_t:
1064 b << i->dbl;
1065 break;
1066 case kUChar_t:
1067 b << i->u_char;
1068 break;
1069 case kUShort_t:
1070 b << i->u_short;
1071 break;
1072 case kUInt_t:
1073 b << i->u_int;
1074 break;
1075 case kULong_t:
1076 b << i->u_long;
1077 break;
1078 case kULong64_t:
1079 b << i->u_longlong;
1080 break;
1081 case kDouble32_t:
1082 b << float(i->dbl);
1083 break;
1084 case kchar:
1085 case kNoType_t:
1086 case kOther_t:
1087 Error("TGenCollectionStreamer", "fType %d is not supported yet!\n", v->fKind);
1088 }
1089 break;
1090 case kIsClass:
1091 b.StreamObject(i, v->fType);
1092 break;
1093 case kBIT_ISSTRING:
1094 TString(i->c_str()).Streamer(b);
1095 break;
1096 case kIsPointer | kIsClass:
1097 b.WriteObjectAny(i->ptr(), v->fType);
1098 break;
1099 case kBIT_ISSTRING | kIsPointer:
1100 i->write_std_string_pointer(b);
1101 break;
1102 case kBIT_ISTSTRING | kIsClass | kIsPointer:
1103 i->write_tstring_pointer(b);
1104 break;
1105 }
1106 addr += fValOffset;
1107 v = fVal;
1108 }
1109 }
1110}
1111
1112template <typename From, typename To>
1113void TGenCollectionStreamer::ConvertBufferVectorPrimitives(TBuffer &b, void *obj, Int_t nElements)
1114{
1115 From *temp = new From[nElements];
1116 b.ReadFastArray(temp, nElements);
1117 std::vector<To> *const vec = (std::vector<To>*)(obj);
1118 for(Int_t ind = 0; ind < nElements; ++ind) {
1119 (*vec)[ind] = (To)temp[ind];
1120 }
1121 delete [] temp;
1122}
1123
1124template <typename To>
1125void TGenCollectionStreamer::ConvertBufferVectorPrimitivesFloat16(TBuffer &b, void *obj, Int_t nElements)
1126{
1127 Float16_t *temp = new Float16_t[nElements];
1128 b.ReadFastArrayFloat16(temp, nElements);
1129 std::vector<To> *const vec = (std::vector<To>*)(obj);
1130 for(Int_t ind = 0; ind < nElements; ++ind) {
1131 (*vec)[ind] = (To)temp[ind];
1132 }
1133 delete [] temp;
1134}
1135
1136template <typename To>
1137void TGenCollectionStreamer::ConvertBufferVectorPrimitivesDouble32(TBuffer &b, void *obj, Int_t nElements)
1138{
1139 Double32_t *temp = new Double32_t[nElements];
1140 b.ReadFastArrayDouble32(temp, nElements);
1141 std::vector<To> *const vec = (std::vector<To>*)(obj);
1142 for(Int_t ind = 0; ind < nElements; ++ind) {
1143 (*vec)[ind] = (To)temp[ind];
1144 }
1145 delete [] temp;
1146}
1147
1148template <typename To>
1149void TGenCollectionStreamer::DispatchConvertBufferVectorPrimitives(TBuffer &b, void *obj, Int_t nElements, const TVirtualCollectionProxy *onFileProxy)
1150{
1151 switch ((TStreamerInfo::EReadWrite)onFileProxy->GetType()) {
1152 case TStreamerInfo::kBool: ConvertBufferVectorPrimitives<Bool_t ,To>(b,obj,nElements); break;
1153 case TStreamerInfo::kChar: ConvertBufferVectorPrimitives<Char_t ,To>(b,obj,nElements); break;
1154 case TStreamerInfo::kShort: ConvertBufferVectorPrimitives<Short_t ,To>(b,obj,nElements); break;
1155 case TStreamerInfo::kInt: ConvertBufferVectorPrimitives<Int_t ,To>(b,obj,nElements); break;
1156 case TStreamerInfo::kLong: ConvertBufferVectorPrimitives<Long_t ,To>(b,obj,nElements); break;
1157 case TStreamerInfo::kLong64: ConvertBufferVectorPrimitives<Long64_t ,To>(b,obj,nElements); break;
1158 case TStreamerInfo::kFloat: ConvertBufferVectorPrimitives<Float_t ,To>(b,obj,nElements); break;
1159 case TStreamerInfo::kFloat16: ConvertBufferVectorPrimitives<Float16_t ,To>(b,obj,nElements); break;
1160 case TStreamerInfo::kDouble: ConvertBufferVectorPrimitives<Double_t ,To>(b,obj,nElements); break;
1161 case TStreamerInfo::kDouble32: ConvertBufferVectorPrimitives<Double32_t,To>(b,obj,nElements); break;
1162 case TStreamerInfo::kUChar: ConvertBufferVectorPrimitives<UChar_t ,To>(b,obj,nElements); break;
1163 case TStreamerInfo::kUShort: ConvertBufferVectorPrimitives<UShort_t ,To>(b,obj,nElements); break;
1164 case TStreamerInfo::kUInt: ConvertBufferVectorPrimitives<UInt_t ,To>(b,obj,nElements); break;
1165 case TStreamerInfo::kULong: ConvertBufferVectorPrimitives<ULong_t ,To>(b,obj,nElements); break;
1166 case TStreamerInfo::kULong64: ConvertBufferVectorPrimitives<ULong64_t ,To>(b,obj,nElements); break;
1167 default: break;
1168 }
1169}
1170
1171template <typename basictype>
1172void TGenCollectionStreamer::ReadBufferVectorPrimitives(TBuffer &b, void *obj, const TClass *onFileClass)
1173{
1174 int nElements = 0;
1175 b >> nElements;
1176 fResize(obj,nElements);
1177
1178 if (onFileClass) {
1179 DispatchConvertBufferVectorPrimitives<basictype>(b,obj,nElements,onFileClass->GetCollectionProxy());
1180 } else {
1181 TVirtualVectorIterators iterators(fFunctionCreateIterators);
1182 iterators.CreateIterators(obj);
1183 b.ReadFastArray((basictype*)iterators.fBegin, nElements);
1184 }
1185}
1186
1187void TGenCollectionStreamer::ReadBufferVectorPrimitivesFloat16(TBuffer &b, void *obj, const TClass *onFileClass)
1188{
1189 int nElements = 0;
1190 b >> nElements;
1191 fResize(obj,nElements);
1192
1193 if (onFileClass) {
1194 DispatchConvertBufferVectorPrimitives<Float16_t>(b,obj,nElements,onFileClass->GetCollectionProxy());
1195 } else {
1196 TVirtualVectorIterators iterators(fFunctionCreateIterators);
1197 iterators.CreateIterators(obj);
1198 b.ReadFastArrayFloat16((Float16_t*)iterators.fBegin, nElements);
1199 }
1200}
1201
1202void TGenCollectionStreamer::ReadBufferVectorPrimitivesDouble32(TBuffer &b, void *obj, const TClass *onFileClass)
1203{
1204 int nElements = 0;
1205 b >> nElements;
1206 fResize(obj,nElements);
1207
1208 if (onFileClass) {
1209 DispatchConvertBufferVectorPrimitives<Double32_t>(b,obj,nElements,onFileClass->GetCollectionProxy());
1210 } else {
1211 TVirtualVectorIterators iterators(fFunctionCreateIterators);
1212 iterators.CreateIterators(obj);
1213 b.ReadFastArrayDouble32((Double32_t*)iterators.fBegin, nElements);
1214 }
1215}
1216
1217
1218
1219void TGenCollectionStreamer::ReadBuffer(TBuffer &b, void *obj, const TClass *onFileClass)
1220{
1221 // Call the specialized function. The first time this call ReadBufferDefault which
1222 // actually set to fReadBufferFunc to the 'right' specialized version.
1223
1224 (this->*fReadBufferFunc)(b,obj,onFileClass);
1225}
1226
1227void TGenCollectionStreamer::ReadBuffer(TBuffer &b, void *obj)
1228{
1229 // Call the specialized function. The first time this call ReadBufferDefault which
1230 // actually set to fReadBufferFunc to the 'right' specialized version.
1231
1232 (this->*fReadBufferFunc)(b,obj,0);
1233}
1234
1235void TGenCollectionStreamer::ReadBufferDefault(TBuffer &b, void *obj, const TClass *onFileClass)
1236{
1237
1238 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferGeneric;
1239
1240 // We will need this later, so let's make sure it is initialized.
1241 if ( !fValue.load() ) InitializeEx(kFALSE);
1242 if (!GetFunctionCreateIterators()) {
1243 Fatal("TGenCollectionStreamer::ReadBufferDefault","No CreateIterators function for %s",fName.c_str());
1244 }
1245 if (fSTL_type == ROOT::kSTLvector && ( fVal->fCase == kIsFundamental || fVal->fCase == kIsEnum ) )
1246 {
1247 // Only handle primitives this way
1248 switch (int(fVal->fKind)) {
1249 case kBool_t:
1250 // Nothing use generic for now
1251 break;
1252 case kChar_t:
1253 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Char_t>;
1254 break;
1255 case kShort_t:
1256 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Short_t>;
1257 break;
1258 case kInt_t:
1259 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Int_t>;
1260 break;
1261 case kLong_t:
1262 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Long_t>;
1263 break;
1264 case kLong64_t:
1265 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Long64_t>;
1266 break;
1267 case kFloat_t:
1268 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Float_t>;
1269 break;
1270 case kFloat16_t:
1271 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitivesFloat16;
1272 break;
1273 case kDouble_t:
1274 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<Double_t>;
1275 break;
1276 case kUChar_t:
1277 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<UChar_t>;
1278 break;
1279 case kUShort_t:
1280 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<UShort_t>;
1281 break;
1282 case kUInt_t:
1283 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<UInt_t>;
1284 break;
1285 case kULong_t:
1286 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<ULong_t>;
1287 break;
1288 case kULong64_t:
1289 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitives<ULong64_t>;
1290 break;
1291 case kDouble32_t:
1292 fReadBufferFunc = &TGenCollectionStreamer::ReadBufferVectorPrimitivesDouble32;
1293 break;
1294 case kchar:
1295 case kNoType_t:
1296 case kOther_t:
1297 // Nothing use the generic for now
1298 break;
1299 }
1300 }
1301 (this->*fReadBufferFunc)(b,obj,onFileClass);
1302}
1303
1304void TGenCollectionStreamer::ReadBufferGeneric(TBuffer &b, void *obj, const TClass *onFileClass)
1305{
1306 TVirtualCollectionProxy::TPushPop env(this, obj);
1307
1308 int nElements = 0;
1309 b >> nElements;
1310
1311 if (nElements == 0) {
1312 if (obj) {
1313 TGenCollectionProxy::Clear("force");
1314 }
1315 } else if (nElements > 0) {
1316 switch (fSTL_type) {
1317 case ROOT::kSTLbitset:
1318 if (obj) {
1319 if (fProperties & kNeedDelete) {
1320 TGenCollectionProxy::Clear("force");
1321 } else {
1322 fClear.invoke(fEnv);
1323 }
1324 }
1325 ReadPrimitives(nElements, b, onFileClass);
1326 return;
1327 case ROOT::kSTLvector:
1328 if (obj) {
1329 if (fProperties & kNeedDelete) {
1330 TGenCollectionProxy::Clear("force");
1331 } // a resize will be called in ReadPrimitives/ReadObjects.
1332 else if (fVal->fKind == kBool_t) {
1333 fClear.invoke(fEnv);
1334 }
1335 }
1336 switch (fVal->fCase) {
1337 case kIsFundamental: // Only handle primitives this way
1338 case kIsEnum:
1339 ReadPrimitives(nElements, b, onFileClass);
1340 return;
1341 default:
1342 ReadObjects(nElements, b, onFileClass);
1343 return;
1344 }
1345 break;
1346 case ROOT::kSTLlist:
1347 case ROOT::kSTLforwardlist:
1348 case ROOT::kSTLdeque:
1349 case ROOT::kSTLmultiset:
1350 case ROOT::kSTLset:
1351 case ROOT::kSTLunorderedset:
1352 case ROOT::kSTLunorderedmultiset:
1353 if (obj) {
1354 if (fProperties & kNeedDelete) {
1355 TGenCollectionProxy::Clear("force");
1356 } else {
1357 fClear.invoke(fEnv);
1358 }
1359 }
1360 switch (fVal->fCase) {
1361 case kIsFundamental: // Only handle primitives this way
1362 case kIsEnum:
1363 ReadPrimitives(nElements, b, onFileClass);
1364 return;
1365 default:
1366 ReadObjects(nElements, b, onFileClass);
1367 return;
1368 }
1369 break;
1370 case ROOT::kSTLmap:
1371 case ROOT::kSTLmultimap:
1372 case ROOT::kSTLunorderedmap:
1373 case ROOT::kSTLunorderedmultimap:
1374 if (obj) {
1375 if (fProperties & kNeedDelete) {
1376 TGenCollectionProxy::Clear("force");
1377 } else {
1378 fClear.invoke(fEnv);
1379 }
1380 }
1381 ReadMap(nElements, b, onFileClass);
1382 break;
1383 }
1384 }
1385}
1386
1387void TGenCollectionStreamer::Streamer(TBuffer &b)
1388{
1389 // TClassStreamer IO overload.
1390 if (b.IsReading()) { //Read mode
1391 int nElements = 0;
1392 b >> nElements;
1393 if (fEnv->fObject) {
1394 TGenCollectionProxy::Clear("force");
1395 }
1396 if (nElements > 0) {
1397 switch (fSTL_type) {
1398 case ROOT::kSTLbitset:
1399 ReadPrimitives(nElements, b, fOnFileClass);
1400 return;
1401 case ROOT::kSTLvector:
1402 case ROOT::kSTLlist:
1403 case ROOT::kSTLdeque:
1404 case ROOT::kSTLmultiset:
1405 case ROOT::kSTLset:
1406 case ROOT::kSTLunorderedset:
1407 case ROOT::kSTLunorderedmultiset:
1408 switch (fVal->fCase) {
1409 case kIsFundamental: // Only handle primitives this way
1410 case kIsEnum:
1411 ReadPrimitives(nElements, b, fOnFileClass);
1412 return;
1413 default:
1414 ReadObjects(nElements, b, fOnFileClass);
1415 return;
1416 }
1417 break;
1418 case ROOT::kSTLmap:
1419 case ROOT::kSTLmultimap:
1420 case ROOT::kSTLunorderedmap:
1421 case ROOT::kSTLunorderedmultimap:
1422 ReadMap(nElements, b, fOnFileClass);
1423 break;
1424 }
1425 }
1426 } else { // Write case
1427 int nElements = fEnv->fObject ? *(size_t*)fSize.invoke(fEnv) : 0;
1428 b << nElements;
1429 if (nElements > 0) {
1430 switch (fSTL_type) {
1431 case ROOT::kSTLbitset:
1432 WritePrimitives(nElements, b);
1433 return;
1434 case ROOT::kSTLvector:
1435 case ROOT::kSTLlist:
1436 case ROOT::kSTLforwardlist:
1437 case ROOT::kSTLdeque:
1438 case ROOT::kSTLmultiset:
1439 case ROOT::kSTLset:
1440 case ROOT::kSTLunorderedset:
1441 case ROOT::kSTLunorderedmultiset:
1442 switch (fVal->fCase) {
1443 case kIsFundamental: // Only handle primitives this way
1444 case kIsEnum:
1445 WritePrimitives(nElements, b);
1446 return;
1447 default:
1448 WriteObjects(nElements, b);
1449 return;
1450 }
1451 break;
1452 case ROOT::kSTLmap:
1453 case ROOT::kSTLmultimap:
1454 case ROOT::kSTLunorderedmap:
1455 case ROOT::kSTLunorderedmultimap:
1456 WriteMap(nElements, b);
1457 break;
1458 }
1459 }
1460 }
1461}
1462
1463void TGenCollectionStreamer::StreamerAsMap(TBuffer &b)
1464{
1465 // TClassStreamer IO overload.
1466 if (b.IsReading()) { //Read mode
1467 int nElements = 0;
1468 b >> nElements;
1469 if (fEnv->fObject) {
1470 TGenCollectionProxy::Clear("force");
1471 }
1472 if (nElements > 0) {
1473 switch (fSTL_type) {
1474 case ROOT::kSTLmap:
1475 case ROOT::kSTLmultimap:
1476 case ROOT::kSTLunorderedmap:
1477 case ROOT::kSTLunorderedmultimap:
1478 ReadMap(nElements, b, fOnFileClass);
1479 break;
1480 case ROOT::kSTLvector:
1481 case ROOT::kSTLlist:
1482 case ROOT::kSTLforwardlist:
1483 case ROOT::kSTLdeque:
1484 case ROOT::kSTLmultiset:
1485 case ROOT::kSTLset:
1486 case ROOT::kSTLunorderedset:
1487 case ROOT::kSTLunorderedmultiset:{
1488 ReadPairFromMap(nElements, b);
1489 break;
1490 }
1491 default:
1492 break;
1493 }
1494 }
1495 } else { // Write case
1496 Streamer(b);
1497 }
1498}
double
double
Definition Converters.cxx:921
r
ROOT::R::TRInterface & r
Definition Object.C:4
b
#define b(i)
Definition RSha256.hxx:100
f
#define f(i)
Definition RSha256.hxx:104
Float16_t
float Float16_t
Definition RtypesCore.h:58
UShort_t
unsigned short UShort_t
Definition RtypesCore.h:40
Double32_t
double Double32_t
Definition RtypesCore.h:60
Int_t
int Int_t
Definition RtypesCore.h:45
UChar_t
unsigned char UChar_t
Definition RtypesCore.h:38
Char_t
char Char_t
Definition RtypesCore.h:37
UInt_t
unsigned int UInt_t
Definition RtypesCore.h:46
kFALSE
const Bool_t kFALSE
Definition RtypesCore.h:92
ULong_t
unsigned long ULong_t
Definition RtypesCore.h:55
Long_t
long Long_t
Definition RtypesCore.h:54
Short_t
short Short_t
Definition RtypesCore.h:39
Double_t
double Double_t
Definition RtypesCore.h:59
Long64_t
long long Long64_t
Definition RtypesCore.h:73
ULong64_t
unsigned long long ULong64_t
Definition RtypesCore.h:74
Float_t
float Float_t
Definition RtypesCore.h:57
kNoType_t
@ kNoType_t
Definition TDataType.h:33
kFloat_t
@ kFloat_t
Definition TDataType.h:31
kULong64_t
@ kULong64_t
Definition TDataType.h:32
kInt_t
@ kInt_t
Definition TDataType.h:30
kchar
@ kchar
Definition TDataType.h:31
kLong_t
@ kLong_t
Definition TDataType.h:30
kDouble32_t
@ kDouble32_t
Definition TDataType.h:31
kShort_t
@ kShort_t
Definition TDataType.h:29
kBool_t
@ kBool_t
Definition TDataType.h:32
kULong_t
@ kULong_t
Definition TDataType.h:30
kLong64_t
@ kLong64_t
Definition TDataType.h:32
kUShort_t
@ kUShort_t
Definition TDataType.h:29
kDouble_t
@ kDouble_t
Definition TDataType.h:31
kChar_t
@ kChar_t
Definition TDataType.h:29
kUChar_t
@ kUChar_t
Definition TDataType.h:29
kUInt_t
@ kUInt_t
Definition TDataType.h:30
kFloat16_t
@ kFloat16_t
Definition TDataType.h:33
kOther_t
@ kOther_t
Definition TDataType.h:32
kIsPointer
@ kIsPointer
Definition TDictionary.h:78
kIsClass
@ kIsClass
Definition TDictionary.h:65
kIsEnum
@ kIsEnum
Definition TDictionary.h:68
kIsFundamental
@ kIsFundamental
Definition TDictionary.h:70
DOLOOP
#define DOLOOP(x)
R__ASSERT
#define R__ASSERT(e)
Definition TError.h:120
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:187
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:245
getaddress< bool >
bool * getaddress< bool >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:67
DispatchConvertArray
void DispatchConvertArray(int writeType, TGenCollectionProxy::StreamHelper *read, TGenCollectionProxy::StreamHelper *write, int nElements)
Definition TGenCollectionStreamer.cxx:156
getaddress< UChar_t >
UChar_t * getaddress< UChar_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:115
getaddress< Long_t >
Long_t * getaddress< Long_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:91
getaddress< ULong64_t >
ULong64_t * getaddress< ULong64_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:139
getaddress< UInt_t >
UInt_t * getaddress< UInt_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:127
getaddress< Long64_t >
Long64_t * getaddress< Long64_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:97
getaddress< UShort_t >
UShort_t * getaddress< UShort_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:121
readOneValue
To readOneValue(TBuffer &b, int readtype)
Definition TGenCollectionStreamer.cxx:650
getaddress< Float_t >
Float_t * getaddress< Float_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:103
getaddress< ULong_t >
ULong_t * getaddress< ULong_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:133
getaddress< Char_t >
Char_t * getaddress< Char_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:73
getaddress< Int_t >
Int_t * getaddress< Int_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:85
getaddress< Short_t >
Short_t * getaddress< Short_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:79
getaddress
T * getaddress(TGenCollectionProxy::StreamHelper &itm)
getaddress< Double_t >
Double_t * getaddress< Double_t >(TGenCollectionProxy::StreamHelper &itm)
Definition TGenCollectionStreamer.cxx:109
ConvertArray
void ConvertArray(TGenCollectionProxy::StreamHelper *read, TGenCollectionProxy::StreamHelper *write, int nElements)
Definition TGenCollectionStreamer.cxx:145
TBuffer
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:80
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:4576
TClass::GetCollectionProxy
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2886
TGenCollectionProxy::Method::invoke
void * invoke(void *obj) const
Definition TGenCollectionProxy.h:201
TGenCollectionProxy
Proxy around an arbitrary container, which implements basic functionality and iteration.
Definition TGenCollectionProxy.h:31
TGenCollectionProxy::fFirst
Method fFirst
Container accessors: generic iteration: first.
Definition TGenCollectionProxy.h:304
TGenCollectionProxy::fValue
std::atomic< Value * > fValue
Descriptor of the container value type.
Definition TGenCollectionProxy.h:311
TGenCollectionProxy::GetType
virtual EDataType GetType() const
If the content is a simple numerical value, return its type (see TDataType)
Definition TGenCollectionProxy.cxx:1047
TGenCollectionProxy::fValOffset
int fValOffset
Offset from key to value (in maps)
Definition TGenCollectionProxy.h:315
TGenCollectionProxy::fEnv
EnvironBase_t * fEnv
Address of the currently proxied object.
Definition TGenCollectionProxy.h:314
TGenCollectionProxy::fCollect
Collectfunc_t fCollect
Method to collect objects from container.
Definition TGenCollectionProxy.h:309
TGenCollectionProxy::Initialize
TGenCollectionProxy * Initialize(Bool_t silent) const
Proxy initializer.
Definition TGenCollectionProxy.cxx:771
TGenCollectionProxy::InitializeEx
virtual TGenCollectionProxy * InitializeEx(Bool_t silent)
Proxy initializer.
Definition TGenCollectionProxy.cxx:844
TGenCollectionProxy::fName
std::string fName
Name of the class being proxied.
Definition TGenCollectionProxy.h:299
TGenCollectionProxy::fSTL_type
int fSTL_type
STL container type.
Definition TGenCollectionProxy.h:320
TGenCollectionProxy::fKey
Value * fKey
Descriptor of the key_type.
Definition TGenCollectionProxy.h:313
TGenCollectionProxy::fDestruct
Sizing_t fDestruct
Container accessors: block destruct.
Definition TGenCollectionProxy.h:307
TGenCollectionProxy::fVal
Value * fVal
Descriptor of the Value_type.
Definition TGenCollectionProxy.h:312
TGenCollectionProxy::fOnFileClass
TClass * fOnFileClass
On file class.
Definition TGenCollectionProxy.h:322
TGenCollectionProxy::fResize
Sizing_t fResize
Container accessors: resize container.
Definition TGenCollectionProxy.h:303
TGenCollectionProxy::fConstruct
ArrIterfunc_t fConstruct
Container accessors: block construct.
Definition TGenCollectionProxy.h:306
TGenCollectionProxy::At
virtual void * At(UInt_t idx)
Return the address of the value at index 'idx'.
Definition TGenCollectionProxy.cxx:1060
TGenCollectionProxy::fFunctionCreateIterators
CreateIterators_t fFunctionCreateIterators
Definition TGenCollectionProxy.h:324
TGenCollectionProxy::Clear
virtual void Clear(const char *opt="")
Clear the emulated collection.
Definition TGenCollectionProxy.cxx:1130
TGenCollectionProxy::fSize
Method fSize
Container accessors: size of container.
Definition TGenCollectionProxy.h:302
TGenCollectionProxy::fClear
Method fClear
Method cache for container accessors: clear container.
Definition TGenCollectionProxy.h:301
TGenCollectionProxy::fFeed
Feedfunc_t fFeed
Container accessors: block feed.
Definition TGenCollectionProxy.h:308
TGenCollectionProxy::GetFunctionCreateIterators
virtual CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE)
See typedef void (*CreateIterators_t)(void *collection, void *&begin_arena, void *&end_arena); begin_...
Definition TGenCollectionProxy.cxx:1600
TGenCollectionProxy::fValDiff
int fValDiff
Offset between two consecutive value_types (memory layout).
Definition TGenCollectionProxy.h:316
TGenCollectionProxy::Info_t
const std::type_info & Info_t
Definition TGenCollectionProxy.h:41
TGenCollectionStreamer::ReadBufferDefault
void ReadBufferDefault(TBuffer &b, void *obj, const TClass *onFileClass)
Definition TGenCollectionStreamer.cxx:1235
TGenCollectionStreamer::ReadPrimitives
void ReadPrimitives(int nElements, TBuffer &b, const TClass *onfileClass)
Definition TGenCollectionStreamer.cxx:211
TGenCollectionStreamer::WriteObjects
void WriteObjects(int nElements, TBuffer &b)
Definition TGenCollectionStreamer.cxx:966
TGenCollectionStreamer::DispatchConvertBufferVectorPrimitives
void DispatchConvertBufferVectorPrimitives(TBuffer &b, void *obj, Int_t nElements, const TVirtualCollectionProxy *onfileProxy)
Definition TGenCollectionStreamer.cxx:1149
TGenCollectionStreamer::Generate
virtual TVirtualCollectionProxy * Generate() const
Virtual copy constructor.
Definition TGenCollectionStreamer.cxx:56
TGenCollectionStreamer::ReadBufferVectorPrimitivesDouble32
void ReadBufferVectorPrimitivesDouble32(TBuffer &b, void *obj, const TClass *onFileClass)
Definition TGenCollectionStreamer.cxx:1202
TGenCollectionStreamer::Streamer
virtual void Streamer(TBuffer &refBuffer)
Streamer Function.
Definition TGenCollectionStreamer.cxx:1387
TGenCollectionStreamer::WriteMap
void WriteMap(int nElements, TBuffer &b)
Definition TGenCollectionStreamer.cxx:1024
TGenCollectionStreamer::ReadMapHelper
void ReadMapHelper(StreamHelper *i, Value *v, Bool_t vsn3, TBuffer &b)
Definition TGenCollectionStreamer.cxx:568
TGenCollectionStreamer::ReadBufferVectorPrimitivesFloat16
void ReadBufferVectorPrimitivesFloat16(TBuffer &b, void *obj, const TClass *onFileClass)
Definition TGenCollectionStreamer.cxx:1187
TGenCollectionStreamer::ReadObjects
void ReadObjects(int nElements, TBuffer &b, const TClass *onfileClass)
Definition TGenCollectionStreamer.cxx:363
TGenCollectionStreamer::WritePrimitives
void WritePrimitives(int nElements, TBuffer &b)
Definition TGenCollectionStreamer.cxx:892
TGenCollectionStreamer::ConvertBufferVectorPrimitivesFloat16
void ConvertBufferVectorPrimitivesFloat16(TBuffer &b, void *obj, Int_t nElements)
Definition TGenCollectionStreamer.cxx:1125
TGenCollectionStreamer::ReadPairFromMap
void ReadPairFromMap(int nElements, TBuffer &b)
Definition TGenCollectionStreamer.cxx:470
TGenCollectionStreamer::TGenCollectionStreamer
TGenCollectionStreamer(const TGenCollectionStreamer &copy)
Definition TGenCollectionStreamer.cxx:33
TGenCollectionStreamer::ReadMap
void ReadMap(int nElements, TBuffer &b, const TClass *onfileClass)
Definition TGenCollectionStreamer.cxx:726
TGenCollectionStreamer::ConvertBufferVectorPrimitivesDouble32
void ConvertBufferVectorPrimitivesDouble32(TBuffer &b, void *obj, Int_t nElements)
Definition TGenCollectionStreamer.cxx:1137
TGenCollectionStreamer::ReadBuffer
virtual void ReadBuffer(TBuffer &b, void *obj, const TClass *onfileClass)
Definition TGenCollectionStreamer.cxx:1219
TGenCollectionStreamer::ConvertBufferVectorPrimitives
void ConvertBufferVectorPrimitives(TBuffer &b, void *obj, Int_t nElements)
Definition TGenCollectionStreamer.cxx:1113
TGenCollectionStreamer::StreamerAsMap
virtual void StreamerAsMap(TBuffer &refBuffer)
Definition TGenCollectionStreamer.cxx:1463
TGenCollectionStreamer::ReadBufferGeneric
void ReadBufferGeneric(TBuffer &b, void *obj, const TClass *onFileClass)
Definition TGenCollectionStreamer.cxx:1304
TGenCollectionStreamer::ReadBufferVectorPrimitives
void ReadBufferVectorPrimitives(TBuffer &b, void *obj, const TClass *onFileClass)
Definition TGenCollectionStreamer.cxx:1172
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
TObjArray::At
TObject * At(Int_t idx) const
Definition TObjArray.h:166
TStreamerInfo
Describe Streamer information for one class version.
Definition TStreamerInfo.h:44
TStreamerInfo::GetElements
TObjArray * GetElements() const
Definition TStreamerInfo.h:209
TStreamerInfo::EReadWrite
EReadWrite
Status bits See TVirtualStreamerInfo::EStatusBits for the values.
Definition TStreamerInfo.h:165
TStreamerInfo::kUChar
@ kUChar
Equal to TDataType's kchar.
Definition TStreamerInfo.h:170
TStreamerInfo::GetReadObjectWiseActions
TStreamerInfoActions::TActionSequence * GetReadObjectWiseActions()
Definition TStreamerInfo.h:214
TString
Basic string class.
Definition TString.h:136
TVirtualCollectionProxy::GetIncrement
virtual ULong_t GetIncrement() const =0
TVirtualCollectionProxy::GetType
virtual EDataType GetType() const =0
TVirtualCollectionProxy::GetValueClass
virtual TClass * GetValueClass() const =0
TVirtualStreamerInfo
Abstract Interface class describing Streamer information for one class.
Definition TVirtualStreamerInfo.h:37
TVirtualStreamerInfo::GetElements
virtual TObjArray * GetElements() const =0
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::kSTLdeque
@ kSTLdeque
Definition ESTLType.h:32
ROOT::kSTLvector
@ kSTLvector
Definition ESTLType.h:30
ROOT::kSTLunorderedmultimap
@ kSTLunorderedmultimap
Definition ESTLType.h:45
ROOT::kSTLunorderedset
@ kSTLunorderedset
Definition ESTLType.h:42
ROOT::kSTLlist
@ kSTLlist
Definition ESTLType.h:31
ROOT::kSTLforwardlist
@ kSTLforwardlist
Definition ESTLType.h:41
ROOT::kSTLunorderedmap
@ kSTLunorderedmap
Definition ESTLType.h:44
ROOT::kSTLmultimap
@ kSTLmultimap
Definition ESTLType.h:34
TClassEdit::GetSplit
int GetSplit(const char *type, std::vector< std::string > &output, int &nestedLoc, EModType mode=TClassEdit::kNone)
Stores in output (after emptying it) the split type.
Definition TClassEdit.cxx:1027
first
Definition first.py:1
v
@ v
Definition rootcling_impl.cxx:3649
TGenCollectionProxy::Value
Small helper to describe the Value_type or the key_type of an STL container.
Definition TGenCollectionProxy.h:60
TGenCollectionProxy::Value::fCase
UInt_t fCase
type of data of Value_type
Definition TGenCollectionProxy.h:64
TGenCollectionProxy::Value::fType
TClassRef fType
TClass reference of Value_type in collection.
Definition TGenCollectionProxy.h:66
TGenCollectionProxy::Value::fKind
EDataType fKind
kind of ROOT-fundamental type
Definition TGenCollectionProxy.h:67
TVirtualVectorIterators::CreateIterators
void CreateIterators(void *collection)
Definition TVirtualCollectionIterators.h:347
TGenCollectionProxy::StreamHelper
Helper class to facilitate I/O.
Definition TGenCollectionProxy.h:88
TGenCollectionProxy::StreamHelper::read_tstring_pointer
void read_tstring_pointer(Bool_t vsn3, TBuffer &b)
Definition TGenCollectionProxy.h:167