// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIFullDetResponsedOdict #define R__NO_DEPRECATION /*******************************************************************/ #include #include #include #include #include #define G__DICTIONARY #include "RConfig.h" #include "TClass.h" #include "TDictAttributeMap.h" #include "TInterpreter.h" #include "TROOT.h" #include "TBuffer.h" #include "TMemberInspector.h" #include "TInterpreter.h" #include "TVirtualMutex.h" #include "TError.h" #ifndef G__ROOT #define G__ROOT #endif #include "RtypesImp.h" #include "TIsAProxy.h" #include "TFileMergeInfo.h" #include #include "TCollectionProxyInfo.h" /*******************************************************************/ #include "TDataMember.h" // The generated code does not explicitly qualifies STL entities namespace std {} using namespace std; // Header files passed as explicit arguments #include "FullDetResponse.hh" // Header files passed via #pragma extra_include namespace ROOT { static void *new_FullDetResponse(void *p = 0); static void *newArray_FullDetResponse(Long_t size, void *p); static void delete_FullDetResponse(void *p); static void deleteArray_FullDetResponse(void *p); static void destruct_FullDetResponse(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::FullDetResponse*) { ::FullDetResponse *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::FullDetResponse >(0); static ::ROOT::TGenericClassInfo instance("FullDetResponse", ::FullDetResponse::Class_Version(), "FullDetResponse.hh", 8, typeid(::FullDetResponse), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::FullDetResponse::Dictionary, isa_proxy, 4, sizeof(::FullDetResponse) ); instance.SetNew(&new_FullDetResponse); instance.SetNewArray(&newArray_FullDetResponse); instance.SetDelete(&delete_FullDetResponse); instance.SetDeleteArray(&deleteArray_FullDetResponse); instance.SetDestructor(&destruct_FullDetResponse); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::FullDetResponse*) { return GenerateInitInstanceLocal((::FullDetResponse*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::FullDetResponse*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr FullDetResponse::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *FullDetResponse::Class_Name() { return "FullDetResponse"; } //______________________________________________________________________________ const char *FullDetResponse::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::FullDetResponse*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int FullDetResponse::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::FullDetResponse*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *FullDetResponse::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::FullDetResponse*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *FullDetResponse::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::FullDetResponse*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ void FullDetResponse::Streamer(TBuffer &R__b) { // Stream an object of class FullDetResponse. if (R__b.IsReading()) { R__b.ReadClassBuffer(FullDetResponse::Class(),this); } else { R__b.WriteClassBuffer(FullDetResponse::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_FullDetResponse(void *p) { return p ? new(p) ::FullDetResponse : new ::FullDetResponse; } static void *newArray_FullDetResponse(Long_t nElements, void *p) { return p ? new(p) ::FullDetResponse[nElements] : new ::FullDetResponse[nElements]; } // Wrapper around operator delete static void delete_FullDetResponse(void *p) { delete ((::FullDetResponse*)p); } static void deleteArray_FullDetResponse(void *p) { delete [] ((::FullDetResponse*)p); } static void destruct_FullDetResponse(void *p) { typedef ::FullDetResponse current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::FullDetResponse namespace ROOT { static TClass *vectorlEdefscLcLFlavorgR_Dictionary(); static void vectorlEdefscLcLFlavorgR_TClassManip(TClass*); static void *new_vectorlEdefscLcLFlavorgR(void *p = 0); static void *newArray_vectorlEdefscLcLFlavorgR(Long_t size, void *p); static void delete_vectorlEdefscLcLFlavorgR(void *p); static void deleteArray_vectorlEdefscLcLFlavorgR(void *p); static void destruct_vectorlEdefscLcLFlavorgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEdefscLcLFlavorgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEdefscLcLFlavorgR); instance.SetNewArray(&newArray_vectorlEdefscLcLFlavorgR); instance.SetDelete(&delete_vectorlEdefscLcLFlavorgR); instance.SetDeleteArray(&deleteArray_vectorlEdefscLcLFlavorgR); instance.SetDestructor(&destruct_vectorlEdefscLcLFlavorgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdefscLcLFlavorgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEdefscLcLFlavorgR_TClassManip(theClass); return theClass; } static void vectorlEdefscLcLFlavorgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEdefscLcLFlavorgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEdefscLcLFlavorgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdefscLcLFlavorgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEdefscLcLFlavorgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEdefscLcLFlavorgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEdefscLcLChannelgR_Dictionary(); static void vectorlEdefscLcLChannelgR_TClassManip(TClass*); static void *new_vectorlEdefscLcLChannelgR(void *p = 0); static void *newArray_vectorlEdefscLcLChannelgR(Long_t size, void *p); static void delete_vectorlEdefscLcLChannelgR(void *p); static void deleteArray_vectorlEdefscLcLChannelgR(void *p); static void destruct_vectorlEdefscLcLChannelgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEdefscLcLChannelgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEdefscLcLChannelgR); instance.SetNewArray(&newArray_vectorlEdefscLcLChannelgR); instance.SetDelete(&delete_vectorlEdefscLcLChannelgR); instance.SetDeleteArray(&deleteArray_vectorlEdefscLcLChannelgR); instance.SetDestructor(&destruct_vectorlEdefscLcLChannelgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdefscLcLChannelgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEdefscLcLChannelgR_TClassManip(theClass); return theClass; } static void vectorlEdefscLcLChannelgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEdefscLcLChannelgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEdefscLcLChannelgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdefscLcLChannelgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEdefscLcLChannelgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEdefscLcLChannelgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *maplEintcOmaplEintcODefaultDetResponsegRsPgR_Dictionary(); static void maplEintcOmaplEintcODefaultDetResponsegRsPgR_TClassManip(TClass*); static void *new_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p = 0); static void *newArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR(Long_t size, void *p); static void delete_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p); static void deleteArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p); static void destruct_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 96, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEintcOmaplEintcODefaultDetResponsegRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEintcOmaplEintcODefaultDetResponsegRsPgR); instance.SetNewArray(&newArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR); instance.SetDelete(&delete_maplEintcOmaplEintcODefaultDetResponsegRsPgR); instance.SetDeleteArray(&deleteArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR); instance.SetDestructor(&destruct_maplEintcOmaplEintcODefaultDetResponsegRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::allocator > >, std::less, std::allocator, std::allocator > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEintcOmaplEintcODefaultDetResponsegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map >*)0x0)->GetClass(); maplEintcOmaplEintcODefaultDetResponsegRsPgR_TClassManip(theClass); return theClass; } static void maplEintcOmaplEintcODefaultDetResponsegRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p) { delete ((map >*)p); } static void deleteArray_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p) { delete [] ((map >*)p); } static void destruct_maplEintcOmaplEintcODefaultDetResponsegRsPgR(void *p) { typedef map > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEintcODefaultDetResponsegR_Dictionary(); static void maplEintcODefaultDetResponsegR_TClassManip(TClass*); static void *new_maplEintcODefaultDetResponsegR(void *p = 0); static void *newArray_maplEintcODefaultDetResponsegR(Long_t size, void *p); static void delete_maplEintcODefaultDetResponsegR(void *p); static void deleteArray_maplEintcODefaultDetResponsegR(void *p); static void destruct_maplEintcODefaultDetResponsegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 96, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEintcODefaultDetResponsegR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEintcODefaultDetResponsegR); instance.SetNewArray(&newArray_maplEintcODefaultDetResponsegR); instance.SetDelete(&delete_maplEintcODefaultDetResponsegR); instance.SetDeleteArray(&deleteArray_maplEintcODefaultDetResponsegR); instance.SetDestructor(&destruct_maplEintcODefaultDetResponsegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEintcODefaultDetResponsegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEintcODefaultDetResponsegR_TClassManip(theClass); return theClass; } static void maplEintcODefaultDetResponsegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcODefaultDetResponsegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcODefaultDetResponsegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcODefaultDetResponsegR(void *p) { delete ((map*)p); } static void deleteArray_maplEintcODefaultDetResponsegR(void *p) { delete [] ((map*)p); } static void destruct_maplEintcODefaultDetResponsegR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace { void TriggerDictionaryInitialization_FullDetResponsedOdict_Impl() { static const char* headers[] = { "FullDetResponse.hh", 0 }; static const char* includePaths[] = { "/usr/local/include", "/km3net/aanet/evt", "/km3net/aanet/astro", "/km3net/aanet", "/km3net/aanet/externals", "/km3net/aanet/externals/km3net-dataformat/offline", "/km3net/aanet/externals/km3net-dataformat/online", "/km3net/aanet/externals/flux", "/Jpp/software/", "/Jpp/externals/antares-daq/include/", "/usr/local/include/", "/km3net/aanet/ana/search/src/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "FullDetResponsedOdict dictionary forward declarations' payload" #pragma clang diagnostic ignored "-Wkeyword-compat" #pragma clang diagnostic ignored "-Wignored-attributes" #pragma clang diagnostic ignored "-Wreturn-type-c-linkage" extern int __Cling_AutoLoading_Map; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@FullDetResponse.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$FullDetResponse.hh"))) FullDetResponse; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "FullDetResponsedOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "FullDetResponse.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "FullDetResponse", payloadCode, "@", "FullDetResponse::fgIsA", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("FullDetResponse.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_FullDetResponsedOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_FullDetResponsedOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_FullDetResponsedOdict() { TriggerDictionaryInitialization_FullDetResponsedOdict_Impl(); }