// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIDetResponsedOdict #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 "DetResponse.hh" // Header files passed via #pragma extra_include namespace ROOT { static void *new_PsfParam(void *p = 0); static void *newArray_PsfParam(Long_t size, void *p); static void delete_PsfParam(void *p); static void deleteArray_PsfParam(void *p); static void destruct_PsfParam(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PsfParam*) { ::PsfParam *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PsfParam >(0); static ::ROOT::TGenericClassInfo instance("PsfParam", ::PsfParam::Class_Version(), "PsfParam.hh", 17, typeid(::PsfParam), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PsfParam::Dictionary, isa_proxy, 4, sizeof(::PsfParam) ); instance.SetNew(&new_PsfParam); instance.SetNewArray(&newArray_PsfParam); instance.SetDelete(&delete_PsfParam); instance.SetDeleteArray(&deleteArray_PsfParam); instance.SetDestructor(&destruct_PsfParam); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PsfParam*) { return GenerateInitInstanceLocal((::PsfParam*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PsfParam*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *convert_decl_Dictionary(); static void convert_decl_TClassManip(TClass*); static void *new_convert_decl(void *p = 0); static void *newArray_convert_decl(Long_t size, void *p); static void delete_convert_decl(void *p); static void deleteArray_convert_decl(void *p); static void destruct_convert_decl(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::convert_decl*) { ::convert_decl *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::convert_decl)); static ::ROOT::TGenericClassInfo instance("convert_decl", "histogram_conversion.hh", 9, typeid(::convert_decl), ::ROOT::Internal::DefineBehavior(ptr, ptr), &convert_decl_Dictionary, isa_proxy, 4, sizeof(::convert_decl) ); instance.SetNew(&new_convert_decl); instance.SetNewArray(&newArray_convert_decl); instance.SetDelete(&delete_convert_decl); instance.SetDeleteArray(&deleteArray_convert_decl); instance.SetDestructor(&destruct_convert_decl); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::convert_decl*) { return GenerateInitInstanceLocal((::convert_decl*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::convert_decl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *convert_decl_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::convert_decl*)0x0)->GetClass(); convert_decl_TClassManip(theClass); return theClass; } static void convert_decl_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","histogram_conversion.hh"); } } // end of namespace ROOT namespace ROOT { static void *new_DetResponse(void *p = 0); static void *newArray_DetResponse(Long_t size, void *p); static void delete_DetResponse(void *p); static void deleteArray_DetResponse(void *p); static void destruct_DetResponse(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DetResponse*) { ::DetResponse *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DetResponse >(0); static ::ROOT::TGenericClassInfo instance("DetResponse", ::DetResponse::Class_Version(), "DetResponse.hh", 13, typeid(::DetResponse), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::DetResponse::Dictionary, isa_proxy, 4, sizeof(::DetResponse) ); instance.SetNew(&new_DetResponse); instance.SetNewArray(&newArray_DetResponse); instance.SetDelete(&delete_DetResponse); instance.SetDeleteArray(&deleteArray_DetResponse); instance.SetDestructor(&destruct_DetResponse); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DetResponse*) { return GenerateInitInstanceLocal((::DetResponse*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DetResponse*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_DefaultDetResponse(void *p = 0); static void *newArray_DefaultDetResponse(Long_t size, void *p); static void delete_DefaultDetResponse(void *p); static void deleteArray_DefaultDetResponse(void *p); static void destruct_DefaultDetResponse(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DefaultDetResponse*) { ::DefaultDetResponse *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DefaultDetResponse >(0); static ::ROOT::TGenericClassInfo instance("DefaultDetResponse", ::DefaultDetResponse::Class_Version(), "DetResponse.hh", 41, typeid(::DefaultDetResponse), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::DefaultDetResponse::Dictionary, isa_proxy, 4, sizeof(::DefaultDetResponse) ); instance.SetNew(&new_DefaultDetResponse); instance.SetNewArray(&newArray_DefaultDetResponse); instance.SetDelete(&delete_DefaultDetResponse); instance.SetDeleteArray(&deleteArray_DefaultDetResponse); instance.SetDestructor(&destruct_DefaultDetResponse); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DefaultDetResponse*) { return GenerateInitInstanceLocal((::DefaultDetResponse*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DefaultDetResponse*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr PsfParam::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *PsfParam::Class_Name() { return "PsfParam"; } //______________________________________________________________________________ const char *PsfParam::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PsfParam*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int PsfParam::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PsfParam*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PsfParam::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PsfParam*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PsfParam::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PsfParam*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr DetResponse::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *DetResponse::Class_Name() { return "DetResponse"; } //______________________________________________________________________________ const char *DetResponse::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::DetResponse*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int DetResponse::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::DetResponse*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DetResponse::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetResponse*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DetResponse::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetResponse*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr DefaultDetResponse::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *DefaultDetResponse::Class_Name() { return "DefaultDetResponse"; } //______________________________________________________________________________ const char *DefaultDetResponse::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::DefaultDetResponse*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int DefaultDetResponse::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::DefaultDetResponse*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DefaultDetResponse::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DefaultDetResponse*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DefaultDetResponse::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DefaultDetResponse*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ void PsfParam::Streamer(TBuffer &R__b) { // Stream an object of class PsfParam. if (R__b.IsReading()) { R__b.ReadClassBuffer(PsfParam::Class(),this); } else { R__b.WriteClassBuffer(PsfParam::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PsfParam(void *p) { return p ? new(p) ::PsfParam : new ::PsfParam; } static void *newArray_PsfParam(Long_t nElements, void *p) { return p ? new(p) ::PsfParam[nElements] : new ::PsfParam[nElements]; } // Wrapper around operator delete static void delete_PsfParam(void *p) { delete ((::PsfParam*)p); } static void deleteArray_PsfParam(void *p) { delete [] ((::PsfParam*)p); } static void destruct_PsfParam(void *p) { typedef ::PsfParam current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::PsfParam namespace ROOT { // Wrappers around operator new static void *new_convert_decl(void *p) { return p ? new(p) ::convert_decl : new ::convert_decl; } static void *newArray_convert_decl(Long_t nElements, void *p) { return p ? new(p) ::convert_decl[nElements] : new ::convert_decl[nElements]; } // Wrapper around operator delete static void delete_convert_decl(void *p) { delete ((::convert_decl*)p); } static void deleteArray_convert_decl(void *p) { delete [] ((::convert_decl*)p); } static void destruct_convert_decl(void *p) { typedef ::convert_decl current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::convert_decl //______________________________________________________________________________ void DetResponse::Streamer(TBuffer &R__b) { // Stream an object of class DetResponse. if (R__b.IsReading()) { R__b.ReadClassBuffer(DetResponse::Class(),this); } else { R__b.WriteClassBuffer(DetResponse::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_DetResponse(void *p) { return p ? new(p) ::DetResponse : new ::DetResponse; } static void *newArray_DetResponse(Long_t nElements, void *p) { return p ? new(p) ::DetResponse[nElements] : new ::DetResponse[nElements]; } // Wrapper around operator delete static void delete_DetResponse(void *p) { delete ((::DetResponse*)p); } static void deleteArray_DetResponse(void *p) { delete [] ((::DetResponse*)p); } static void destruct_DetResponse(void *p) { typedef ::DetResponse current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::DetResponse //______________________________________________________________________________ void DefaultDetResponse::Streamer(TBuffer &R__b) { // Stream an object of class DefaultDetResponse. if (R__b.IsReading()) { R__b.ReadClassBuffer(DefaultDetResponse::Class(),this); } else { R__b.WriteClassBuffer(DefaultDetResponse::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_DefaultDetResponse(void *p) { return p ? new(p) ::DefaultDetResponse : new ::DefaultDetResponse; } static void *newArray_DefaultDetResponse(Long_t nElements, void *p) { return p ? new(p) ::DefaultDetResponse[nElements] : new ::DefaultDetResponse[nElements]; } // Wrapper around operator delete static void delete_DefaultDetResponse(void *p) { delete ((::DefaultDetResponse*)p); } static void deleteArray_DefaultDetResponse(void *p) { delete [] ((::DefaultDetResponse*)p); } static void destruct_DefaultDetResponse(void *p) { typedef ::DefaultDetResponse current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::DefaultDetResponse namespace ROOT { static TClass *vectorlETSpline3gR_Dictionary(); static void vectorlETSpline3gR_TClassManip(TClass*); static void *new_vectorlETSpline3gR(void *p = 0); static void *newArray_vectorlETSpline3gR(Long_t size, void *p); static void delete_vectorlETSpline3gR(void *p); static void deleteArray_vectorlETSpline3gR(void *p); static void destruct_vectorlETSpline3gR(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), &vectorlETSpline3gR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETSpline3gR); instance.SetNewArray(&newArray_vectorlETSpline3gR); instance.SetDelete(&delete_vectorlETSpline3gR); instance.SetDeleteArray(&deleteArray_vectorlETSpline3gR); instance.SetDestructor(&destruct_vectorlETSpline3gR); 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 *vectorlETSpline3gR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlETSpline3gR_TClassManip(theClass); return theClass; } static void vectorlETSpline3gR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETSpline3gR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETSpline3gR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETSpline3gR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlETSpline3gR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlETSpline3gR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlETH1DgR_Dictionary(); static void vectorlETH1DgR_TClassManip(TClass*); static void *new_vectorlETH1DgR(void *p = 0); static void *newArray_vectorlETH1DgR(Long_t size, void *p); static void delete_vectorlETH1DgR(void *p); static void deleteArray_vectorlETH1DgR(void *p); static void destruct_vectorlETH1DgR(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), &vectorlETH1DgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETH1DgR); instance.SetNewArray(&newArray_vectorlETH1DgR); instance.SetDelete(&delete_vectorlETH1DgR); instance.SetDeleteArray(&deleteArray_vectorlETH1DgR); instance.SetDestructor(&destruct_vectorlETH1DgR); 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 *vectorlETH1DgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlETH1DgR_TClassManip(theClass); return theClass; } static void vectorlETH1DgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETH1DgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETH1DgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETH1DgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlETH1DgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlETH1DgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *maplEstringcOTH3DgR_Dictionary(); static void maplEstringcOTH3DgR_TClassManip(TClass*); static void *new_maplEstringcOTH3DgR(void *p = 0); static void *newArray_maplEstringcOTH3DgR(Long_t size, void *p); static void delete_maplEstringcOTH3DgR(void *p); static void deleteArray_maplEstringcOTH3DgR(void *p); static void destruct_maplEstringcOTH3DgR(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), &maplEstringcOTH3DgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOTH3DgR); instance.SetNewArray(&newArray_maplEstringcOTH3DgR); instance.SetDelete(&delete_maplEstringcOTH3DgR); instance.SetDeleteArray(&deleteArray_maplEstringcOTH3DgR); instance.SetDestructor(&destruct_maplEstringcOTH3DgR); 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 *maplEstringcOTH3DgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEstringcOTH3DgR_TClassManip(theClass); return theClass; } static void maplEstringcOTH3DgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOTH3DgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOTH3DgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOTH3DgR(void *p) { delete ((map*)p); } static void deleteArray_maplEstringcOTH3DgR(void *p) { delete [] ((map*)p); } static void destruct_maplEstringcOTH3DgR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOTH2DgR_Dictionary(); static void maplEstringcOTH2DgR_TClassManip(TClass*); static void *new_maplEstringcOTH2DgR(void *p = 0); static void *newArray_maplEstringcOTH2DgR(Long_t size, void *p); static void delete_maplEstringcOTH2DgR(void *p); static void deleteArray_maplEstringcOTH2DgR(void *p); static void destruct_maplEstringcOTH2DgR(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), &maplEstringcOTH2DgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOTH2DgR); instance.SetNewArray(&newArray_maplEstringcOTH2DgR); instance.SetDelete(&delete_maplEstringcOTH2DgR); instance.SetDeleteArray(&deleteArray_maplEstringcOTH2DgR); instance.SetDestructor(&destruct_maplEstringcOTH2DgR); 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 *maplEstringcOTH2DgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEstringcOTH2DgR_TClassManip(theClass); return theClass; } static void maplEstringcOTH2DgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOTH2DgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOTH2DgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOTH2DgR(void *p) { delete ((map*)p); } static void deleteArray_maplEstringcOTH2DgR(void *p) { delete [] ((map*)p); } static void destruct_maplEstringcOTH2DgR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace { void TriggerDictionaryInitialization_DetResponsedOdict_Impl() { static const char* headers[] = { "DetResponse.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 "DetResponsedOdict 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@@@PsfParam.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$PsfParam.hh"))) __attribute__((annotate("$clingAutoload$DetResponse.hh"))) PsfParam; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@histogram_conversion.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$histogram_conversion.hh"))) __attribute__((annotate("$clingAutoload$DetResponse.hh"))) convert_decl; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@DetResponse.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$DetResponse.hh"))) DetResponse; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@DetResponse.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$DetResponse.hh"))) DefaultDetResponse; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "DetResponsedOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "DetResponse.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "DefaultDetResponse", payloadCode, "@", "DefaultDetResponse::fgIsA", payloadCode, "@", "DetResponse", payloadCode, "@", "DetResponse::fgIsA", payloadCode, "@", "PsfParam", payloadCode, "@", "PsfParam::fgIsA", payloadCode, "@", "conversion_table_costheta_sindecl", payloadCode, "@", "convert_decl", payloadCode, "@", "convert_to_sindecl", payloadCode, "@", "h_declzen_conversion", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("DetResponse.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_DetResponsedOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_DetResponsedOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_DetResponsedOdict() { TriggerDictionaryInitialization_DetResponsedOdict_Impl(); }