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