// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIDetdOdict #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 "Det.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *pairlEintcODomgR_Dictionary(); static void pairlEintcODomgR_TClassManip(TClass*); static void *new_pairlEintcODomgR(void *p = 0); static void *newArray_pairlEintcODomgR(Long_t size, void *p); static void delete_pairlEintcODomgR(void *p); static void deleteArray_pairlEintcODomgR(void *p); static void destruct_pairlEintcODomgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const pair*) { pair *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair)); static ::ROOT::TGenericClassInfo instance("pair", "string", 96, typeid(pair), ::ROOT::Internal::DefineBehavior(ptr, ptr), &pairlEintcODomgR_Dictionary, isa_proxy, 0, sizeof(pair) ); instance.SetNew(&new_pairlEintcODomgR); instance.SetNewArray(&newArray_pairlEintcODomgR); instance.SetDelete(&delete_pairlEintcODomgR); instance.SetDeleteArray(&deleteArray_pairlEintcODomgR); instance.SetDestructor(&destruct_pairlEintcODomgR); ::ROOT::AddClassAlternate("pair","std::pair"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const pair*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *pairlEintcODomgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const pair*)0x0)->GetClass(); pairlEintcODomgR_TClassManip(theClass); return theClass; } static void pairlEintcODomgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *_Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_Dictionary(); static void _Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_TClassManip(TClass*); static void *new__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p = 0); static void *newArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(Long_t size, void *p); static void delete__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p); static void deleteArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p); static void destruct__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::_Rb_tree_iterator >*) { ::_Rb_tree_iterator > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::_Rb_tree_iterator >)); static ::ROOT::TGenericClassInfo instance("_Rb_tree_iterator >", "map", 157, typeid(::_Rb_tree_iterator >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &_Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_Dictionary, isa_proxy, 0, sizeof(::_Rb_tree_iterator >) ); instance.SetNew(&new__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR); instance.SetNewArray(&newArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR); instance.SetDelete(&delete__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR); instance.SetDeleteArray(&deleteArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR); instance.SetDestructor(&destruct__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR); ::ROOT::AddClassAlternate("_Rb_tree_iterator >","map::iterator"); ::ROOT::AddClassAlternate("_Rb_tree_iterator >","std::_Rb_tree_iterator >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::_Rb_tree_iterator >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *_Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::_Rb_tree_iterator >*)0x0)->GetClass(); _Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_TClassManip(theClass); return theClass; } static void _Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_Pmt(void *p = 0); static void *newArray_Pmt(Long_t size, void *p); static void delete_Pmt(void *p); static void deleteArray_Pmt(void *p); static void destruct_Pmt(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Pmt*) { ::Pmt *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Pmt >(0); static ::ROOT::TGenericClassInfo instance("Pmt", ::Pmt::Class_Version(), "Det.hh", 26, typeid(::Pmt), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Pmt::Dictionary, isa_proxy, 4, sizeof(::Pmt) ); instance.SetNew(&new_Pmt); instance.SetNewArray(&newArray_Pmt); instance.SetDelete(&delete_Pmt); instance.SetDeleteArray(&deleteArray_Pmt); instance.SetDestructor(&destruct_Pmt); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Pmt*) { return GenerateInitInstanceLocal((::Pmt*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Pmt*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_Dom(void *p = 0); static void *newArray_Dom(Long_t size, void *p); static void delete_Dom(void *p); static void deleteArray_Dom(void *p); static void destruct_Dom(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Dom*) { ::Dom *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Dom >(0); static ::ROOT::TGenericClassInfo instance("Dom", ::Dom::Class_Version(), "Det.hh", 78, typeid(::Dom), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Dom::Dictionary, isa_proxy, 4, sizeof(::Dom) ); instance.SetNew(&new_Dom); instance.SetNewArray(&newArray_Dom); instance.SetDelete(&delete_Dom); instance.SetDeleteArray(&deleteArray_Dom); instance.SetDestructor(&destruct_Dom); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Dom*) { return GenerateInitInstanceLocal((::Dom*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Dom*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_Det(void *p = 0); static void *newArray_Det(Long_t size, void *p); static void delete_Det(void *p); static void deleteArray_Det(void *p); static void destruct_Det(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Det*) { ::Det *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Det >(0); static ::ROOT::TGenericClassInfo instance("Det", ::Det::Class_Version(), "Det.hh", 115, typeid(::Det), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Det::Dictionary, isa_proxy, 4, sizeof(::Det) ); instance.SetNew(&new_Det); instance.SetNewArray(&newArray_Det); instance.SetDelete(&delete_Det); instance.SetDeleteArray(&deleteArray_Det); instance.SetDestructor(&destruct_Det); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Det*) { return GenerateInitInstanceLocal((::Det*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Det*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *DetDim_Dictionary(); static void DetDim_TClassManip(TClass*); static void delete_DetDim(void *p); static void deleteArray_DetDim(void *p); static void destruct_DetDim(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DetDim*) { ::DetDim *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::DetDim)); static ::ROOT::TGenericClassInfo instance("DetDim", "Det.hh", 471, typeid(::DetDim), ::ROOT::Internal::DefineBehavior(ptr, ptr), &DetDim_Dictionary, isa_proxy, 4, sizeof(::DetDim) ); instance.SetDelete(&delete_DetDim); instance.SetDeleteArray(&deleteArray_DetDim); instance.SetDestructor(&destruct_DetDim); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DetDim*) { return GenerateInitInstanceLocal((::DetDim*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DetDim*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *DetDim_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::DetDim*)0x0)->GetClass(); DetDim_TClassManip(theClass); return theClass; } static void DetDim_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Det.hh"); } } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr Pmt::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Pmt::Class_Name() { return "Pmt"; } //______________________________________________________________________________ const char *Pmt::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Pmt*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Pmt::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Pmt*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Pmt::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Pmt*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Pmt::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Pmt*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr Dom::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Dom::Class_Name() { return "Dom"; } //______________________________________________________________________________ const char *Dom::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Dom*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Dom::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Dom*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Dom::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Dom*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Dom::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Dom*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr Det::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Det::Class_Name() { return "Det"; } //______________________________________________________________________________ const char *Det::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Det*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Det::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Det*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Det::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Det*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Det::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Det*)0x0)->GetClass(); } return fgIsA; } namespace ROOT { // Wrappers around operator new static void *new_pairlEintcODomgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair : new pair; } static void *newArray_pairlEintcODomgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) pair[nElements] : new pair[nElements]; } // Wrapper around operator delete static void delete_pairlEintcODomgR(void *p) { delete ((pair*)p); } static void deleteArray_pairlEintcODomgR(void *p) { delete [] ((pair*)p); } static void destruct_pairlEintcODomgR(void *p) { typedef pair current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class pair namespace ROOT { // Wrappers around operator new static void *new__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Rb_tree_iterator > : new ::_Rb_tree_iterator >; } static void *newArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Rb_tree_iterator >[nElements] : new ::_Rb_tree_iterator >[nElements]; } // Wrapper around operator delete static void delete__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p) { delete ((::_Rb_tree_iterator >*)p); } static void deleteArray__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p) { delete [] ((::_Rb_tree_iterator >*)p); } static void destruct__Rb_tree_iteratorlEpairlEconstsPintcODomgRsPgR(void *p) { typedef ::_Rb_tree_iterator > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::_Rb_tree_iterator > //______________________________________________________________________________ void Pmt::Streamer(TBuffer &R__b) { // Stream an object of class Pmt. if (R__b.IsReading()) { R__b.ReadClassBuffer(Pmt::Class(),this); } else { R__b.WriteClassBuffer(Pmt::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_Pmt(void *p) { return p ? new(p) ::Pmt : new ::Pmt; } static void *newArray_Pmt(Long_t nElements, void *p) { return p ? new(p) ::Pmt[nElements] : new ::Pmt[nElements]; } // Wrapper around operator delete static void delete_Pmt(void *p) { delete ((::Pmt*)p); } static void deleteArray_Pmt(void *p) { delete [] ((::Pmt*)p); } static void destruct_Pmt(void *p) { typedef ::Pmt current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Pmt //______________________________________________________________________________ void Dom::Streamer(TBuffer &R__b) { // Stream an object of class Dom. if (R__b.IsReading()) { R__b.ReadClassBuffer(Dom::Class(),this); } else { R__b.WriteClassBuffer(Dom::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_Dom(void *p) { return p ? new(p) ::Dom : new ::Dom; } static void *newArray_Dom(Long_t nElements, void *p) { return p ? new(p) ::Dom[nElements] : new ::Dom[nElements]; } // Wrapper around operator delete static void delete_Dom(void *p) { delete ((::Dom*)p); } static void deleteArray_Dom(void *p) { delete [] ((::Dom*)p); } static void destruct_Dom(void *p) { typedef ::Dom current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Dom //______________________________________________________________________________ void Det::Streamer(TBuffer &R__b) { // Stream an object of class Det. if (R__b.IsReading()) { R__b.ReadClassBuffer(Det::Class(),this); } else { R__b.WriteClassBuffer(Det::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_Det(void *p) { return p ? new(p) ::Det : new ::Det; } static void *newArray_Det(Long_t nElements, void *p) { return p ? new(p) ::Det[nElements] : new ::Det[nElements]; } // Wrapper around operator delete static void delete_Det(void *p) { delete ((::Det*)p); } static void deleteArray_Det(void *p) { delete [] ((::Det*)p); } static void destruct_Det(void *p) { typedef ::Det current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Det namespace ROOT { // Wrapper around operator delete static void delete_DetDim(void *p) { delete ((::DetDim*)p); } static void deleteArray_DetDim(void *p) { delete [] ((::DetDim*)p); } static void destruct_DetDim(void *p) { typedef ::DetDim current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::DetDim namespace ROOT { static TClass *vectorlEPmtgR_Dictionary(); static void vectorlEPmtgR_TClassManip(TClass*); static void *new_vectorlEPmtgR(void *p = 0); static void *newArray_vectorlEPmtgR(Long_t size, void *p); static void delete_vectorlEPmtgR(void *p); static void deleteArray_vectorlEPmtgR(void *p); static void destruct_vectorlEPmtgR(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), &vectorlEPmtgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlEPmtgR); instance.SetNewArray(&newArray_vectorlEPmtgR); instance.SetDelete(&delete_vectorlEPmtgR); instance.SetDeleteArray(&deleteArray_vectorlEPmtgR); instance.SetDestructor(&destruct_vectorlEPmtgR); 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 *vectorlEPmtgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEPmtgR_TClassManip(theClass); return theClass; } static void vectorlEPmtgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEPmtgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEPmtgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEPmtgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEPmtgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEPmtgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *maplEintcOPmtmUgR_Dictionary(); static void maplEintcOPmtmUgR_TClassManip(TClass*); static void *new_maplEintcOPmtmUgR(void *p = 0); static void *newArray_maplEintcOPmtmUgR(Long_t size, void *p); static void delete_maplEintcOPmtmUgR(void *p); static void deleteArray_maplEintcOPmtmUgR(void *p); static void destruct_maplEintcOPmtmUgR(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), &maplEintcOPmtmUgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEintcOPmtmUgR); instance.SetNewArray(&newArray_maplEintcOPmtmUgR); instance.SetDelete(&delete_maplEintcOPmtmUgR); instance.SetDeleteArray(&deleteArray_maplEintcOPmtmUgR); instance.SetDestructor(&destruct_maplEintcOPmtmUgR); 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 *maplEintcOPmtmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEintcOPmtmUgR_TClassManip(theClass); return theClass; } static void maplEintcOPmtmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcOPmtmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcOPmtmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcOPmtmUgR(void *p) { delete ((map*)p); } static void deleteArray_maplEintcOPmtmUgR(void *p) { delete [] ((map*)p); } static void destruct_maplEintcOPmtmUgR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEintcODomgR_Dictionary(); static void maplEintcODomgR_TClassManip(TClass*); static void *new_maplEintcODomgR(void *p = 0); static void *newArray_maplEintcODomgR(Long_t size, void *p); static void delete_maplEintcODomgR(void *p); static void deleteArray_maplEintcODomgR(void *p); static void destruct_maplEintcODomgR(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), &maplEintcODomgR_Dictionary, isa_proxy, 4, sizeof(map) ); instance.SetNew(&new_maplEintcODomgR); instance.SetNewArray(&newArray_maplEintcODomgR); instance.SetDelete(&delete_maplEintcODomgR); instance.SetDeleteArray(&deleteArray_maplEintcODomgR); instance.SetDestructor(&destruct_maplEintcODomgR); 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 *maplEintcODomgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEintcODomgR_TClassManip(theClass); return theClass; } static void maplEintcODomgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcODomgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcODomgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcODomgR(void *p) { delete ((map*)p); } static void deleteArray_maplEintcODomgR(void *p) { delete [] ((map*)p); } static void destruct_maplEintcODomgR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace { void TriggerDictionaryInitialization_DetdOdict_Impl() { static const char* headers[] = { "Det.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/evt/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "DetdOdict 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@@@Det.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Det.hh"))) Dom; namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_pair.h"))) __attribute__((annotate("$clingAutoload$string"))) pair; } struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Det.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Det.hh"))) Pmt; namespace std{template class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator; } namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_tree.h"))) __attribute__((annotate("$clingAutoload$Det.hh"))) _Rb_tree_iterator; } namespace std{template struct __attribute__((annotate("$clingAutoload$bits/stl_function.h"))) __attribute__((annotate("$clingAutoload$string"))) less; } struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Det.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Det.hh"))) Det; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Det.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Det.hh"))) DetDim; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "DetdOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "Det.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "Det", payloadCode, "@", "Det::fgIsA", payloadCode, "@", "DetDim", payloadCode, "@", "Dom", payloadCode, "@", "Dom::fgIsA", payloadCode, "@", "Pmt", payloadCode, "@", "Pmt::fgIsA", payloadCode, "@", "get_dist_to_edge", payloadCode, "@", "read", payloadCode, "@", "read_detfile_det", payloadCode, "@", "read_detfile_detx", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("Det.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_DetdOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_DetdOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_DetdOdict() { TriggerDictionaryInitialization_DetdOdict_Impl(); }