// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIJppShowerFitdOdict #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 "JppShowerFit.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *JppShowerFitlEJppGradgR_Dictionary(); static void JppShowerFitlEJppGradgR_TClassManip(TClass*); static void *new_JppShowerFitlEJppGradgR(void *p = 0); static void *newArray_JppShowerFitlEJppGradgR(Long_t size, void *p); static void delete_JppShowerFitlEJppGradgR(void *p); static void deleteArray_JppShowerFitlEJppGradgR(void *p); static void destruct_JppShowerFitlEJppGradgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JppShowerFit*) { ::JppShowerFit *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JppShowerFit)); static ::ROOT::TGenericClassInfo instance("JppShowerFit", "JppShowerFit.hh", 18, typeid(::JppShowerFit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JppShowerFitlEJppGradgR_Dictionary, isa_proxy, 4, sizeof(::JppShowerFit) ); instance.SetNew(&new_JppShowerFitlEJppGradgR); instance.SetNewArray(&newArray_JppShowerFitlEJppGradgR); instance.SetDelete(&delete_JppShowerFitlEJppGradgR); instance.SetDeleteArray(&deleteArray_JppShowerFitlEJppGradgR); instance.SetDestructor(&destruct_JppShowerFitlEJppGradgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JppShowerFit*) { return GenerateInitInstanceLocal((::JppShowerFit*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JppShowerFit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JppShowerFitlEJppGradgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JppShowerFit*)0x0)->GetClass(); JppShowerFitlEJppGradgR_TClassManip(theClass); return theClass; } static void JppShowerFitlEJppGradgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JppShowerFit.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *JppShowerFitlEJppGradEgR_Dictionary(); static void JppShowerFitlEJppGradEgR_TClassManip(TClass*); static void *new_JppShowerFitlEJppGradEgR(void *p = 0); static void *newArray_JppShowerFitlEJppGradEgR(Long_t size, void *p); static void delete_JppShowerFitlEJppGradEgR(void *p); static void deleteArray_JppShowerFitlEJppGradEgR(void *p); static void destruct_JppShowerFitlEJppGradEgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JppShowerFit*) { ::JppShowerFit *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JppShowerFit)); static ::ROOT::TGenericClassInfo instance("JppShowerFit", "JppShowerFit.hh", 18, typeid(::JppShowerFit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JppShowerFitlEJppGradEgR_Dictionary, isa_proxy, 4, sizeof(::JppShowerFit) ); instance.SetNew(&new_JppShowerFitlEJppGradEgR); instance.SetNewArray(&newArray_JppShowerFitlEJppGradEgR); instance.SetDelete(&delete_JppShowerFitlEJppGradEgR); instance.SetDeleteArray(&deleteArray_JppShowerFitlEJppGradEgR); instance.SetDestructor(&destruct_JppShowerFitlEJppGradEgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JppShowerFit*) { return GenerateInitInstanceLocal((::JppShowerFit*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JppShowerFit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JppShowerFitlEJppGradEgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JppShowerFit*)0x0)->GetClass(); JppShowerFitlEJppGradEgR_TClassManip(theClass); return theClass; } static void JppShowerFitlEJppGradEgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JppShowerFit.hh"); } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_JppShowerFitlEJppGradgR(void *p) { return p ? new(p) ::JppShowerFit : new ::JppShowerFit; } static void *newArray_JppShowerFitlEJppGradgR(Long_t nElements, void *p) { return p ? new(p) ::JppShowerFit[nElements] : new ::JppShowerFit[nElements]; } // Wrapper around operator delete static void delete_JppShowerFitlEJppGradgR(void *p) { delete ((::JppShowerFit*)p); } static void deleteArray_JppShowerFitlEJppGradgR(void *p) { delete [] ((::JppShowerFit*)p); } static void destruct_JppShowerFitlEJppGradgR(void *p) { typedef ::JppShowerFit current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JppShowerFit namespace ROOT { // Wrappers around operator new static void *new_JppShowerFitlEJppGradEgR(void *p) { return p ? new(p) ::JppShowerFit : new ::JppShowerFit; } static void *newArray_JppShowerFitlEJppGradEgR(Long_t nElements, void *p) { return p ? new(p) ::JppShowerFit[nElements] : new ::JppShowerFit[nElements]; } // Wrapper around operator delete static void delete_JppShowerFitlEJppGradEgR(void *p) { delete ((::JppShowerFit*)p); } static void deleteArray_JppShowerFitlEJppGradEgR(void *p) { delete [] ((::JppShowerFit*)p); } static void destruct_JppShowerFitlEJppGradEgR(void *p) { typedef ::JppShowerFit current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JppShowerFit namespace ROOT { static TClass *vectorlEintgR_Dictionary(); static void vectorlEintgR_TClassManip(TClass*); static void *new_vectorlEintgR(void *p = 0); static void *newArray_vectorlEintgR(Long_t size, void *p); static void delete_vectorlEintgR(void *p); static void deleteArray_vectorlEintgR(void *p); static void destruct_vectorlEintgR(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), &vectorlEintgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEintgR); instance.SetNewArray(&newArray_vectorlEintgR); instance.SetDelete(&delete_vectorlEintgR); instance.SetDeleteArray(&deleteArray_vectorlEintgR); instance.SetDestructor(&destruct_vectorlEintgR); 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 *vectorlEintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEintgR_TClassManip(theClass); return theClass; } static void vectorlEintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEintgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEintgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEintgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace { void TriggerDictionaryInitialization_JppShowerFitdOdict_Impl() { static const char* headers[] = { "JppShowerFit.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/rec/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "JppShowerFitdOdict 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; class __attribute__((annotate("$clingAutoload$rec2/JppGrad.hh"))) __attribute__((annotate("$clingAutoload$JppShowerFit.hh"))) JppGrad; template class __attribute__((annotate("$clingAutoload$JppShowerFit.hh"))) JppShowerFit; class __attribute__((annotate("$clingAutoload$rec2/JppGradE.hh"))) __attribute__((annotate("$clingAutoload$JppShowerFit.hh"))) JppGradE; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "JppShowerFitdOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "JppShowerFit.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "JppShowerFit", payloadCode, "@", "JppShowerFit", payloadCode, "@", "use_jppshowerfitmerged", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("JppShowerFit.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_JppShowerFitdOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_JppShowerFitdOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_JppShowerFitdOdict() { TriggerDictionaryInitialization_JppShowerFitdOdict_Impl(); }