// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIutildOdict #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 "util.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *DomSum_Dictionary(); static void DomSum_TClassManip(TClass*); static void *new_DomSum(void *p = 0); static void *newArray_DomSum(Long_t size, void *p); static void delete_DomSum(void *p); static void deleteArray_DomSum(void *p); static void destruct_DomSum(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DomSum*) { ::DomSum *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DomSum)); static ::ROOT::TGenericClassInfo instance("DomSum", "util.hh", 15, typeid(::DomSum), ::ROOT::Internal::DefineBehavior(ptr, ptr), &DomSum_Dictionary, isa_proxy, 4, sizeof(::DomSum) ); instance.SetNew(&new_DomSum); instance.SetNewArray(&newArray_DomSum); instance.SetDelete(&delete_DomSum); instance.SetDeleteArray(&deleteArray_DomSum); instance.SetDestructor(&destruct_DomSum); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DomSum*) { return GenerateInitInstanceLocal((::DomSum*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DomSum*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *DomSum_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DomSum*)0x0)->GetClass(); DomSum_TClassManip(theClass); return theClass; } static void DomSum_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","util.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Fdom_Dictionary(); static void Fdom_TClassManip(TClass*); static void *new_Fdom(void *p = 0); static void *newArray_Fdom(Long_t size, void *p); static void delete_Fdom(void *p); static void deleteArray_Fdom(void *p); static void destruct_Fdom(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Fdom*) { ::Fdom *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Fdom)); static ::ROOT::TGenericClassInfo instance("Fdom", "util.hh", 37, typeid(::Fdom), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Fdom_Dictionary, isa_proxy, 4, sizeof(::Fdom) ); instance.SetNew(&new_Fdom); instance.SetNewArray(&newArray_Fdom); instance.SetDelete(&delete_Fdom); instance.SetDeleteArray(&deleteArray_Fdom); instance.SetDestructor(&destruct_Fdom); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Fdom*) { return GenerateInitInstanceLocal((::Fdom*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Fdom*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Fdom_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Fdom*)0x0)->GetClass(); Fdom_TClassManip(theClass); return theClass; } static void Fdom_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","util.hh"); } } // end of namespace ROOT namespace ROOT { static void delete_Cherenkov_pars(void *p); static void deleteArray_Cherenkov_pars(void *p); static void destruct_Cherenkov_pars(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Cherenkov_pars*) { ::Cherenkov_pars *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Cherenkov_pars >(0); static ::ROOT::TGenericClassInfo instance("Cherenkov_pars", ::Cherenkov_pars::Class_Version(), "util.hh", 281, typeid(::Cherenkov_pars), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Cherenkov_pars::Dictionary, isa_proxy, 4, sizeof(::Cherenkov_pars) ); instance.SetDelete(&delete_Cherenkov_pars); instance.SetDeleteArray(&deleteArray_Cherenkov_pars); instance.SetDestructor(&destruct_Cherenkov_pars); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Cherenkov_pars*) { return GenerateInitInstanceLocal((::Cherenkov_pars*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Cherenkov_pars*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr Cherenkov_pars::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Cherenkov_pars::Class_Name() { return "Cherenkov_pars"; } //______________________________________________________________________________ const char *Cherenkov_pars::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Cherenkov_pars*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Cherenkov_pars::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Cherenkov_pars*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Cherenkov_pars::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Cherenkov_pars*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Cherenkov_pars::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Cherenkov_pars*)0x0)->GetClass(); } return fgIsA; } namespace ROOT { // Wrappers around operator new static void *new_DomSum(void *p) { return p ? new(p) ::DomSum : new ::DomSum; } static void *newArray_DomSum(Long_t nElements, void *p) { return p ? new(p) ::DomSum[nElements] : new ::DomSum[nElements]; } // Wrapper around operator delete static void delete_DomSum(void *p) { delete ((::DomSum*)p); } static void deleteArray_DomSum(void *p) { delete [] ((::DomSum*)p); } static void destruct_DomSum(void *p) { typedef ::DomSum current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::DomSum namespace ROOT { // Wrappers around operator new static void *new_Fdom(void *p) { return p ? new(p) ::Fdom : new ::Fdom; } static void *newArray_Fdom(Long_t nElements, void *p) { return p ? new(p) ::Fdom[nElements] : new ::Fdom[nElements]; } // Wrapper around operator delete static void delete_Fdom(void *p) { delete ((::Fdom*)p); } static void deleteArray_Fdom(void *p) { delete [] ((::Fdom*)p); } static void destruct_Fdom(void *p) { typedef ::Fdom current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Fdom //______________________________________________________________________________ void Cherenkov_pars::Streamer(TBuffer &R__b) { // Stream an object of class Cherenkov_pars. if (R__b.IsReading()) { R__b.ReadClassBuffer(Cherenkov_pars::Class(),this); } else { R__b.WriteClassBuffer(Cherenkov_pars::Class(),this); } } namespace ROOT { // Wrapper around operator delete static void delete_Cherenkov_pars(void *p) { delete ((::Cherenkov_pars*)p); } static void deleteArray_Cherenkov_pars(void *p) { delete [] ((::Cherenkov_pars*)p); } static void destruct_Cherenkov_pars(void *p) { typedef ::Cherenkov_pars current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Cherenkov_pars namespace ROOT { static TClass *vectorlEpairlEunsignedsPintcOVecgRsPgR_Dictionary(); static void vectorlEpairlEunsignedsPintcOVecgRsPgR_TClassManip(TClass*); static void *new_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p = 0); static void *newArray_vectorlEpairlEunsignedsPintcOVecgRsPgR(Long_t size, void *p); static void delete_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p); static void deleteArray_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p); static void destruct_vectorlEpairlEunsignedsPintcOVecgRsPgR(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), &vectorlEpairlEunsignedsPintcOVecgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); instance.SetNew(&new_vectorlEpairlEunsignedsPintcOVecgRsPgR); instance.SetNewArray(&newArray_vectorlEpairlEunsignedsPintcOVecgRsPgR); instance.SetDelete(&delete_vectorlEpairlEunsignedsPintcOVecgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEpairlEunsignedsPintcOVecgRsPgR); instance.SetDestructor(&destruct_vectorlEpairlEunsignedsPintcOVecgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > >())); ::ROOT::AddClassAlternate("vector >","std::vector, std::allocator > >"); 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 *vectorlEpairlEunsignedsPintcOVecgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector >*)0x0)->GetClass(); vectorlEpairlEunsignedsPintcOVecgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEpairlEunsignedsPintcOVecgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > : new vector >; } static void *newArray_vectorlEpairlEunsignedsPintcOVecgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p) { delete ((vector >*)p); } static void deleteArray_vectorlEpairlEunsignedsPintcOVecgRsPgR(void *p) { delete [] ((vector >*)p); } static void destruct_vectorlEpairlEunsignedsPintcOVecgRsPgR(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 *vectorlESplinegR_Dictionary(); static void vectorlESplinegR_TClassManip(TClass*); static void *new_vectorlESplinegR(void *p = 0); static void *newArray_vectorlESplinegR(Long_t size, void *p); static void delete_vectorlESplinegR(void *p); static void deleteArray_vectorlESplinegR(void *p); static void destruct_vectorlESplinegR(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), &vectorlESplinegR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlESplinegR); instance.SetNewArray(&newArray_vectorlESplinegR); instance.SetDelete(&delete_vectorlESplinegR); instance.SetDeleteArray(&deleteArray_vectorlESplinegR); instance.SetDestructor(&destruct_vectorlESplinegR); 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 *vectorlESplinegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlESplinegR_TClassManip(theClass); return theClass; } static void vectorlESplinegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlESplinegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlESplinegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlESplinegR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlESplinegR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlESplinegR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace { void TriggerDictionaryInitialization_utildOdict_Impl() { static const char* headers[] = { "util.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", "/usr/local/include/", "/km3net/aanet/rec/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "utildOdict 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@@@util.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$util.hh"))) DomSum; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@util.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$util.hh"))) Fdom; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@util.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$util.hh"))) Cherenkov_pars; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "utildOdict dictionary payload" #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "util.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "Cherenkov_pars", payloadCode, "@", "Cherenkov_pars::fgIsA", payloadCode, "@", "DomSum", payloadCode, "@", "Fdom", payloadCode, "@", "earlier", payloadCode, "@", "filter_hits", payloadCode, "@", "first_sort", payloadCode, "@", "get_coincidences", payloadCode, "@", "greedy_merge", payloadCode, "@", "hit_to_dom_ratio", payloadCode, "@", "log_without_error", payloadCode, "@", "merge_hits", payloadCode, "@", "poisson", payloadCode, "@", "select_hits", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("util.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_utildOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_utildOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_utildOdict() { TriggerDictionaryInitialization_utildOdict_Impl(); }