Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TGenCollectionProxy.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-2004, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TGenCollectionProxy.h"
14#include "TStreamerElement.h"
15#include "TClassEdit.h"
16#include "TClass.h"
17#include "TError.h"
18#include "TEnum.h"
19#include "TROOT.h"
20#include "TInterpreter.h" // For gInterpreterMutex
21#include "TVirtualMutex.h"
23#include "THashTable.h"
24#include "THashList.h"
25#include <cstdlib>
26
27#define MESSAGE(which,text)
28
29/**
30\class TGenVectorProxy
31\ingroup IO
32Local optimization class.
33
34Collection proxies get copied. On copy we switch the type of the
35proxy to the concrete STL type. The concrete types are optimized
36for element access.
37*/
38
40public:
41 // Standard Destructor
43 {
44 }
45 // Standard Destructor
47 {
48 }
49 // Return the address of the value at index 'idx'
50 void* At(UInt_t idx) override
51 {
52 if ( fEnv && fEnv->fObject ) {
53 fEnv->fIdx = idx;
54 switch( idx ) {
55 case 0:
56 return fEnv->fStart = fFirst.invoke(fEnv);
57 default:
58 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
59 return ((char*)fEnv->fStart) + fValDiff*idx;
60 }
61 }
62 Fatal("TGenVectorProxy","At> Logic error - no proxy object set.");
63 return nullptr;
64 }
65 // Call to delete/destruct individual item
66 void DeleteItem(Bool_t force, void* ptr) const override
67 {
68 if ( force && ptr ) {
71 TPushPop helper(proxy,ptr);
72 proxy->Clear("force");
73 }
74 fVal->DeleteItem(ptr);
75 }
76 }
77};
78
79/**
80\class TGenVectorBoolProxy
81\ingroup IO
82Local optimization class.
83
84Collection proxies get copied. On copy we switch the type of the
85proxy to the concrete STL type. The concrete types are optimized
86for element access.
87*/
90
91public:
93 {
94 // Standard Constructor.
95 }
97 {
98 // Standard Destructor.
99 }
100 void* At(UInt_t idx) override
101 {
102 // Return the address of the value at index 'idx'
103
104 // However we can 'take' the address of the content of std::vector<bool>.
105 if ( fEnv && fEnv->fObject ) {
106 auto vec = (std::vector<bool> *)(fEnv->fObject);
107 fLastValue = (*vec)[idx];
108 fEnv->fIdx = idx;
109 return &fLastValue;
110 }
111 Fatal("TGenVectorProxy","At> Logic error - no proxy object set.");
112 return nullptr;
113 }
114
115 void DeleteItem(Bool_t force, void* ptr) const override
116 {
117 // Call to delete/destruct individual item
118 if ( force && ptr ) {
119 fVal->DeleteItem(ptr);
120 }
121 }
122};
123
124//////////////////////////////////////////////////////////////////////////
125// //
126// class TGenBitsetProxy
127//
128// Local optimization class.
129//
130// Collection proxies get copied. On copy we switch the type of the
131// proxy to the concrete STL type. The concrete types are optimized
132// for element access.
133//
134//////////////////////////////////////////////////////////////////////////
136
137public:
139 {
140 // Standard Constructor.
141 }
143 {
144 // Standard Destructor.
145 }
146 void* At(UInt_t idx) override
147 {
148 // Return the address of the value at index 'idx'
149
150 if ( fEnv && fEnv->fObject ) {
151 switch( idx ) {
152 case 0:
154 fEnv->fIdx = idx;
155 break;
156 default:
157 fEnv->fIdx = idx - fEnv->fIdx;
158 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
160 fEnv->fIdx = idx;
161 break;
162 }
163 typedef ROOT::TCollectionProxyInfo::Environ<std::pair<size_t,Bool_t> > EnvType_t;
164 EnvType_t *e = (EnvType_t*)fEnv;
165 return &(e->fIterator.second);
166 }
167 Fatal("TGenVectorProxy","At> Logic error - no proxy object set.");
168 return 0;
169 }
170
171 void DeleteItem(Bool_t force, void* ptr) const override
172 {
173 // Call to delete/destruct individual item
174 if ( force && ptr ) {
175 fVal->DeleteItem(ptr);
176 }
177 }
178};
179
180/*
181\class TGenListProxy
182\ingroup IO
183Local optimization class.
184
185Collection proxies get copied. On copy we switch the type of the
186proxy to the concrete STL type. The concrete types are optimized
187for element access.
188**/
189
191public:
192 // Standard Destructor
194 {
195 }
196 // Standard Destructor
197 ~TGenListProxy() override
198 {
199 }
200 // Return the address of the value at index 'idx'
201 void* At(UInt_t idx) override
202 {
203 if ( fEnv && fEnv->fObject ) {
204 switch( idx ) {
205 case 0:
206 fEnv->fIdx = idx;
207 return fEnv->fStart = fFirst.invoke(fEnv);
208 default: {
209 fEnv->fIdx = idx - fEnv->fIdx;
210 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
211 void* result = fNext.invoke(fEnv);
212 fEnv->fIdx = idx;
213 return result;
214 }
215 }
216 }
217 Fatal("TGenListProxy","At> Logic error - no proxy object set.");
218 return nullptr;
219 }
220};
221
222/**
223\class TGenSetProxy
224\ingroup IO
225Localoptimization class.
226
227Collection proxies get copied. On copy we switch the type of the
228proxy to the concrete STL type. The concrete types are optimized
229for element access.
230*/
231
233public:
234 // Standard Destructor
236 {
237 }
238 // Standard Destructor
239 ~TGenSetProxy() override
240 {
241 }
242 // Return the address of the value at index 'idx'
243 void* At(UInt_t idx) override
244 {
245 if ( fEnv && fEnv->fObject ) {
246 if ( fEnv->fUseTemp ) {
247 return (((char*)fEnv->fTemp)+idx*fValDiff);
248 }
249 switch( idx ) {
250 case 0:
251 fEnv->fIdx = idx;
252 return fEnv->fStart = fFirst.invoke(fEnv);
253 default: {
254 fEnv->fIdx = idx - fEnv->fIdx;
255 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
256 void* result = fNext.invoke(fEnv);
257 fEnv->fIdx = idx;
258 return result;
259 }
260 }
261 }
262 Fatal("TGenSetProxy","At> Logic error - no proxy object set.");
263 return nullptr;
264 }
265};
266
267/**
268\class TGenMapProxy
269\ingroup IO
270Localoptimization class.
271
272Collection proxies get copied. On copy we switch the type of the
273proxy to the concrete STL type. The concrete types are optimized
274for element access.
275*/
276
278public:
279 // Standard Destructor
281 {
282 }
283 // Standard Destructor
284 ~TGenMapProxy() override
285 {
286 }
287 // Call to delete/destruct individual item
288 void DeleteItem(Bool_t force, void* ptr) const override
289 {
290 if (force) {
293 TPushPop helper(proxy,fKey->fCase&kIsPointer ? *(void**)ptr : ptr);
294 proxy->Clear("force");
295 }
298 char *addr = ((char*)ptr)+fValOffset;
299 TPushPop helper(proxy,fVal->fCase&kIsPointer ? *(void**)addr : addr);
300 proxy->Clear("force");
301 }
302 }
303 if ( fKey->fCase&kIsPointer ) {
304 fKey->DeleteItem(*(void**)ptr);
305 }
306 if ( fVal->fCase&kIsPointer ) {
307 char *addr = ((char*)ptr)+fValOffset;
308 fVal->DeleteItem(*(void**)addr);
309 }
310 }
311};
312
313////////////////////////////////////////////////////////////////////////////////
314/// Constructor.
315
316TGenCollectionProxy::Value::Value(const std::string& inside_type, Bool_t silent, size_t hint_pair_offset, size_t hint_pair_size)
317{
318 std::string inside = (inside_type.find("const ")==0) ? inside_type.substr(6) : inside_type;
319 fCase = 0;
320 fProperties = 0;
321 fCtor = 0;
322 fDtor = 0;
323 fDelete = 0;
324 fSize = std::string::npos;
326
327 // Let's treat the unique_ptr case
328 bool nameChanged = false;
329 std::string intype = TClassEdit::GetNameForIO(inside.c_str(), TClassEdit::EModType::kNone, &nameChanged);
330
331 bool isPointer = nameChanged; // unique_ptr is considered a pointer
332 // The incoming name is normalized (it comes from splitting the name of a TClass),
333 // so all we need to do is drop the last trailing star (if any) and record that information.
334 if (!nameChanged && intype[intype.length()-1] == '*') {
335 isPointer = true;
336 intype.pop_back();
337 if (intype[intype.length()-1] == '*') {
338 // The value is a pointer to a pointer
339 if (!silent)
340 Warning("TGenCollectionProxy::Value::Value", "I/O not supported for collection of pointer to pointer: %s", inside_type.c_str());
341 fSize = sizeof(void*);
342 fKind = kVoid_t;
343 return;
344 }
345 }
346
347 if ( intype.substr(0,6) == "string" || intype.substr(0,11) == "std::string" ) {
349 fType = TClass::GetClass("string");
350 fCtor = fType->GetNew();
353 if (isPointer) {
354 fCase |= kIsPointer;
355 fSize = sizeof(void*);
356 } else {
357 fSize = sizeof(std::string);
358 }
359 }
360 else {
361 // In the case where we have an emulated class,
362 // if the class is nested (in a class or a namespace),
363 // calling G__TypeInfo ti(inside.c_str());
364 // might fail because CINT does not known the nesting
365 // scope, so let's first look for an emulated class:
366
367 fType = TClass::GetClass(intype.c_str(),kTRUE,silent, hint_pair_offset, hint_pair_size);
368
369 if (fType) {
370 if (isPointer) {
371 fCase |= kIsPointer;
372 fSize = sizeof(void*);
373 if (fType == TString::Class()) {
375 }
376 }
377 fCase |= kIsClass;
378 fCtor = fType->GetNew();
381 } else {
383
384 // Try to avoid autoparsing.
385
386 THashTable *typeTable = dynamic_cast<THashTable*>( gROOT->GetListOfTypes() );
387 assert(typeTable && "The type of the list of type has changed");
388
389 TDataType *fundType = (TDataType *)typeTable->THashTable::FindObject( intype.c_str() );
390 if (fundType && fundType->GetType() < 0x17 && fundType->GetType() > 0) {
391 fKind = (EDataType)fundType->GetType();
392 // R__ASSERT((fKind>0 && fKind<0x17) || (fKind==-1&&(prop&kIsPointer)) );
393
395 if (isPointer) {
396 fCase |= kIsPointer;
397 fSize = sizeof(void*);
398 } else {
399 fSize = fundType->Size();
400 }
401 } else if (TEnum::GetEnum( intype.c_str(), TEnum::kNone) ) {
402 // This is a known enum.
403 fCase = kIsEnum;
404 fSize = sizeof(Int_t);
405 fKind = kInt_t;
406 if (isPointer) {
407 fCase |= kIsPointer;
408 fSize = sizeof(void*);
409 }
410 } else {
411 // This fallback solution should be hardly used ...
412 // One of the common use case is to 'discover' that this is a
413 // collection for the content of which we do not have a dictionary
414 // which can happen at least in the following cases:
415 // - empty emulated collection
416 // - emulated collection of enums
417 // In those two cases there is no StreamerInfo stored in the file
418 // for the content.
419
420 // R__ASSERT("FallBack, should be hardly used.");
421
422 TypeInfo_t *ti = gCling->TypeInfo_Factory();
423 gCling->TypeInfo_Init(ti,inside.c_str());
424 if ( !gCling->TypeInfo_IsValid(ti) ) {
425 if (isPointer) {
426 fCase |= kIsPointer;
427 fSize = sizeof(void*);
428 }
429 // Since we already search for GetClass earlier, this should
430 // never be true.
431// fType = TClass::GetClass(intype.c_str(),kTRUE,silent);
432// if (fType) {
433// fCase |= kIsClass;
434// fCtor = fType->GetNew();
435// fDtor = fType->GetDestructor();
436// fDelete = fType->GetDelete();
437// }
438// else {
439 // either we have an Emulated enum or a really unknown class!
440 // let's just claim its an enum :(
441 fCase = kIsEnum;
442 fSize = sizeof(Int_t);
443 fKind = kInt_t;
444// }
445 }
446 else {
448 if ( prop&kIsPointer ) {
449 fSize = sizeof(void*);
450 }
451 if ( prop&kIsStruct ) {
452 prop |= kIsClass;
453 }
454
455 if ( prop&kIsClass ) {
456 // We can get here in the case where the value if forward declared or
457 // is an std::pair that can not be (yet) emulated (eg. "std::pair<int,void*>")
458 fSize = std::string::npos;
459 if (!silent)
460 Error("TGenCollectionProxy", "Could not retrieve the TClass for %s", intype.c_str());
461// fType = TClass::GetClass(intype.c_str(),kTRUE,silent);
462// R__ASSERT(fType);
463// fCtor = fType->GetNew();
464// fDtor = fType->GetDestructor();
465// fDelete = fType->GetDelete();
466 }
467 else if ( prop&kIsFundamental ) {
468 fundType = gROOT->GetType( intype.c_str() );
469 if (fundType==0) {
470 if (intype != "long double" && !silent) {
471 Error("TGenCollectionProxy","Unknown fundamental type %s",intype.c_str());
472 }
473 fSize = sizeof(int);
474 fKind = kInt_t;
475 } else {
476 fKind = (EDataType)fundType->GetType();
478 R__ASSERT((fKind>0 && fKind<0x17) || (fKind==-1&&(prop&kIsPointer)) );
479 }
480 }
481 else if ( prop&kIsEnum ) {
482 fSize = sizeof(int);
483 fKind = kInt_t;
484 }
486 if (fType == TString::Class() && (fCase&kIsPointer)) {
488 }
489 }
491 }
492 }
493 if (fType) {
495 if (proxy && (proxy->GetProperties() & kNeedDelete)) {
497 }
498 }
499 }
500 if ( fSize == std::string::npos ) {
501 if ( fType == 0 ) {
502 // The caller should check the validity by calling IsValid()
503 } else {
504 fSize = fType->Size();
505 }
506 }
507}
508
509////////////////////////////////////////////////////////////////////////////////
510/// Return true if the Value has been properly initialized.
511
513{
514
515
516 return fSize != std::string::npos;
517}
518
520{
521 // Delete an item.
522
523 if ( ptr && fCase&kIsPointer ) {
524 if ( fDelete ) {
525 (*fDelete)(ptr);
526 }
527 else if ( fType ) {
528 fType->Destructor(ptr);
529 }
530 else {
531 ::operator delete(ptr);
532 }
533 }
534}
535
536/**
537 \class TGenCollectionProxy TGenCollectionProxy.cxx
538 \ingroup IO
539
540 Proxy around an arbitrary container, which implements basic
541 functionality and iteration.
542
543 The purpose of this implementation
544 is to shield any generated dictionary implementation from the
545 underlying streamer/proxy implementation and only expose
546 the creation functions.
547
548 In particular this is used to implement splitting and abstract
549 element access of any container. Access to compiled code is necessary
550 to implement the abstract iteration sequence and functionality like
551 size(), clear(), resize(). resize() may be a void operation.
552*/
553
554////////////////////////////////////////////////////////////////////////////////
555/// Build a proxy for an emulated container.
556
559 fTypeinfo(copy.fTypeinfo)
560{
561 fEnv = 0;
562 fName = copy.fName;
563 fPointers = copy.fPointers;
564 fSTL_type = copy.fSTL_type;
565 fSize.call = copy.fSize.call;
566 fNext.call = copy.fNext.call;
567 fFirst.call = copy.fFirst.call;
568 fClear.call = copy.fClear.call;
569 fResize = copy.fResize;
570 fDestruct = copy.fDestruct;
571 fConstruct = copy.fConstruct;
572 fFeed = copy.fFeed;
573 fCollect = copy.fCollect;
575 fValOffset = copy.fValOffset;
576 fValDiff = copy.fValDiff;
577 fValue = copy.fValue.load(std::memory_order_relaxed) ? new Value(*copy.fValue) : 0;
578 fVal = copy.fVal ? new Value(*copy.fVal) : 0;
579 fKey = copy.fKey ? new Value(*copy.fKey) : 0;
590}
591
592////////////////////////////////////////////////////////////////////////////////
593/// Build a proxy for a collection whose type is described by 'collectionClass'.
594
597 fTypeinfo(info)
598{
599 fEnv = 0;
600 fSize.call = 0;
601 fFirst.call = 0;
602 fNext.call = 0;
603 fClear.call = 0;
604 fResize = 0;
605 fDestruct = 0;
606 fConstruct = 0;
607 fCollect = 0;
608 fCreateEnv.call = 0;
609 fFeed = 0;
610 fValue = 0;
611 fKey = 0;
612 fVal = 0;
613 fValOffset = 0;
614 fValDiff = 0;
615 fPointers = false;
616 fOnFileClass = 0;
618 Env_t e;
619 if ( iter_size > sizeof(e.fIterator) ) {
620 Fatal("TGenCollectionProxy",
621 "%s %s are too large:%ld bytes. Maximum is:%ld bytes",
622 "Iterators for collection",
623 fClass->GetName(),
624 (Long_t)iter_size,
625 (Long_t)sizeof(e.fIterator));
626 }
635}
636
637////////////////////////////////////////////////////////////////////////////////
638/// Build a proxy for a collection whose type is described by 'collectionClass'.
639
642 fTypeinfo(info.fInfo), fOnFileClass(0)
643{
644 fEnv = 0;
645 fValDiff = info.fValueDiff;
647 fSize.call = info.fSizeFunc;
648 fResize = info.fResizeFunc;
649 fNext.call = info.fNextFunc;
650 fFirst.call = info.fFirstFunc;
651 fClear.call = info.fClearFunc;
654 fFeed = info.fFeedFunc;
655 fCollect = info.fCollectFunc;
657
658 if (cl) {
659 fName = cl->GetName();
660 }
662
663 fValue = 0;
664 fKey = 0;
665 fVal = 0;
666 fPointers = false;
668
669 Env_t e;
670 if ( info.fIterSize > sizeof(e.fIterator) ) {
671 Fatal("TGenCollectionProxy",
672 "%s %s are too large:%ld bytes. Maximum is:%ld bytes",
673 "Iterators for collection",
674 fClass->GetName(),
675 (Long_t)info.fIterSize,
676 (Long_t)sizeof(e.fIterator));
677 }
686}
687
688namespace {
689 template <class vec>
690 void clearVector(vec& v)
691 {
692 // Clear out the proxies.
693
694 for(typename vec::iterator i=v.begin(); i != v.end(); ++i) {
695 typename vec::value_type e = *i;
696 if ( e ) {
697 delete e;
698 }
699 }
700 v.clear();
701 }
702}
703////////////////////////////////////////////////////////////////////////////////
704/// Standard destructor
705
707{
708 clearVector(fProxyList);
709 clearVector(fProxyKept);
710 clearVector(fStaged);
711
712 if ( fValue.load() ) delete fValue.load();
713 if ( fVal ) delete fVal;
714 if ( fKey ) delete fKey;
715
716 delete fReadMemberWise;
718 std::map<std::string, TObjArray*>::iterator it;
719 std::map<std::string, TObjArray*>::iterator end = fConversionReadMemberWise->end();
720 for( it = fConversionReadMemberWise->begin(); it != end; ++it ) {
721 delete it->second;
722 }
725 }
726 delete fWriteMemberWise;
727}
728
729////////////////////////////////////////////////////////////////////////////////
730/// Virtual copy constructor
731
733{
734 if ( !fValue.load(std::memory_order_relaxed) ) Initialize(kFALSE);
735
736 if( fPointers )
737 return new TGenCollectionProxy(*this);
738
739 switch(fSTL_type) {
740 case ROOT::kSTLbitset: {
741 return new TGenBitsetProxy(*this);
742 }
743 case ROOT::kSTLvector: {
744 if ((*fValue).fKind == kBool_t) {
745 return new TGenVectorBoolProxy(*this);
746 } else {
747 return new TGenVectorProxy(*this);
748 }
749 }
750 case ROOT::kSTLlist:
752 return new TGenListProxy(*this);
753 case ROOT::kSTLmap:
757 return new TGenMapProxy(*this);
758 case ROOT::kSTLset:
762 return new TGenSetProxy(*this);
763 default:
764 return new TGenCollectionProxy(*this);
765 }
766}
767
768////////////////////////////////////////////////////////////////////////////////
769/// Proxy initializer
770
772{
773 TGenCollectionProxy* p = const_cast<TGenCollectionProxy*>(this);
774 if ( fValue.load() ) return p;
775 return p->InitializeEx(silent);
776}
777
778////////////////////////////////////////////////////////////////////////////////
779/// Reset the info gathered from StreamerInfos and value's TClass.
781{
782 if (fReadMemberWise)
784 delete fWriteMemberWise;
785 fWriteMemberWise = nullptr;
788 return kTRUE;
789}
790
791////////////////////////////////////////////////////////////////////////////////
792/// Check existence of function pointers
793
795{
796 if ( 0 == fSize.call ) {
797 Fatal("TGenCollectionProxy","No 'size' function pointer for class %s present.",fName.c_str());
798 }
799 if ( 0 == fResize ) {
800 Fatal("TGenCollectionProxy","No 'resize' function for class %s present.",fName.c_str());
801 }
802 if ( 0 == fNext.call ) {
803 Fatal("TGenCollectionProxy","No 'next' function for class %s present.",fName.c_str());
804 }
805 if ( 0 == fFirst.call ) {
806 Fatal("TGenCollectionProxy","No 'begin' function for class %s present.",fName.c_str());
807 }
808 if ( 0 == fClear.call ) {
809 Fatal("TGenCollectionProxy","No 'clear' function for class %s present.",fName.c_str());
810 }
811 if ( 0 == fConstruct ) {
812 Fatal("TGenCollectionProxy","No 'block constructor' function for class %s present.",fName.c_str());
813 }
814 if ( 0 == fDestruct ) {
815 Fatal("TGenCollectionProxy","No 'block destructor' function for class %s present.",fName.c_str());
816 }
817 if ( 0 == fFeed ) {
818 Fatal("TGenCollectionProxy","No 'data feed' function for class %s present.",fName.c_str());
819 }
820 if ( 0 == fCollect ) {
821 Fatal("TGenCollectionProxy","No 'data collect' function for class %s present.",fName.c_str());
822 }
823 if (0 == fCreateEnv.call ) {
824 Fatal("TGenCollectionProxy","No 'environment creation' function for class %s present.",fName.c_str());
825 }
826}
827
828////////////////////////////////////////////////////////////////////////////////
829/// Utility routine to issue a Fatal error is the Value object is not valid
830
831static TGenCollectionProxy::Value *R__CreateValue(const std::string &name, Bool_t silent,
832 size_t hint_pair_offset = 0, size_t hint_pair_size = 0)
833{
834 TGenCollectionProxy::Value *val = new TGenCollectionProxy::Value( name, silent, hint_pair_offset, hint_pair_size );
835 if ( !val->IsValid() ) {
836 Fatal("TGenCollectionProxy","Could not find %s!",name.c_str());
837 }
838 return val;
839}
840
841////////////////////////////////////////////////////////////////////////////////
842/// Proxy initializer
843
845{
847 if (fValue.load()) return this;
848
850 if ( cl ) {
851 fEnv = 0;
852 fName = cl->GetName();
853 fPointers = false;
854 int nested = 0;
855 std::vector<std::string> inside;
856 int num = TClassEdit::GetSplit(cl->GetName(),inside,nested);
857 if ( num > 1 ) {
858 std::string nam;
859 Value* newfValue = nullptr;
860 if ( inside[0].find("stdext::hash_") != std::string::npos )
861 inside[0].replace(3,10,"::");
862 if ( inside[0].find("__gnu_cxx::hash_") != std::string::npos )
863 inside[0].replace(0,16,"std::");
864 fSTL_type = TClassEdit::STLKind(inside[0]);
865 switch ( fSTL_type ) {
866 case ROOT::kSTLmap:
870 case ROOT::kSTLset:
874 case ROOT::kSTLbitset: // not really an associate container but it has no real iterator.
876 if (num > 3 && !inside[3].empty()) {
877 if (! TClassEdit::IsDefAlloc(inside[3].c_str(),inside[0].c_str())) {
879 }
880 }
881 break;
882 };
883
884 int slong = sizeof(void*);
885 switch ( fSTL_type ) {
886 case ROOT::kSTLmap:
890 nam = "pair<"+inside[1]+","+inside[2];
891 nam += (nam[nam.length()-1]=='>') ? " >" : ">";
892
893 fVal = R__CreateValue(inside[2], silent);
894 fKey = R__CreateValue(inside[1], silent);
895
896 {
898 TClass *paircl = TClass::GetClass(nam.c_str(), true, false, fValOffset, fValDiff);
899 if (paircl == nullptr) {
900 // We need to emulate the pair
901 auto info = TVirtualStreamerInfo::Factory()->GenerateInfoForPair(inside[1], inside[2], silent, fValOffset, fValDiff);
902 if (!info) {
903 Fatal("InitializeEx",
904 "Could not load nor generate the dictionary for \"%s\", some element might be missing their dictionary (eg. enums)",
905 nam.c_str());
906 }
907 } else {
908 if ((!paircl->IsSyntheticPair() && paircl->GetState() < TClass::kInterpreted) || paircl->GetClassSize() != fValDiff) {
909 if (paircl->GetState() >= TClass::kInterpreted)
910 Fatal("InitializeEx",
911 "The %s for %s reports a class size that is inconsistent with the one registered "
912 "through the CollectionProxy for %s: %d vs %d\n",
913 paircl->IsLoaded() ? "dictionary" : "interpreter information for", nam.c_str(),
914 cl->GetName(), (int)paircl->GetClassSize(), (int)fValDiff);
915 else {
916 gROOT->GetListOfClasses()->Remove(paircl);
917 TClass *newpaircl = TClass::GetClass(nam.c_str(), true, false, fValOffset, fValDiff);
918 if (!newpaircl || newpaircl == paircl || newpaircl->GetClassSize() != fValDiff)
919 Fatal("InitializeEx",
920 "The TClass creation for %s did not get the right size: %d instead of%d\n",
921 nam.c_str(), (int)paircl->GetClassSize(), (int)fValDiff);
922 newpaircl->ForceReload(paircl);
923 }
924 }
925 }
926 }
927 newfValue = R__CreateValue(nam, silent, fValOffset, fValDiff);
928
929 fPointers = (0 != (fKey->fCase&kIsPointer));
930 if (fPointers || (0 != (fKey->fProperties&kNeedDelete))) {
932 }
933 if ( 0 == fValDiff ) {
935 fValDiff += (slong - fKey->fSize%slong)%slong;
936 fValDiff += (slong - fValDiff%slong)%slong;
937 }
938 if ( 0 == fValOffset ) {
940 fValOffset += (slong - fKey->fSize%slong)%slong;
941 }
942 break;
943 case ROOT::kSTLbitset:
944 inside[1] = "bool";
945 // Intentional fall through
946 default:
947 newfValue = R__CreateValue(inside[1], silent);
948
949 fVal = new Value(*newfValue);
950 if ( 0 == fValDiff ) {
952 fValDiff += (slong - fValDiff%slong)%slong;
953 }
954 if (num > 2 && !inside[2].empty()) {
955 if (! TClassEdit::IsDefAlloc(inside[2].c_str(),inside[0].c_str())) {
957 }
958 }
959 break;
960 }
961 if (!(fProperties & kIsEmulated) && newfValue->fType && !newfValue->fType->IsSyntheticPair()) {
962 if (!newfValue->fType->IsLoaded() && !newfValue->fType->HasInterpreterInfo())
963 Error("TGenCollectionProxy::InitializeEx",
964 "The TClass for %s used as the value type of the compiled collection proxy %s is not loaded.",
965 newfValue->fType->GetName(), cl->GetName());
966 }
967
968 fPointers = fPointers || (0 != (fVal->fCase&kIsPointer));
969 if (fPointers || (0 != (fVal->fProperties&kNeedDelete))) {
971 }
972 fClass = cl;
973 //fValue must be set last since we use it to indicate that we are initialized
974 fValue = newfValue;
975 return this;
976 }
977 Fatal("TGenCollectionProxy","Components of %s not analysed!",cl->GetName());
978 }
979 Fatal("TGenCollectionProxy","Collection class %s not found!",fTypeinfo.name());
980 return 0;
981}
982
983////////////////////////////////////////////////////////////////////////////////
984/// Return a pointer to the TClass representing the container
985
987{
988 return fClass ? fClass : Initialize(kFALSE)->fClass;
989}
990
991////////////////////////////////////////////////////////////////////////////////
992/// Return the type of collection see TClassEdit::ESTLType
993
995{
996 if (!fValue.load(std::memory_order_relaxed)) {
998 }
999 return fSTL_type;
1000}
1001
1002////////////////////////////////////////////////////////////////////////////////
1003/// Return the offset between two consecutive value_types (memory layout).
1004
1006 if (!fValue.load(std::memory_order_relaxed)) {
1008 }
1009 return fValDiff;
1010}
1011
1012////////////////////////////////////////////////////////////////////////////////
1013/// Return the sizeof the collection object.
1014
1016{
1017 return fClass->Size();
1018}
1019
1020////////////////////////////////////////////////////////////////////////////////
1021/// Return true if the content is of type 'pointer to'
1022
1024{
1025 // Initialize proxy in case it hasn't been initialized yet
1026 if( !fValue.load(std::memory_order_relaxed) )
1028
1029 // The content of a map and multimap is always a 'pair' and hence
1030 // fPointers means "Flag to indicate if containee has pointers (key or value)"
1031 // so we need to ignore its value for map and multimap;
1034}
1035
1036////////////////////////////////////////////////////////////////////////////////
1037/// Return a pointer to the TClass representing the content.
1038
1040{
1041 auto value = fValue.load(std::memory_order_relaxed);
1042 if (!value) {
1044 value = fValue.load(std::memory_order_relaxed);
1045 }
1046 return value ? (*value).fType.GetClass() : 0;
1047}
1048
1049////////////////////////////////////////////////////////////////////////////////
1050/// If the content is a simple numerical value, return its type (see TDataType)
1051
1053{
1054 auto value = fValue.load(std::memory_order_relaxed);
1055 if (!value) {
1057 value = fValue.load(std::memory_order_relaxed);
1058 }
1059 return value ? (*value).fKind : kNoType_t;
1060}
1061
1062////////////////////////////////////////////////////////////////////////////////
1063/// Return the address of the value at index 'idx'
1064
1066{
1067 if ( fEnv && fEnv->fObject ) {
1068 switch (fSTL_type) {
1069 case ROOT::kSTLvector:
1070 if ((*fValue).fKind == kBool_t) {
1071 auto vec = (std::vector<bool> *)(fEnv->fObject);
1072 fEnv->fLastValueVecBool = (*vec)[idx];
1073 fEnv->fIdx = idx;
1074 return &(fEnv->fLastValueVecBool);
1075 }
1076 // intentional fall through
1077 case ROOT::kROOTRVec:
1078 fEnv->fIdx = idx;
1079 switch( idx ) {
1080 case 0:
1081 return fEnv->fStart = fFirst.invoke(fEnv);
1082 default:
1083 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
1084 return ((char*)fEnv->fStart) + fValDiff*idx;
1085 }
1086 case ROOT::kSTLbitset: {
1087 switch (idx) {
1088 case 0:
1090 fEnv->fIdx = idx;
1091 break;
1092 default:
1093 fEnv->fIdx = idx - fEnv->fIdx;
1094 if (!fEnv->fStart) fEnv->fStart = fFirst.invoke(fEnv);
1095 fNext.invoke(fEnv);
1096 fEnv->fIdx = idx;
1097 break;
1098 }
1099 typedef ROOT::TCollectionProxyInfo::Environ <std::pair<size_t, Bool_t>> EnvType_t;
1100 EnvType_t *e = (EnvType_t *) fEnv;
1101 return &(e->fIterator.second);
1102 }
1103 case ROOT::kSTLset:
1105 case ROOT::kSTLmultiset:
1107 case ROOT::kSTLmap:
1109 case ROOT::kSTLmultimap:
1111 if ( fEnv->fUseTemp ) {
1112 return (((char*)fEnv->fTemp)+idx*fValDiff);
1113 }
1114 // Intentional fall through.
1115 default:
1116 switch( idx ) {
1117 case 0:
1118 fEnv->fIdx = idx;
1119 return fEnv->fStart = fFirst.invoke(fEnv);
1120 default: {
1121 fEnv->fIdx = idx - fEnv->fIdx;
1122 if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
1123 void* result = fNext.invoke(fEnv);
1124 fEnv->fIdx = idx;
1125 return result;
1126 }
1127 }
1128 }
1129 }
1130 Fatal("TGenCollectionProxy","At> Logic error - no proxy object set.");
1131 return 0;
1132}
1133
1134////////////////////////////////////////////////////////////////////////////////
1135/// Clear the emulated collection.
1136
1137void TGenCollectionProxy::Clear(const char* opt)
1138{
1139 if ( fEnv && fEnv->fObject ) {
1140 if ( (fProperties & kNeedDelete) && opt && *opt=='f' ) {
1141 size_t i, n = *(size_t*)fSize.invoke(fEnv);
1142 if ( n > 0 ) {
1143 for (i=0; i<n; ++i)
1145 }
1146 }
1148 }
1149}
1150
1151////////////////////////////////////////////////////////////////////////////////
1152/// Return the current size of the container
1153
1155{
1156 if ( fEnv && fEnv->fObject ) {
1157 if (fEnv->fUseTemp) {
1158 return fEnv->fSize;
1159 } else {
1160 return *(size_t*)fSize.invoke(fEnv);
1161 }
1162 }
1163 Fatal("TGenCollectionProxy","Size> Logic error - no proxy object set.");
1164 return 0;
1165}
1166
1167////////////////////////////////////////////////////////////////////////////////
1168/// Resize the container
1169
1171{
1172 if ( fEnv && fEnv->fObject ) {
1173 if ( force && fPointers ) {
1174 size_t i, nold = *(size_t*)fSize.invoke(fEnv);
1175 if ( n != nold ) {
1176 for (i=n; i<nold; ++i)
1177 DeleteItem(true, *(void**)TGenCollectionProxy::At(i));
1178 }
1179 }
1180 MESSAGE(3, "Resize(n)" );
1181 fEnv->fSize = n;
1183 return;
1184 }
1185 Fatal("TGenCollectionProxy","Resize> Logic error - no proxy object set.");
1186}
1187
1188////////////////////////////////////////////////////////////////////////////////
1189/// Allocate the needed space.
1190/// For associative collection, this returns a TStaging object that
1191/// need to be deleted manually __or__ returned by calling Commit(TStaging*)
1192
1194{
1195 if ( fEnv && fEnv->fObject ) {
1196 switch ( fSTL_type ) {
1197 case ROOT::kSTLset:
1199 case ROOT::kSTLmultiset:
1201 case ROOT::kSTLmap:
1203 case ROOT::kSTLmultimap:
1205 if ( (fProperties & kNeedDelete) )
1206 Clear("force");
1207 else
1209 // Commit no longer use the environment and thus no longer decrease
1210 // the count. Consequently we no longer should increase it here.
1211 // ++fEnv->fRefCount;
1212 fEnv->fSize = n;
1213
1214 TStaging *s;
1215 if (fStaged.empty()) {
1216 s = new TStaging(n,fValDiff);
1217 } else {
1218 s = fStaged.back();
1219 fStaged.pop_back();
1220 s->Resize(n);
1221 }
1222 fConstruct(s->GetContent(),s->GetSize());
1223
1224 s->SetTarget(fEnv->fObject);
1225
1226 fEnv->fTemp = s->GetContent();
1227 fEnv->fUseTemp = kTRUE;
1228 fEnv->fStart = fEnv->fTemp;
1229
1230 return s;
1231 }
1232 case ROOT::kSTLvector:
1233 case ROOT::kSTLlist:
1235 case ROOT::kSTLdeque:
1236 case ROOT::kROOTRVec:
1237 if( (fProperties & kNeedDelete) ) {
1238 Clear("force");
1239 }
1240 fEnv->fSize = n;
1242 return fEnv->fObject;
1243
1244 case ROOT::kSTLbitset: {
1245 TStaging *s;
1246 if (fStaged.empty()) {
1247 s = new TStaging(n,fValDiff);
1248 } else {
1249 s = fStaged.back();
1250 fStaged.pop_back();
1251 s->Resize(n);
1252 }
1253 s->SetTarget(fEnv->fObject);
1254
1255 fEnv->fTemp = s->GetContent();
1256 fEnv->fUseTemp = kTRUE;
1257 fEnv->fStart = fEnv->fTemp;
1258
1259 return s;
1260 }
1261 }
1262 }
1263 return 0;
1264}
1265
1266////////////////////////////////////////////////////////////////////////////////
1267/// Insert data into the container where data is a C-style array of the actual type contained in the collection
1268/// of the given size. For associative container (map, etc.), the data type is the pair<key,value>.
1269
1270void TGenCollectionProxy::Insert(const void *data, void *container, size_t size)
1271{
1272 fFeed((void*)data,container,size);
1273}
1274
1275////////////////////////////////////////////////////////////////////////////////
1276/// Commit the change.
1277
1279{
1281// case ROOT::kSTLmap:
1282// case ROOT::kSTLmultimap:
1283// case ROOT::kSTLset:
1284// case ROOT::kSTLmultiset:
1285 if ( from ) {
1286 TStaging *s = (TStaging*) from;
1287 if ( s->GetTarget() ) {
1288 fFeed(s->GetContent(),s->GetTarget(),s->GetSize());
1289 }
1290 fDestruct(s->GetContent(),s->GetSize());
1291 s->SetTarget(0);
1292 fStaged.push_back(s);
1293 }
1294 }
1295}
1296
1297////////////////////////////////////////////////////////////////////////////////
1298/// Add an object.
1299
1301{
1302 if ( !fValue.load(std::memory_order_relaxed) ) Initialize(kFALSE);
1303 if ( !fProxyList.empty() ) {
1304 EnvironBase_t* back = fProxyList.back();
1305 if ( back->fObject == objstart ) {
1306 ++back->fRefCount;
1307 fProxyList.push_back(back);
1308 fEnv = back;
1309 return;
1310 }
1311 }
1312 EnvironBase_t* e = 0;
1313 if ( fProxyKept.empty() ) {
1315 e->fTemp = 0;
1316 e->fUseTemp = kFALSE;
1317 }
1318 else {
1319 e = fProxyKept.back();
1320 fProxyKept.pop_back();
1321 }
1322 e->fSize = 0;
1323 e->fRefCount = 1;
1324 e->fObject = objstart;
1325 e->fStart = 0;
1326 e->fIdx = 0;
1327 // ::memset(e->buff,0,sizeof(e->buff));
1328 fProxyList.push_back(e);
1329 fEnv = e;
1330}
1331
1332////////////////////////////////////////////////////////////////////////////////
1333/// Remove the last object.
1334
1336{
1337 if ( !fProxyList.empty() ) {
1338 EnvironBase_t* e = fProxyList.back();
1339 if ( --e->fRefCount <= 0 ) {
1340 fProxyKept.push_back(e);
1341 e->fUseTemp = kFALSE;
1342 }
1343 fProxyList.pop_back();
1344 }
1345 fEnv = fProxyList.empty() ? 0 : fProxyList.back();
1346}
1347
1348////////////////////////////////////////////////////////////////////////////////
1349/// Call to delete/destruct individual item.
1350
1351void TGenCollectionProxy::DeleteItem(Bool_t force, void* ptr) const
1352{
1353 if ( force && ptr ) {
1354 switch (fSTL_type) {
1355 case ROOT::kSTLmap:
1357 case ROOT::kSTLmultimap:
1359 if ( fKey->fCase&kIsPointer ) {
1362 TPushPop helper(proxy,*(void**)ptr);
1363 proxy->Clear("force");
1364 }
1365 fKey->DeleteItem(*(void**)ptr);
1366 } else {
1369 TPushPop helper(proxy,ptr);
1370 proxy->Clear("force");
1371 }
1372 }
1373 char *addr = ((char*)ptr)+fValOffset;
1374 if ( fVal->fCase&kIsPointer ) {
1377 TPushPop helper(proxy,*(void**)addr);
1378 proxy->Clear("force");
1379 }
1380 fVal->DeleteItem(*(void**)addr);
1381 } else {
1384 TPushPop helper(proxy,addr);
1385 proxy->Clear("force");
1386 }
1387 }
1388 break;
1389 }
1390 default: {
1391 if ( fVal->fCase&kIsPointer ) {
1394 TPushPop helper(proxy,*(void**)ptr);
1395 proxy->Clear("force");
1396 }
1397 fVal->DeleteItem(*(void**)ptr);
1398 } else {
1401 TPushPop helper(proxy,ptr);
1402 proxy->Clear("force");
1403 }
1404 }
1405 break;
1406 }
1407 }
1408 }
1409}
1410
1411////////////////////////////////////////////////////////////////////////////////
1412
1413void TGenCollectionProxy::ReadBuffer(TBuffer & /* b */, void * /* obj */, const TClass * /* onfileClass */)
1414{
1415 MayNotUse("TGenCollectionProxy::ReadBuffer(TBuffer &, void *, const TClass *)");
1416}
1417
1418////////////////////////////////////////////////////////////////////////////////
1419
1420void TGenCollectionProxy::ReadBuffer(TBuffer & /* b */, void * /* obj */)
1421{
1422 MayNotUse("TGenCollectionProxy::ReadBuffer(TBuffer &, void *)");
1423}
1424
1425////////////////////////////////////////////////////////////////////////////////
1426/// Streamer Function.
1427
1429{
1430 if ( fEnv ) {
1432 return;
1433 }
1434 Fatal("TGenCollectionProxy","Streamer> Logic error - no proxy object set.");
1435}
1436
1437////////////////////////////////////////////////////////////////////////////////
1438/// Streamer I/O overload
1439
1440void TGenCollectionProxy::Streamer(TBuffer &buff, void *objp, int /* siz */ )
1441{
1442 TPushPop env(this, objp);
1443 Streamer(buff);
1444}
1445
1446////////////////////////////////////////////////////////////////////////////////
1447/// TClassStreamer IO overload
1448
1450{
1451 Streamer(b, objp, 0);
1452}
1453
1454
1459};
1460
1461////////////////////////////////////////////////////////////////////////////////
1462
1463void TGenCollectionProxy__SlowCreateIterators(void * /* collection */, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
1464{
1465 new (*begin_arena) TGenCollectionProxy__SlowIterator(proxy);
1466 *(UInt_t*)*end_arena = proxy->Size();
1467}
1468
1469////////////////////////////////////////////////////////////////////////////////
1470
1471void *TGenCollectionProxy__SlowNext(void *iter, const void *end)
1472{
1474 if (iterator->fIndex != *(UInt_t*)end) {
1475 void *result = iterator->fProxy->At(iterator->fIndex);
1476 ++(iterator->fIndex);
1477 return result;
1478 } else {
1479 return 0;
1480 }
1481}
1482
1483////////////////////////////////////////////////////////////////////////////////
1484
1485void * TGenCollectionProxy__SlowCopyIterator(void *dest, const void *source)
1486{
1488 return dest;
1489}
1490
1491////////////////////////////////////////////////////////////////////////////////
1492/// Nothing to do
1493
1495{
1496}
1497
1498////////////////////////////////////////////////////////////////////////////////
1499/// Nothing to do
1500
1502{
1503}
1504
1505
1506////////////////////////////////////////////////////////////////////////////////
1507/// We can safely assume that the std::vector layout does not really depend on
1508/// the content!
1509
1510void TGenCollectionProxy__VectorCreateIterators(void *obj, void **begin_arena, void **end_arena, TVirtualCollectionProxy*)
1511{
1512 std::vector<char> *vec = (std::vector<char>*)obj;
1513 if (vec->empty()) {
1514 *begin_arena = 0;
1515 *end_arena = 0;
1516 return;
1517 }
1518 *begin_arena = &(*vec->begin());
1519#ifdef R__VISUAL_CPLUSPLUS
1520 *end_arena = &(*(vec->end()-1)) + 1; // On windows we can not dererence the end iterator at all.
1521#else
1522 // coverity[past_the_end] Safe on other platforms
1523 *end_arena = &(*vec->end());
1524#endif
1525
1526}
1527
1528////////////////////////////////////////////////////////////////////////////////
1529/// Should not be used.
1530
1531void *TGenCollectionProxy__VectorNext(void *, const void *)
1532{
1533 R__ASSERT(0);
1534 return 0;
1535}
1536
1537////////////////////////////////////////////////////////////////////////////////
1538
1539void *TGenCollectionProxy__VectorCopyIterator(void *dest, const void *source)
1540{
1541 *(void**)dest = *(void**)source;
1542 return dest;
1543}
1544
1545////////////////////////////////////////////////////////////////////////////////
1546/// Nothing to do
1547
1549{
1550}
1551
1552////////////////////////////////////////////////////////////////////////////////
1553/// Nothing to do
1554
1556{
1557}
1558
1559
1560
1561////////////////////////////////////////////////////////////////////////////////
1562
1563void TGenCollectionProxy__StagingCreateIterators(void *obj, void **begin_arena, void **end_arena, TVirtualCollectionProxy *)
1564{
1566 *begin_arena = s->GetContent();
1567 *end_arena = s->GetEnd();
1568}
1569
1570////////////////////////////////////////////////////////////////////////////////
1571/// Should not be used.
1572
1573void *TGenCollectionProxy__StagingNext(void *, const void *)
1574{
1575 R__ASSERT(0);
1576 return 0;
1577}
1578
1579////////////////////////////////////////////////////////////////////////////////
1580
1581void *TGenCollectionProxy__StagingCopyIterator(void *dest, const void *source)
1582{
1583 *(void**)dest = *(void**)source;
1584 return dest;
1585}
1586
1587////////////////////////////////////////////////////////////////////////////////
1588/// Nothing to do
1589
1591{
1592}
1593
1594////////////////////////////////////////////////////////////////////////////////
1595/// Nothing to do
1596
1598{
1599}
1600
1601
1602////////////////////////////////////////////////////////////////////////////////
1603/// See typedef void (*CreateIterators_t)(void *collection, void *&begin_arena, void *&end_arena);
1604/// begin_arena and end_arena should contain the location of memory arena of size fgIteratorSize.
1605/// If the collection iterator are of that size or less, the iterators will be constructed in place in those location (new with placement)
1606/// Otherwise the iterators will be allocated via a regular new and their address returned by modifying the value of begin_arena and end_arena.
1607
1609{
1610 if (read) {
1611 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1612 if ( (fProperties & kIsAssociative) && read)
1614 }
1615
1617
1618 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1619
1620// fprintf(stderr,"GetFunctinCreateIterator for %s will give: ",fClass.GetClassName());
1621// if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
1622// fprintf(stderr,"vector/emulated iterator\n");
1623// else if ( (fProperties & kIsAssociative) && read)
1624// fprintf(stderr,"an associative read iterator\n");
1625// else
1626// fprintf(stderr,"a generic iterator\n");
1627
1628 // TODO could we do better than SlowCreateIterators for RVec?
1631 else if ( (fProperties & kIsAssociative) && read)
1633 else
1635}
1636
1637////////////////////////////////////////////////////////////////////////////////
1638/// See typedef void (*CopyIterator_t)(void *&dest, const void *source);
1639/// Copy the iterator source, into dest. dest should contain should contain the location of memory arena of size fgIteratorSize.
1640/// If the collection iterator are of that size or less, the iterator will be constructed in place in this location (new with placement)
1641/// Otherwise the iterator will be allocated via a regular new and its address returned by modifying the value of dest.
1642
1644{
1645 if (read) {
1646 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1647 if ( (fProperties & kIsAssociative) && read)
1649 }
1650
1652
1653 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1654
1655 // TODO can we do better than the default for RVec?
1658 else if ( (fProperties & kIsAssociative) && read)
1660 else
1662}
1663
1664////////////////////////////////////////////////////////////////////////////////
1665/// See typedef void* (*Next_t)(void *iter, void *end);
1666/// iter and end should be pointer to respectively an iterator to be incremented and the result of colleciton.end()
1667/// 'Next' will increment the iterator 'iter' and return 0 if the iterator reached the end.
1668/// If the end is not reached, 'Next' will return the address of the content unless the collection contains pointers in
1669/// which case 'Next' will return the value of the pointer.
1670
1672{
1673 if (read) {
1674 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1675 if ( (fProperties & kIsAssociative) && read)
1677 }
1678
1680
1681 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1682
1683 // TODO can we do better than the default for RVec?
1686 else if ( (fProperties & kIsAssociative) && read)
1688 else
1690}
1691
1692////////////////////////////////////////////////////////////////////////////////
1693/// See typedef void (*DeleteIterator_t)(void *iter);
1694/// If the sizeof iterator is greater than fgIteratorArenaSize, call delete on the addresses,
1695/// Otherwise just call the iterator's destructor.
1696
1698{
1699 if (read) {
1700 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1701 if ( (fProperties & kIsAssociative) && read)
1703 }
1704
1706
1707 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1708
1709 // TODO can we do better than the default for RVec?
1712 else if ( (fProperties & kIsAssociative) && read)
1714 else
1716}
1717
1718////////////////////////////////////////////////////////////////////////////////
1719/// See typedef void (*DeleteTwoIterators_t)(void *begin, void *end);
1720/// If the sizeof iterator is greater than fgIteratorArenaSize, call delete on the addresses,
1721/// Otherwise just call the iterator's destructor.
1722
1724{
1725 if (read) {
1726 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1727 if ( (fProperties & kIsAssociative) && read)
1729 }
1730
1732
1733 if ( !fValue.load(std::memory_order_relaxed) ) InitializeEx(kFALSE);
1734
1735 // TODO could RVec use something faster than SlowCopyIterator?
1738 else if ( (fProperties & kIsAssociative) && read)
1740 else
1742}
1743
1744////////////////////////////////////////////////////////////////////////////////
1745/// Return the set of action necessary to stream in this collection member-wise coming from
1746/// the old value class layout refered to by 'version'.
1747
1749{
1750 if (oldClass == 0) {
1751 return 0;
1752 }
1753 TObjArray* arr = 0;
1756 std::map<std::string, TObjArray*>::iterator it;
1757
1758 it = fConversionReadMemberWise->find( oldClass->GetName() );
1759
1760 if( it != fConversionReadMemberWise->end() ) {
1761 arr = it->second;
1762 }
1763
1764 if (arr) {
1766 if (result) {
1767 return result;
1768 }
1769 }
1770 }
1771
1772 // Need to create it.
1773 TClass *valueClass = GetValueClass();
1774 if (valueClass == 0) {
1775 return 0;
1776 }
1777 TVirtualStreamerInfo *info = valueClass->GetConversionStreamerInfo(oldClass,version);
1778 if (info == 0) {
1779 return 0;
1780 }
1782
1783 if (!arr) {
1784 arr = new TObjArray(version+10, -1);
1786 fConversionReadMemberWise = new std::map<std::string, TObjArray*>();
1787 }
1788 (*fConversionReadMemberWise)[oldClass->GetName()] = arr;
1789 }
1790 arr->AddAtAndExpand( result, version );
1791
1792 return result;
1793}
1794
1795////////////////////////////////////////////////////////////////////////////////
1796/// Return the set of action necessary to stream in this collection member-wise coming from
1797/// the old value class layout refered to by 'version'.
1798
1800{
1802 if (version < (fReadMemberWise->GetSize()-1)) { // -1 because the 'index' starts at -1
1804 }
1805 if (result == 0) {
1806 // Need to create it.
1807 TClass *valueClass = GetValueClass();
1808 TVirtualStreamerInfo *info = 0;
1809 if (valueClass) {
1810 info = valueClass->GetStreamerInfo(version);
1811 }
1814 }
1815 return result;
1816}
1817
1818////////////////////////////////////////////////////////////////////////////////
1819/// Return the set of action necessary to stream out this collection member-wise.
1820
1822{
1824 if (result == 0) {
1825 // Need to create it.
1826 TClass *valueClass = GetValueClass();
1827 TVirtualStreamerInfo *info = 0;
1828 if (valueClass) {
1829 info = valueClass->GetStreamerInfo();
1830 }
1833 }
1834 return result;
1835}
#define b(i)
Definition RSha256.hxx:100
#define c(i)
Definition RSha256.hxx:101
#define e(i)
Definition RSha256.hxx:103
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
unsigned long ULong_t
Definition RtypesCore.h:55
long Long_t
Definition RtypesCore.h:54
unsigned int UInt_t
Definition RtypesCore.h:46
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
EDataType
Definition TDataType.h:28
@ kNoType_t
Definition TDataType.h:33
@ kInt_t
Definition TDataType.h:30
@ kBool_t
Definition TDataType.h:32
@ kVoid_t
Definition TDataType.h:35
@ kIsPointer
Definition TDictionary.h:78
@ kIsClass
Definition TDictionary.h:65
@ kIsEnum
Definition TDictionary.h:68
@ kIsFundamental
Definition TDictionary.h:70
@ kIsStruct
Definition TDictionary.h:66
#define R__ASSERT(e)
Definition TError.h:118
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:185
void MayNotUse(const char *method)
This function can be used in classes that should override a certain function, but in the inherited cl...
Definition TError.cxx:168
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
Definition TError.cxx:244
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t dest
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
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 prop
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 result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition TGX11.cxx:110
#define MESSAGE(which, text)
void * TGenCollectionProxy__VectorCopyIterator(void *dest, const void *source)
void TGenCollectionProxy__StagingDeleteTwoIterators(void *, void *)
Nothing to do.
void * TGenCollectionProxy__VectorNext(void *, const void *)
Should not be used.
static TGenCollectionProxy::Value * R__CreateValue(const std::string &name, Bool_t silent, size_t hint_pair_offset=0, size_t hint_pair_size=0)
Utility routine to issue a Fatal error is the Value object is not valid.
void TGenCollectionProxy__StagingDeleteSingleIterators(void *)
Nothing to do.
void TGenCollectionProxy__SlowCreateIterators(void *, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
void * TGenCollectionProxy__SlowNext(void *iter, const void *end)
void TGenCollectionProxy__VectorCreateIterators(void *obj, void **begin_arena, void **end_arena, TVirtualCollectionProxy *)
We can safely assume that the std::vector layout does not really depend on the content!
void * TGenCollectionProxy__StagingCopyIterator(void *dest, const void *source)
void * TGenCollectionProxy__StagingNext(void *, const void *)
Should not be used.
void TGenCollectionProxy__VectorDeleteSingleIterators(void *)
Nothing to do.
void * TGenCollectionProxy__SlowCopyIterator(void *dest, const void *source)
void TGenCollectionProxy__StagingCreateIterators(void *obj, void **begin_arena, void **end_arena, TVirtualCollectionProxy *)
void TGenCollectionProxy__SlowDeleteTwoIterators(void *, void *)
Nothing to do.
void TGenCollectionProxy__VectorDeleteTwoIterators(void *, void *)
Nothing to do.
void TGenCollectionProxy__SlowDeleteSingleIterators(void *)
Nothing to do.
R__EXTERN TVirtualMutex * gInterpreterMutex
R__EXTERN TInterpreter * gCling
#define gROOT
Definition TROOT.h:407
#define R__LOCKGUARD(mutex)
void *(* fCopyIterator)(void *dest, const void *source)
void *(* fConstructFunc)(void *, size_t)
void(* fDeleteTwoIterators)(void *begin, void *end)
void *(* fFeedFunc)(void *, void *, size_t)
void(* fCreateIterators)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
void *(* fNext)(void *iter, const void *end)
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TClass * GetClass() const
Definition TClassRef.h:66
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
Bool_t IsSyntheticPair() const
Definition TClass.h:521
void Streamer(void *obj, TBuffer &b, const TClass *onfile_class=nullptr) const
Definition TClass.h:607
void ForceReload(TClass *oldcl)
we found at least one equivalent.
Definition TClass.cxx:1336
EState GetState() const
Definition TClass.h:488
ROOT::DesFunc_t GetDestructor() const
Return the wrapper around the destructor.
Definition TClass.cxx:7479
ROOT::NewFunc_t GetNew() const
Return the wrapper around new ThisClass().
Definition TClass.cxx:7447
Bool_t HasInterpreterInfo() const
Definition TClass.h:410
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
Definition TClass.cxx:5912
TVirtualStreamerInfo * GetStreamerInfo(Int_t version=0, Bool_t isTransient=kFALSE) const
returns a pointer to the TVirtualStreamerInfo object for version If the object does not exist,...
Definition TClass.cxx:4599
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
Definition TClass.cxx:2897
Int_t GetClassSize() const
Definition TClass.h:425
TVirtualStreamerInfo * GetConversionStreamerInfo(const char *onfile_classname, Int_t version) const
Return a Conversion StreamerInfo from the class 'classname' for version number 'version' to this clas...
Definition TClass.cxx:7086
@ kInterpreted
Definition TClass.h:126
ROOT::DelFunc_t GetDelete() const
Return the wrapper around delete ThiObject.
Definition TClass.cxx:7463
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition TClass.cxx:2968
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Basic data type descriptor (datatype information is obtained from CINT).
Definition TDataType.h:44
Int_t GetType() const
Definition TDataType.h:68
Int_t Size() const
Get size of basic typedef'ed type.
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
Definition TEnum.cxx:175
@ kNone
Definition TEnum.h:48
TGenBitsetProxy(const TGenCollectionProxy &c)
void DeleteItem(Bool_t force, void *ptr) const override
Call to delete/destruct individual item.
void * At(UInt_t idx) override
Return the address of the value at index idx
void * invoke(void *obj) const
Small helper to stage the content of an associative container when reading and before inserting it in...
Proxy around an arbitrary container, which implements basic functionality and iteration.
TStreamerInfoActions::TActionSequence * GetReadMemberWiseActions(Int_t version) override
Return the set of action necessary to stream in this collection member-wise coming from the old value...
Method fFirst
Container accessors: generic iteration: first.
std::atomic< Value * > fValue
Descriptor of the container value type.
void Insert(const void *data, void *container, size_t size) override
Insert data into the container where data is a C-style array of the actual type contained in the coll...
Bool_t fPointers
Flag to indicate if containee has pointers (key or value)
Method fNext
Container accessors: generic iteration: next.
virtual void Streamer(TBuffer &refBuffer)
Streamer Function.
TStreamerInfoActions::TActionSequence * fWriteMemberWise
void * Allocate(UInt_t n, Bool_t forceDelete) override
Allocate the needed space.
Bool_t Reset() override
Reset the info gathered from StreamerInfos and value's TClass.
Info_t fTypeinfo
Type information.
int fValOffset
Offset from key to value (in maps)
TClass * GetValueClass() const override
Return a pointer to the TClass representing the content.
EnvironBase_t * fEnv
Address of the currently proxied object.
DeleteIterator_t fFunctionDeleteIterator
Collectfunc_t fCollect
Method to collect objects from container.
void PushProxy(void *objstart) override
Add an object.
void PopProxy() override
Remove the last object.
EDataType GetType() const override
If the content is a simple numerical value, return its type (see TDataType)
TGenCollectionProxy * Initialize(Bool_t silent) const
Proxy initializer.
virtual TGenCollectionProxy * InitializeEx(Bool_t silent)
Proxy initializer.
void Commit(void *env) override
Commit the change.
std::string fName
Name of the class being proxied.
CopyIterator_t GetFunctionCopyIterator(Bool_t read=kTRUE) override
See typedef void (*CopyIterator_t)(void *&dest, const void *source); Copy the iterator source,...
int fSTL_type
STL container type.
CopyIterator_t fFunctionCopyIterator
~TGenCollectionProxy() override
Standard destructor.
ULong_t GetIncrement() const override
Return the offset between two consecutive value_types (memory layout).
Value * fKey
Descriptor of the key_type.
virtual void Resize(UInt_t n, Bool_t force_delete)
Resize the container.
Int_t GetCollectionType() const override
Return the type of collection see TClassEdit::ESTLType.
void Clear(const char *opt="") override
Clear the emulated collection.
Proxies_t fProxyList
Stack of recursive proxies.
DeleteIterator_t GetFunctionDeleteIterator(Bool_t read=kTRUE) override
See typedef void (*DeleteIterator_t)(void *iter); If the sizeof iterator is greater than fgIteratorAr...
UInt_t Size() const override
Return the current size of the container.
Sizing_t fDestruct
Container accessors: block destruct.
Method0 fCreateEnv
Method to allocate an Environment holder.
Value * fVal
Descriptor of the Value_type.
Next_t GetFunctionNext(Bool_t read=kTRUE) override
See typedef void* (*Next_t)(void *iter, void *end); iter and end should be pointer to respectively an...
virtual void operator()(TBuffer &refBuffer, void *pObject)
TClassStreamer IO overload.
TClass * fOnFileClass
On file class.
Sizing_t fResize
Container accessors: resize container.
ArrIterfunc_t fConstruct
Container accessors: block construct.
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
DeleteTwoIterators_t GetFunctionDeleteTwoIterators(Bool_t read=kTRUE) override
See typedef void (*DeleteTwoIterators_t)(void *begin, void *end); If the sizeof iterator is greater t...
std::map< std::string, TObjArray * > * fConversionReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read) derived from another class.
void CheckFunctions() const
Check existence of function pointers.
TVirtualCollectionProxy * Generate() const override
Virtual copy constructor.
DeleteTwoIterators_t fFunctionDeleteTwoIterators
TStreamerInfoActions::TActionSequence * GetWriteMemberWiseActions() override
Return the set of action necessary to stream out this collection member-wise.
Bool_t HasPointers() const override
Return true if the content is of type 'pointer to'.
CreateIterators_t fFunctionCreateIterators
TStreamerInfoActions::TActionSequence * GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version) override
Return the set of action necessary to stream in this collection member-wise coming from the old value...
TObjArray * fReadMemberWise
Array of bundle of TStreamerInfoActions to stream out (read)
virtual void DeleteItem(Bool_t force, void *ptr) const
Call to delete/destruct individual item.
TClass * GetCollectionClass() const override
Return a pointer to the TClass representing the container.
Staged_t fStaged
Optimization: Keep staged array once they were created.
Method fSize
Container accessors: size of container.
Method fClear
Method cache for container accessors: clear container.
Feedfunc_t fFeed
Container accessors: block feed.
CreateIterators_t GetFunctionCreateIterators(Bool_t read=kTRUE) override
See typedef void (*CreateIterators_t)(void *collection, void *&begin_arena, void *&end_arena); begin_...
int fValDiff
Offset between two consecutive value_types (memory layout).
virtual void ReadBuffer(TBuffer &b, void *obj)
Proxies_t fProxyKept
Optimization: Keep proxies once they were created.
UInt_t Sizeof() const override
Return the sizeof the collection object.
const std::type_info & Info_t
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
TGenListProxy(const TGenCollectionProxy &c)
Localoptimization class.
TGenMapProxy(const TGenCollectionProxy &c)
void DeleteItem(Bool_t force, void *ptr) const override
Call to delete/destruct individual item.
Localoptimization class.
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
TGenSetProxy(const TGenCollectionProxy &c)
Local optimization class.
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
TGenVectorBoolProxy(const TGenCollectionProxy &c)
void DeleteItem(Bool_t force, void *ptr) const override
Call to delete/destruct individual item.
Local optimization class.
void DeleteItem(Bool_t force, void *ptr) const override
Call to delete/destruct individual item.
void * At(UInt_t idx) override
Return the address of the value at index 'idx'.
TGenVectorProxy(const TGenCollectionProxy &c)
THashTable implements a hash table to store TObject's.
Definition THashTable.h:35
virtual void TypeInfo_Init(TypeInfo_t *, const char *) const
virtual void TypeInfo_Delete(TypeInfo_t *) const
virtual TypeInfo_t * TypeInfo_Factory() const
virtual Long_t TypeInfo_Property(TypeInfo_t *) const
virtual int TypeInfo_Size(TypeInfo_t *) const
virtual Bool_t TypeInfo_IsValid(TypeInfo_t *) const
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
An array of TObjects.
Definition TObjArray.h:31
void Clear(Option_t *option="") override
Remove all objects from the array.
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
static TActionSequence * CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
static TActionSequence * CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy)
Create the bundle of the actions necessary for the streaming memberwise of the content described by '...
static TClass * Class()
RAII helper class that ensures that PushProxy() / PopProxy() are called when entering / leaving a C++...
Defines a common interface to inspect/change the contents of an object that represents a collection.
virtual Int_t GetProperties() const
Return miscallenous properties of the proxy (see TVirtualCollectionProxy::EProperty)
void(* CreateIterators_t)(void *collection, void **begin_arena, void **end_arena, TVirtualCollectionProxy *proxy)
*begin_arena and *end_arena should contain the location of a memory arena of size fgIteratorArenaSize...
@ kCustomAlloc
The collection has a custom allocator.
@ kNeedDelete
The collection contains directly or indirectly (via other collection) some pointers that need explici...
void *(* CopyIterator_t)(void *dest, const void *source)
Copy the iterator source into dest.
virtual void Clear(const char *opt="")=0
Clear the container.
void *(* Next_t)(void *iter, const void *end)
iter and end should be pointers to an iterator to be incremented and an iterator that points to the e...
virtual void * At(UInt_t idx)=0
Return the address of the value at index idx
virtual UInt_t Size() const =0
Return the current number of elements in the container.
void(* DeleteTwoIterators_t)(void *begin, void *end)
void(* DeleteIterator_t)(void *iter)
If the size of the iterator is greater than fgIteratorArenaSize, call delete on the addresses; otherw...
Abstract Interface class describing Streamer information for one class.
virtual TVirtualStreamerInfo * GenerateInfoForPair(const std::string &pairclassname, bool silent, size_t hint_pair_offset, size_t hint_pair_size)=0
Generate the TClass and TStreamerInfo for the requested pair.
static TVirtualStreamerInfo * Factory()
Static function returning a pointer to a new TVirtualStreamerInfo object.
const Int_t n
Definition legend1.C:16
@ kSTLbitset
Definition ESTLType.h:37
@ kSTLmap
Definition ESTLType.h:33
@ kSTLunorderedmultiset
Definition ESTLType.h:43
@ kROOTRVec
Definition ESTLType.h:46
@ kSTLset
Definition ESTLType.h:35
@ kSTLmultiset
Definition ESTLType.h:36
@ kSTLdeque
Definition ESTLType.h:32
@ kSTLvector
Definition ESTLType.h:30
@ kSTLunorderedmultimap
Definition ESTLType.h:45
@ kSTLunorderedset
Definition ESTLType.h:42
@ kSTLlist
Definition ESTLType.h:31
@ kSTLforwardlist
Definition ESTLType.h:41
@ kSTLunorderedmap
Definition ESTLType.h:44
@ kNotSTL
Definition ESTLType.h:29
@ kSTLmultimap
Definition ESTLType.h:34
ROOT::ESTLType STLKind(std::string_view type)
Converts STL container name to number.
std::string GetNameForIO(const std::string &templateInstanceName, TClassEdit::EModType mode=TClassEdit::kNone, bool *hasChanged=nullptr)
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.
bool IsDefAlloc(const char *alloc, const char *classname)
return whether or not 'allocname' is the STL default allocator for type 'classname'
Small helper to save proxy environment in the event of recursive calls.
Small helper to describe the Value_type or the key_type of an STL container.
UInt_t fCase
type of data of Value_type
TClassRef fType
TClass reference of Value_type in collection.
UInt_t fProperties
Additional properties of the value type (kNeedDelete)
size_t fSize
fSize of the contained object
ROOT::DelFunc_t fDelete
Method cache for containee delete.
ROOT::DesFunc_t fDtor
Method cache for containee destructor.
ROOT::NewFunc_t fCtor
Method cache for containee constructor.
Value(const std::string &info, Bool_t silent, size_t hint_pair_offset=0, size_t hint_pair_size=0)
Constructor.
EDataType fKind
kind of ROOT-fundamental type
Bool_t IsValid()
Return true if the Value has been properly initialized.
TGenCollectionProxy__SlowIterator(TVirtualCollectionProxy *proxy)