// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIEventFiledOdict #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 "EventFile.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *BaseEventFile_Dictionary(); static void BaseEventFile_TClassManip(TClass*); static void delete_BaseEventFile(void *p); static void deleteArray_BaseEventFile(void *p); static void destruct_BaseEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::BaseEventFile*) { ::BaseEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BaseEventFile)); static ::ROOT::TGenericClassInfo instance("BaseEventFile", "EventFile.hh", 38, typeid(::BaseEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &BaseEventFile_Dictionary, isa_proxy, 4, sizeof(::BaseEventFile) ); instance.SetDelete(&delete_BaseEventFile); instance.SetDeleteArray(&deleteArray_BaseEventFile); instance.SetDestructor(&destruct_BaseEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::BaseEventFile*) { return GenerateInitInstanceLocal((::BaseEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::BaseEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *BaseEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::BaseEventFile*)0x0)->GetClass(); BaseEventFile_TClassManip(theClass); return theClass; } static void BaseEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *CachelEEvtgR_Dictionary(); static void CachelEEvtgR_TClassManip(TClass*); static void *new_CachelEEvtgR(void *p = 0); static void *newArray_CachelEEvtgR(Long_t size, void *p); static void delete_CachelEEvtgR(void *p); static void deleteArray_CachelEEvtgR(void *p); static void destruct_CachelEEvtgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Cache*) { ::Cache *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Cache)); static ::ROOT::TGenericClassInfo instance("Cache", "EventFile.hh", 110, typeid(::Cache), ::ROOT::Internal::DefineBehavior(ptr, ptr), &CachelEEvtgR_Dictionary, isa_proxy, 4, sizeof(::Cache) ); instance.SetNew(&new_CachelEEvtgR); instance.SetNewArray(&newArray_CachelEEvtgR); instance.SetDelete(&delete_CachelEEvtgR); instance.SetDeleteArray(&deleteArray_CachelEEvtgR); instance.SetDestructor(&destruct_CachelEEvtgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Cache*) { return GenerateInitInstanceLocal((::Cache*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Cache*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *CachelEEvtgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Cache*)0x0)->GetClass(); CachelEEvtgR_TClassManip(theClass); return theClass; } static void CachelEEvtgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *AsciiEventFile_Dictionary(); static void AsciiEventFile_TClassManip(TClass*); static void delete_AsciiEventFile(void *p); static void deleteArray_AsciiEventFile(void *p); static void destruct_AsciiEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::AsciiEventFile*) { ::AsciiEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AsciiEventFile)); static ::ROOT::TGenericClassInfo instance("AsciiEventFile", "EventFile.hh", 167, typeid(::AsciiEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &AsciiEventFile_Dictionary, isa_proxy, 4, sizeof(::AsciiEventFile) ); instance.SetDelete(&delete_AsciiEventFile); instance.SetDeleteArray(&deleteArray_AsciiEventFile); instance.SetDestructor(&destruct_AsciiEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::AsciiEventFile*) { return GenerateInitInstanceLocal((::AsciiEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AsciiEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *AsciiEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AsciiEventFile*)0x0)->GetClass(); AsciiEventFile_TClassManip(theClass); return theClass; } static void AsciiEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *EvtEventFile_Dictionary(); static void EvtEventFile_TClassManip(TClass*); static void *new_EvtEventFile(void *p = 0); static void *newArray_EvtEventFile(Long_t size, void *p); static void delete_EvtEventFile(void *p); static void deleteArray_EvtEventFile(void *p); static void destruct_EvtEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::EvtEventFile*) { ::EvtEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EvtEventFile)); static ::ROOT::TGenericClassInfo instance("EvtEventFile", "EventFile.hh", 286, typeid(::EvtEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &EvtEventFile_Dictionary, isa_proxy, 4, sizeof(::EvtEventFile) ); instance.SetNew(&new_EvtEventFile); instance.SetNewArray(&newArray_EvtEventFile); instance.SetDelete(&delete_EvtEventFile); instance.SetDeleteArray(&deleteArray_EvtEventFile); instance.SetDestructor(&destruct_EvtEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::EvtEventFile*) { return GenerateInitInstanceLocal((::EvtEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::EvtEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *EvtEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::EvtEventFile*)0x0)->GetClass(); EvtEventFile_TClassManip(theClass); return theClass; } static void EvtEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *RootEventFile_Dictionary(); static void RootEventFile_TClassManip(TClass*); static void *new_RootEventFile(void *p = 0); static void *newArray_RootEventFile(Long_t size, void *p); static void delete_RootEventFile(void *p); static void deleteArray_RootEventFile(void *p); static void destruct_RootEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RootEventFile*) { ::RootEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RootEventFile)); static ::ROOT::TGenericClassInfo instance("RootEventFile", "EventFile.hh", 338, typeid(::RootEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RootEventFile_Dictionary, isa_proxy, 4, sizeof(::RootEventFile) ); instance.SetNew(&new_RootEventFile); instance.SetNewArray(&newArray_RootEventFile); instance.SetDelete(&delete_RootEventFile); instance.SetDeleteArray(&deleteArray_RootEventFile); instance.SetDestructor(&destruct_RootEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RootEventFile*) { return GenerateInitInstanceLocal((::RootEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::RootEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RootEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::RootEventFile*)0x0)->GetClass(); RootEventFile_TClassManip(theClass); return theClass; } static void RootEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *JFitEventFile_Dictionary(); static void JFitEventFile_TClassManip(TClass*); static void *new_JFitEventFile(void *p = 0); static void *newArray_JFitEventFile(Long_t size, void *p); static void delete_JFitEventFile(void *p); static void deleteArray_JFitEventFile(void *p); static void destruct_JFitEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JFitEventFile*) { ::JFitEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JFitEventFile)); static ::ROOT::TGenericClassInfo instance("JFitEventFile", "EventFile.hh", 524, typeid(::JFitEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JFitEventFile_Dictionary, isa_proxy, 4, sizeof(::JFitEventFile) ); instance.SetNew(&new_JFitEventFile); instance.SetNewArray(&newArray_JFitEventFile); instance.SetDelete(&delete_JFitEventFile); instance.SetDeleteArray(&deleteArray_JFitEventFile); instance.SetDestructor(&destruct_JFitEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JFitEventFile*) { return GenerateInitInstanceLocal((::JFitEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JFitEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JFitEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JFitEventFile*)0x0)->GetClass(); JFitEventFile_TClassManip(theClass); return theClass; } static void JFitEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *JppEventFile_Dictionary(); static void JppEventFile_TClassManip(TClass*); static void *new_JppEventFile(void *p = 0); static void *newArray_JppEventFile(Long_t size, void *p); static void delete_JppEventFile(void *p); static void deleteArray_JppEventFile(void *p); static void destruct_JppEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JppEventFile*) { ::JppEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JppEventFile)); static ::ROOT::TGenericClassInfo instance("JppEventFile", "EventFile.hh", 550, typeid(::JppEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JppEventFile_Dictionary, isa_proxy, 4, sizeof(::JppEventFile) ); instance.SetNew(&new_JppEventFile); instance.SetNewArray(&newArray_JppEventFile); instance.SetDelete(&delete_JppEventFile); instance.SetDeleteArray(&deleteArray_JppEventFile); instance.SetDestructor(&destruct_JppEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JppEventFile*) { return GenerateInitInstanceLocal((::JppEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JppEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JppEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JppEventFile*)0x0)->GetClass(); JppEventFile_TClassManip(theClass); return theClass; } static void JppEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *JppTimesliceFile_Dictionary(); static void JppTimesliceFile_TClassManip(TClass*); static void *new_JppTimesliceFile(void *p = 0); static void *newArray_JppTimesliceFile(Long_t size, void *p); static void delete_JppTimesliceFile(void *p); static void deleteArray_JppTimesliceFile(void *p); static void destruct_JppTimesliceFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JppTimesliceFile*) { ::JppTimesliceFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JppTimesliceFile)); static ::ROOT::TGenericClassInfo instance("JppTimesliceFile", "EventFile.hh", 575, typeid(::JppTimesliceFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JppTimesliceFile_Dictionary, isa_proxy, 4, sizeof(::JppTimesliceFile) ); instance.SetNew(&new_JppTimesliceFile); instance.SetNewArray(&newArray_JppTimesliceFile); instance.SetDelete(&delete_JppTimesliceFile); instance.SetDeleteArray(&deleteArray_JppTimesliceFile); instance.SetDestructor(&destruct_JppTimesliceFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JppTimesliceFile*) { return GenerateInitInstanceLocal((::JppTimesliceFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JppTimesliceFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JppTimesliceFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JppTimesliceFile*)0x0)->GetClass(); JppTimesliceFile_TClassManip(theClass); return theClass; } static void JppTimesliceFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *AaEventFile_Dictionary(); static void AaEventFile_TClassManip(TClass*); static void *new_AaEventFile(void *p = 0); static void *newArray_AaEventFile(Long_t size, void *p); static void delete_AaEventFile(void *p); static void deleteArray_AaEventFile(void *p); static void destruct_AaEventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::AaEventFile*) { ::AaEventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AaEventFile)); static ::ROOT::TGenericClassInfo instance("AaEventFile", "EventFile.hh", 605, typeid(::AaEventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &AaEventFile_Dictionary, isa_proxy, 4, sizeof(::AaEventFile) ); instance.SetNew(&new_AaEventFile); instance.SetNewArray(&newArray_AaEventFile); instance.SetDelete(&delete_AaEventFile); instance.SetDeleteArray(&deleteArray_AaEventFile); instance.SetDestructor(&destruct_AaEventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::AaEventFile*) { return GenerateInitInstanceLocal((::AaEventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AaEventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *AaEventFile_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AaEventFile*)0x0)->GetClass(); AaEventFile_TClassManip(theClass); return theClass; } static void AaEventFile_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","EventFile.hh"); } } // end of namespace ROOT namespace ROOT { static void *new_EventFile(void *p = 0); static void *newArray_EventFile(Long_t size, void *p); static void delete_EventFile(void *p); static void deleteArray_EventFile(void *p); static void destruct_EventFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventFile*) { ::EventFile *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventFile >(0); static ::ROOT::TGenericClassInfo instance("EventFile", ::EventFile::Class_Version(), "EventFile.hh", 707, typeid(::EventFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::EventFile::Dictionary, isa_proxy, 4, sizeof(::EventFile) ); instance.SetNew(&new_EventFile); instance.SetNewArray(&newArray_EventFile); instance.SetDelete(&delete_EventFile); instance.SetDeleteArray(&deleteArray_EventFile); instance.SetDestructor(&destruct_EventFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::EventFile*) { return GenerateInitInstanceLocal((::EventFile*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::EventFile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void delete_EventFilecLcLiterator(void *p); static void deleteArray_EventFilecLcLiterator(void *p); static void destruct_EventFilecLcLiterator(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventFile::iterator*) { ::EventFile::iterator *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventFile::iterator >(0); static ::ROOT::TGenericClassInfo instance("EventFile::iterator", ::EventFile::iterator::Class_Version(), "EventFile.hh", 846, typeid(::EventFile::iterator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::EventFile::iterator::Dictionary, isa_proxy, 4, sizeof(::EventFile::iterator) ); instance.SetDelete(&delete_EventFilecLcLiterator); instance.SetDeleteArray(&deleteArray_EventFilecLcLiterator); instance.SetDestructor(&destruct_EventFilecLcLiterator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::EventFile::iterator*) { return GenerateInitInstanceLocal((::EventFile::iterator*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::EventFile::iterator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr EventFile::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *EventFile::Class_Name() { return "EventFile"; } //______________________________________________________________________________ const char *EventFile::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::EventFile*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int EventFile::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::EventFile*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EventFile::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventFile*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EventFile::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventFile*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr EventFile::iterator::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *EventFile::iterator::Class_Name() { return "EventFile::iterator"; } //______________________________________________________________________________ const char *EventFile::iterator::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::EventFile::iterator*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int EventFile::iterator::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::EventFile::iterator*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EventFile::iterator::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventFile::iterator*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EventFile::iterator::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventFile::iterator*)0x0)->GetClass(); } return fgIsA; } namespace ROOT { // Wrapper around operator delete static void delete_BaseEventFile(void *p) { delete ((::BaseEventFile*)p); } static void deleteArray_BaseEventFile(void *p) { delete [] ((::BaseEventFile*)p); } static void destruct_BaseEventFile(void *p) { typedef ::BaseEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::BaseEventFile namespace ROOT { // Wrappers around operator new static void *new_CachelEEvtgR(void *p) { return p ? new(p) ::Cache : new ::Cache; } static void *newArray_CachelEEvtgR(Long_t nElements, void *p) { return p ? new(p) ::Cache[nElements] : new ::Cache[nElements]; } // Wrapper around operator delete static void delete_CachelEEvtgR(void *p) { delete ((::Cache*)p); } static void deleteArray_CachelEEvtgR(void *p) { delete [] ((::Cache*)p); } static void destruct_CachelEEvtgR(void *p) { typedef ::Cache current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Cache namespace ROOT { // Wrapper around operator delete static void delete_AsciiEventFile(void *p) { delete ((::AsciiEventFile*)p); } static void deleteArray_AsciiEventFile(void *p) { delete [] ((::AsciiEventFile*)p); } static void destruct_AsciiEventFile(void *p) { typedef ::AsciiEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::AsciiEventFile namespace ROOT { // Wrappers around operator new static void *new_EvtEventFile(void *p) { return p ? new(p) ::EvtEventFile : new ::EvtEventFile; } static void *newArray_EvtEventFile(Long_t nElements, void *p) { return p ? new(p) ::EvtEventFile[nElements] : new ::EvtEventFile[nElements]; } // Wrapper around operator delete static void delete_EvtEventFile(void *p) { delete ((::EvtEventFile*)p); } static void deleteArray_EvtEventFile(void *p) { delete [] ((::EvtEventFile*)p); } static void destruct_EvtEventFile(void *p) { typedef ::EvtEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::EvtEventFile namespace ROOT { // Wrappers around operator new static void *new_RootEventFile(void *p) { return p ? new(p) ::RootEventFile : new ::RootEventFile; } static void *newArray_RootEventFile(Long_t nElements, void *p) { return p ? new(p) ::RootEventFile[nElements] : new ::RootEventFile[nElements]; } // Wrapper around operator delete static void delete_RootEventFile(void *p) { delete ((::RootEventFile*)p); } static void deleteArray_RootEventFile(void *p) { delete [] ((::RootEventFile*)p); } static void destruct_RootEventFile(void *p) { typedef ::RootEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::RootEventFile namespace ROOT { // Wrappers around operator new static void *new_JFitEventFile(void *p) { return p ? new(p) ::JFitEventFile : new ::JFitEventFile; } static void *newArray_JFitEventFile(Long_t nElements, void *p) { return p ? new(p) ::JFitEventFile[nElements] : new ::JFitEventFile[nElements]; } // Wrapper around operator delete static void delete_JFitEventFile(void *p) { delete ((::JFitEventFile*)p); } static void deleteArray_JFitEventFile(void *p) { delete [] ((::JFitEventFile*)p); } static void destruct_JFitEventFile(void *p) { typedef ::JFitEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JFitEventFile namespace ROOT { // Wrappers around operator new static void *new_JppEventFile(void *p) { return p ? new(p) ::JppEventFile : new ::JppEventFile; } static void *newArray_JppEventFile(Long_t nElements, void *p) { return p ? new(p) ::JppEventFile[nElements] : new ::JppEventFile[nElements]; } // Wrapper around operator delete static void delete_JppEventFile(void *p) { delete ((::JppEventFile*)p); } static void deleteArray_JppEventFile(void *p) { delete [] ((::JppEventFile*)p); } static void destruct_JppEventFile(void *p) { typedef ::JppEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JppEventFile namespace ROOT { // Wrappers around operator new static void *new_JppTimesliceFile(void *p) { return p ? new(p) ::JppTimesliceFile : new ::JppTimesliceFile; } static void *newArray_JppTimesliceFile(Long_t nElements, void *p) { return p ? new(p) ::JppTimesliceFile[nElements] : new ::JppTimesliceFile[nElements]; } // Wrapper around operator delete static void delete_JppTimesliceFile(void *p) { delete ((::JppTimesliceFile*)p); } static void deleteArray_JppTimesliceFile(void *p) { delete [] ((::JppTimesliceFile*)p); } static void destruct_JppTimesliceFile(void *p) { typedef ::JppTimesliceFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JppTimesliceFile namespace ROOT { // Wrappers around operator new static void *new_AaEventFile(void *p) { return p ? new(p) ::AaEventFile : new ::AaEventFile; } static void *newArray_AaEventFile(Long_t nElements, void *p) { return p ? new(p) ::AaEventFile[nElements] : new ::AaEventFile[nElements]; } // Wrapper around operator delete static void delete_AaEventFile(void *p) { delete ((::AaEventFile*)p); } static void deleteArray_AaEventFile(void *p) { delete [] ((::AaEventFile*)p); } static void destruct_AaEventFile(void *p) { typedef ::AaEventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::AaEventFile //______________________________________________________________________________ void EventFile::Streamer(TBuffer &R__b) { // Stream an object of class EventFile. if (R__b.IsReading()) { R__b.ReadClassBuffer(EventFile::Class(),this); } else { R__b.WriteClassBuffer(EventFile::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_EventFile(void *p) { return p ? new(p) ::EventFile : new ::EventFile; } static void *newArray_EventFile(Long_t nElements, void *p) { return p ? new(p) ::EventFile[nElements] : new ::EventFile[nElements]; } // Wrapper around operator delete static void delete_EventFile(void *p) { delete ((::EventFile*)p); } static void deleteArray_EventFile(void *p) { delete [] ((::EventFile*)p); } static void destruct_EventFile(void *p) { typedef ::EventFile current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::EventFile //______________________________________________________________________________ void EventFile::iterator::Streamer(TBuffer &R__b) { // Stream an object of class EventFile::iterator. if (R__b.IsReading()) { R__b.ReadClassBuffer(EventFile::iterator::Class(),this); } else { R__b.WriteClassBuffer(EventFile::iterator::Class(),this); } } namespace ROOT { // Wrapper around operator delete static void delete_EventFilecLcLiterator(void *p) { delete ((::EventFile::iterator*)p); } static void deleteArray_EventFilecLcLiterator(void *p) { delete [] ((::EventFile::iterator*)p); } static void destruct_EventFilecLcLiterator(void *p) { typedef ::EventFile::iterator current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::EventFile::iterator namespace ROOT { static TClass *vectorlEstringgR_Dictionary(); static void vectorlEstringgR_TClassManip(TClass*); static void *new_vectorlEstringgR(void *p = 0); static void *newArray_vectorlEstringgR(Long_t size, void *p); static void delete_vectorlEstringgR(void *p); static void deleteArray_vectorlEstringgR(void *p); static void destruct_vectorlEstringgR(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), &vectorlEstringgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEstringgR); instance.SetNewArray(&newArray_vectorlEstringgR); instance.SetDelete(&delete_vectorlEstringgR); instance.SetDeleteArray(&deleteArray_vectorlEstringgR); instance.SetDestructor(&destruct_vectorlEstringgR); 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 *vectorlEstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEstringgR_TClassManip(theClass); return theClass; } static void vectorlEstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEstringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEstringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEstringgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEstringgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEstringgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector 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 ROOT { static TClass *vectorlETObjectmUgR_Dictionary(); static void vectorlETObjectmUgR_TClassManip(TClass*); static void *new_vectorlETObjectmUgR(void *p = 0); static void *newArray_vectorlETObjectmUgR(Long_t size, void *p); static void delete_vectorlETObjectmUgR(void *p); static void deleteArray_vectorlETObjectmUgR(void *p); static void destruct_vectorlETObjectmUgR(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), &vectorlETObjectmUgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETObjectmUgR); instance.SetNewArray(&newArray_vectorlETObjectmUgR); instance.SetDelete(&delete_vectorlETObjectmUgR); instance.SetDeleteArray(&deleteArray_vectorlETObjectmUgR); instance.SetDestructor(&destruct_vectorlETObjectmUgR); 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 *vectorlETObjectmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlETObjectmUgR_TClassManip(theClass); return theClass; } static void vectorlETObjectmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETObjectmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETObjectmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETObjectmUgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlETObjectmUgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlETObjectmUgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *maplEintcOfposlE__mbstate_tgRsPgR_Dictionary(); static void maplEintcOfposlE__mbstate_tgRsPgR_TClassManip(TClass*); static void *new_maplEintcOfposlE__mbstate_tgRsPgR(void *p = 0); static void *newArray_maplEintcOfposlE__mbstate_tgRsPgR(Long_t size, void *p); static void delete_maplEintcOfposlE__mbstate_tgRsPgR(void *p); static void deleteArray_maplEintcOfposlE__mbstate_tgRsPgR(void *p); static void destruct_maplEintcOfposlE__mbstate_tgRsPgR(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), &maplEintcOfposlE__mbstate_tgRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEintcOfposlE__mbstate_tgRsPgR); instance.SetNewArray(&newArray_maplEintcOfposlE__mbstate_tgRsPgR); instance.SetDelete(&delete_maplEintcOfposlE__mbstate_tgRsPgR); instance.SetDeleteArray(&deleteArray_maplEintcOfposlE__mbstate_tgRsPgR); instance.SetDestructor(&destruct_maplEintcOfposlE__mbstate_tgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::less, 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 *maplEintcOfposlE__mbstate_tgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map >*)0x0)->GetClass(); maplEintcOfposlE__mbstate_tgRsPgR_TClassManip(theClass); return theClass; } static void maplEintcOfposlE__mbstate_tgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcOfposlE__mbstate_tgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEintcOfposlE__mbstate_tgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEintcOfposlE__mbstate_tgRsPgR(void *p) { delete ((map >*)p); } static void deleteArray_maplEintcOfposlE__mbstate_tgRsPgR(void *p) { delete [] ((map >*)p); } static void destruct_maplEintcOfposlE__mbstate_tgRsPgR(void *p) { typedef map > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEintcOEvtgR_Dictionary(); static void maplEintcOEvtgR_TClassManip(TClass*); static void *new_maplEintcOEvtgR(void *p = 0); static void *newArray_maplEintcOEvtgR(Long_t size, void *p); static void delete_maplEintcOEvtgR(void *p); static void deleteArray_maplEintcOEvtgR(void *p); static void destruct_maplEintcOEvtgR(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), &maplEintcOEvtgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEintcOEvtgR); instance.SetNewArray(&newArray_maplEintcOEvtgR); instance.SetDelete(&delete_maplEintcOEvtgR); instance.SetDeleteArray(&deleteArray_maplEintcOEvtgR); instance.SetDestructor(&destruct_maplEintcOEvtgR); 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 *maplEintcOEvtgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map*)0x0)->GetClass(); maplEintcOEvtgR_TClassManip(theClass); return theClass; } static void maplEintcOEvtgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcOEvtgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcOEvtgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcOEvtgR(void *p) { delete ((map*)p); } static void deleteArray_maplEintcOEvtgR(void *p) { delete [] ((map*)p); } static void destruct_maplEintcOEvtgR(void *p) { typedef map current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *listlEintgR_Dictionary(); static void listlEintgR_TClassManip(TClass*); static void *new_listlEintgR(void *p = 0); static void *newArray_listlEintgR(Long_t size, void *p); static void delete_listlEintgR(void *p); static void deleteArray_listlEintgR(void *p); static void destruct_listlEintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const list*) { list *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list)); static ::ROOT::TGenericClassInfo instance("list", -2, "list", 438, typeid(list), ::ROOT::Internal::DefineBehavior(ptr, ptr), &listlEintgR_Dictionary, isa_proxy, 0, sizeof(list) ); instance.SetNew(&new_listlEintgR); instance.SetNewArray(&newArray_listlEintgR); instance.SetDelete(&delete_listlEintgR); instance.SetDeleteArray(&deleteArray_listlEintgR); instance.SetDestructor(&destruct_listlEintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list >())); ::ROOT::AddClassAlternate("list","std::list >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const list*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *listlEintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const list*)0x0)->GetClass(); listlEintgR_TClassManip(theClass); return theClass; } static void listlEintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_listlEintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list : new list; } static void *newArray_listlEintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list[nElements] : new list[nElements]; } // Wrapper around operator delete static void delete_listlEintgR(void *p) { delete ((list*)p); } static void deleteArray_listlEintgR(void *p) { delete [] ((list*)p); } static void destruct_listlEintgR(void *p) { typedef list current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class list namespace { void TriggerDictionaryInitialization_EventFiledOdict_Impl() { static const char* headers[] = { "EventFile.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 "EventFiledOdict 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@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) BaseEventFile; struct __attribute__((annotate("$clingAutoload$Evt.hh"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) Evt; template struct __attribute__((annotate("$clingAutoload$EventFile.hh"))) Cache; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) AsciiEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) EvtEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) RootEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) JFitEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) JppEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) JppTimesliceFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) AaEventFile; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@EventFile.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$EventFile.hh"))) EventFile; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "EventFiledOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "EventFile.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "AaEventFile", payloadCode, "@", "AsciiEventFile", payloadCode, "@", "BaseEventFile", payloadCode, "@", "Cache", payloadCode, "@", "EventFile", payloadCode, "@", "EventFile::fgIsA", payloadCode, "@", "EventFile::iterator::fgIsA", payloadCode, "@", "EventFile::read_timeslices", payloadCode, "@", "EventFile::stagedir", payloadCode, "@", "EventFile::timeslice_treename", payloadCode, "@", "EvtEventFile", payloadCode, "@", "JFitEventFile", payloadCode, "@", "JppEventFile", payloadCode, "@", "JppTimesliceFile", payloadCode, "@", "RootEventFile", payloadCode, "@", "prepare_summary_frame", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("EventFile.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_EventFiledOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_EventFiledOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_EventFiledOdict() { TriggerDictionaryInitialization_EventFiledOdict_Impl(); }