// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIJsonDumperdOdict #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 "JsonDumper.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *JsonDumper_Dictionary(); static void JsonDumper_TClassManip(TClass*); static void *new_JsonDumper(void *p = 0); static void *newArray_JsonDumper(Long_t size, void *p); static void delete_JsonDumper(void *p); static void deleteArray_JsonDumper(void *p); static void destruct_JsonDumper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JsonDumper*) { ::JsonDumper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JsonDumper)); static ::ROOT::TGenericClassInfo instance("JsonDumper", "JsonDumper.hh", 30, typeid(::JsonDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JsonDumper_Dictionary, isa_proxy, 4, sizeof(::JsonDumper) ); instance.SetNew(&new_JsonDumper); instance.SetNewArray(&newArray_JsonDumper); instance.SetDelete(&delete_JsonDumper); instance.SetDeleteArray(&deleteArray_JsonDumper); instance.SetDestructor(&destruct_JsonDumper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JsonDumper*) { return GenerateInitInstanceLocal((::JsonDumper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JsonDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JsonDumper_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JsonDumper*)0x0)->GetClass(); JsonDumper_TClassManip(theClass); return theClass; } static void JsonDumper_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *JsonDumpercLcL_TDump_Dictionary(); static void JsonDumpercLcL_TDump_TClassManip(TClass*); static void delete_JsonDumpercLcL_TDump(void *p); static void deleteArray_JsonDumpercLcL_TDump(void *p); static void destruct_JsonDumpercLcL_TDump(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JsonDumper::_TDump*) { ::JsonDumper::_TDump *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JsonDumper::_TDump)); static ::ROOT::TGenericClassInfo instance("JsonDumper::_TDump", "JsonDumper.hh", 129, typeid(::JsonDumper::_TDump), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JsonDumpercLcL_TDump_Dictionary, isa_proxy, 4, sizeof(::JsonDumper::_TDump) ); instance.SetDelete(&delete_JsonDumpercLcL_TDump); instance.SetDeleteArray(&deleteArray_JsonDumpercLcL_TDump); instance.SetDestructor(&destruct_JsonDumpercLcL_TDump); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JsonDumper::_TDump*) { return GenerateInitInstanceLocal((::JsonDumper::_TDump*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JsonDumper::_TDump*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JsonDumpercLcL_TDump_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JsonDumper::_TDump*)0x0)->GetClass(); JsonDumpercLcL_TDump_TClassManip(theClass); return theClass; } static void JsonDumpercLcL_TDump_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *CompactJsonDumper_Dictionary(); static void CompactJsonDumper_TClassManip(TClass*); static void *new_CompactJsonDumper(void *p = 0); static void *newArray_CompactJsonDumper(Long_t size, void *p); static void delete_CompactJsonDumper(void *p); static void deleteArray_CompactJsonDumper(void *p); static void destruct_CompactJsonDumper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::CompactJsonDumper*) { ::CompactJsonDumper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::CompactJsonDumper)); static ::ROOT::TGenericClassInfo instance("CompactJsonDumper", "JsonDumper.hh", 237, typeid(::CompactJsonDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &CompactJsonDumper_Dictionary, isa_proxy, 4, sizeof(::CompactJsonDumper) ); instance.SetNew(&new_CompactJsonDumper); instance.SetNewArray(&newArray_CompactJsonDumper); instance.SetDelete(&delete_CompactJsonDumper); instance.SetDeleteArray(&deleteArray_CompactJsonDumper); instance.SetDestructor(&destruct_CompactJsonDumper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::CompactJsonDumper*) { return GenerateInitInstanceLocal((::CompactJsonDumper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CompactJsonDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *CompactJsonDumper_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::CompactJsonDumper*)0x0)->GetClass(); CompactJsonDumper_TClassManip(theClass); return theClass; } static void CompactJsonDumper_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Dumper_Dictionary(); static void Dumper_TClassManip(TClass*); static void *new_Dumper(void *p = 0); static void *newArray_Dumper(Long_t size, void *p); static void delete_Dumper(void *p); static void deleteArray_Dumper(void *p); static void destruct_Dumper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Dumper*) { ::Dumper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Dumper)); static ::ROOT::TGenericClassInfo instance("Dumper", "JsonDumper.hh", 245, typeid(::Dumper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Dumper_Dictionary, isa_proxy, 4, sizeof(::Dumper) ); instance.SetNew(&new_Dumper); instance.SetNewArray(&newArray_Dumper); instance.SetDelete(&delete_Dumper); instance.SetDeleteArray(&deleteArray_Dumper); instance.SetDestructor(&destruct_Dumper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Dumper*) { return GenerateInitInstanceLocal((::Dumper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Dumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Dumper_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Dumper*)0x0)->GetClass(); Dumper_TClassManip(theClass); return theClass; } static void Dumper_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *DumpercLcL_TDump_Dictionary(); static void DumpercLcL_TDump_TClassManip(TClass*); static void delete_DumpercLcL_TDump(void *p); static void deleteArray_DumpercLcL_TDump(void *p); static void destruct_DumpercLcL_TDump(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Dumper::_TDump*) { ::Dumper::_TDump *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Dumper::_TDump)); static ::ROOT::TGenericClassInfo instance("Dumper::_TDump", "JsonDumper.hh", 277, typeid(::Dumper::_TDump), ::ROOT::Internal::DefineBehavior(ptr, ptr), &DumpercLcL_TDump_Dictionary, isa_proxy, 4, sizeof(::Dumper::_TDump) ); instance.SetDelete(&delete_DumpercLcL_TDump); instance.SetDeleteArray(&deleteArray_DumpercLcL_TDump); instance.SetDestructor(&destruct_DumpercLcL_TDump); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Dumper::_TDump*) { return GenerateInitInstanceLocal((::Dumper::_TDump*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Dumper::_TDump*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *DumpercLcL_TDump_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Dumper::_TDump*)0x0)->GetClass(); DumpercLcL_TDump_TClassManip(theClass); return theClass; } static void DumpercLcL_TDump_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *StdoutDumper_Dictionary(); static void StdoutDumper_TClassManip(TClass*); static void *new_StdoutDumper(void *p = 0); static void *newArray_StdoutDumper(Long_t size, void *p); static void delete_StdoutDumper(void *p); static void deleteArray_StdoutDumper(void *p); static void destruct_StdoutDumper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::StdoutDumper*) { ::StdoutDumper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::StdoutDumper)); static ::ROOT::TGenericClassInfo instance("StdoutDumper", "JsonDumper.hh", 343, typeid(::StdoutDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &StdoutDumper_Dictionary, isa_proxy, 4, sizeof(::StdoutDumper) ); instance.SetNew(&new_StdoutDumper); instance.SetNewArray(&newArray_StdoutDumper); instance.SetDelete(&delete_StdoutDumper); instance.SetDeleteArray(&deleteArray_StdoutDumper); instance.SetDestructor(&destruct_StdoutDumper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::StdoutDumper*) { return GenerateInitInstanceLocal((::StdoutDumper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::StdoutDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *StdoutDumper_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::StdoutDumper*)0x0)->GetClass(); StdoutDumper_TClassManip(theClass); return theClass; } static void StdoutDumper_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JsonDumper.hh"); } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_JsonDumper(void *p) { return p ? new(p) ::JsonDumper : new ::JsonDumper; } static void *newArray_JsonDumper(Long_t nElements, void *p) { return p ? new(p) ::JsonDumper[nElements] : new ::JsonDumper[nElements]; } // Wrapper around operator delete static void delete_JsonDumper(void *p) { delete ((::JsonDumper*)p); } static void deleteArray_JsonDumper(void *p) { delete [] ((::JsonDumper*)p); } static void destruct_JsonDumper(void *p) { typedef ::JsonDumper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JsonDumper namespace ROOT { // Wrapper around operator delete static void delete_JsonDumpercLcL_TDump(void *p) { delete ((::JsonDumper::_TDump*)p); } static void deleteArray_JsonDumpercLcL_TDump(void *p) { delete [] ((::JsonDumper::_TDump*)p); } static void destruct_JsonDumpercLcL_TDump(void *p) { typedef ::JsonDumper::_TDump current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JsonDumper::_TDump namespace ROOT { // Wrappers around operator new static void *new_CompactJsonDumper(void *p) { return p ? new(p) ::CompactJsonDumper : new ::CompactJsonDumper; } static void *newArray_CompactJsonDumper(Long_t nElements, void *p) { return p ? new(p) ::CompactJsonDumper[nElements] : new ::CompactJsonDumper[nElements]; } // Wrapper around operator delete static void delete_CompactJsonDumper(void *p) { delete ((::CompactJsonDumper*)p); } static void deleteArray_CompactJsonDumper(void *p) { delete [] ((::CompactJsonDumper*)p); } static void destruct_CompactJsonDumper(void *p) { typedef ::CompactJsonDumper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::CompactJsonDumper namespace ROOT { // Wrappers around operator new static void *new_Dumper(void *p) { return p ? new(p) ::Dumper : new ::Dumper; } static void *newArray_Dumper(Long_t nElements, void *p) { return p ? new(p) ::Dumper[nElements] : new ::Dumper[nElements]; } // Wrapper around operator delete static void delete_Dumper(void *p) { delete ((::Dumper*)p); } static void deleteArray_Dumper(void *p) { delete [] ((::Dumper*)p); } static void destruct_Dumper(void *p) { typedef ::Dumper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Dumper namespace ROOT { // Wrapper around operator delete static void delete_DumpercLcL_TDump(void *p) { delete ((::Dumper::_TDump*)p); } static void deleteArray_DumpercLcL_TDump(void *p) { delete [] ((::Dumper::_TDump*)p); } static void destruct_DumpercLcL_TDump(void *p) { typedef ::Dumper::_TDump current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Dumper::_TDump namespace ROOT { // Wrappers around operator new static void *new_StdoutDumper(void *p) { return p ? new(p) ::StdoutDumper : new ::StdoutDumper; } static void *newArray_StdoutDumper(Long_t nElements, void *p) { return p ? new(p) ::StdoutDumper[nElements] : new ::StdoutDumper[nElements]; } // Wrapper around operator delete static void delete_StdoutDumper(void *p) { delete ((::StdoutDumper*)p); } static void deleteArray_StdoutDumper(void *p) { delete [] ((::StdoutDumper*)p); } static void destruct_StdoutDumper(void *p) { typedef ::StdoutDumper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::StdoutDumper 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 { void TriggerDictionaryInitialization_JsonDumperdOdict_Impl() { static const char* headers[] = { "JsonDumper.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/evt/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "JsonDumperdOdict 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@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh"))) JsonDumper; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh"))) CompactJsonDumper; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh"))) Dumper; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh"))) StdoutDumper; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "JsonDumperdOdict dictionary payload" #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "JsonDumper.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "CompactJsonDumper", payloadCode, "@", "Dumper", payloadCode, "@", "JsonDumper", payloadCode, "@", "StdoutDumper", payloadCode, "@", "jsons", payloadCode, "@", "write_aa3d", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("JsonDumper.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_JsonDumperdOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_JsonDumperdOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_JsonDumperdOdict() { TriggerDictionaryInitialization_JsonDumperdOdict_Impl(); }