// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIaadOdict #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 "aa.hh" // Header files passed via #pragma extra_include namespace aa { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *aa_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("aa", 0 /*version*/, "constants.hh", 7, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &aa_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *aa_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace valimpl { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *valimpl_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("valimpl", 0 /*version*/, "Table.hh", 16, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &valimpl_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimpl_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace cling { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *cling_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("cling", 0 /*version*/, "cling/Interpreter/RuntimeUniverse.h", 28, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &cling_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *cling_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace aa_legacy_timer { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *aa_legacy_timer_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("aa_legacy_timer", 0 /*version*/, "rootutil.hh", 419, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &aa_legacy_timer_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *aa_legacy_timer_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ticktimer { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *ticktimer_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("ticktimer", 0 /*version*/, "rootutil.hh", 530, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &ticktimer_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ticktimer_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace rec_types { namespace ROOT { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *rec_types_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("rec_types", 0 /*version*/, "rec_types.hh", 4, ::ROOT::Internal::DefineBehavior((void*)0,(void*)0), &rec_types_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *rec_types_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ROOT { static TClass *valimplcLcLValue_imp_base_Dictionary(); static void valimplcLcLValue_imp_base_TClassManip(TClass*); static void delete_valimplcLcLValue_imp_base(void *p); static void deleteArray_valimplcLcLValue_imp_base(void *p); static void destruct_valimplcLcLValue_imp_base(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp_base*) { ::valimpl::Value_imp_base *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp_base)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp_base", "Table.hh", 18, typeid(::valimpl::Value_imp_base), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_imp_base_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp_base) ); instance.SetDelete(&delete_valimplcLcLValue_imp_base); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_imp_base); instance.SetDestructor(&destruct_valimplcLcLValue_imp_base); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp_base*) { return GenerateInitInstanceLocal((::valimpl::Value_imp_base*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp_base*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_imp_base_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp_base*)0x0)->GetClass(); valimplcLcLValue_imp_base_TClassManip(theClass); return theClass; } static void valimplcLcLValue_imp_base_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEintgR_Dictionary(); static void valimplcLcLValue_implEintgR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEintgR(void *p = 0); static void *newArray_valimplcLcLValue_implEintgR(Long_t size, void *p); static void delete_valimplcLcLValue_implEintgR(void *p); static void deleteArray_valimplcLcLValue_implEintgR(void *p); static void destruct_valimplcLcLValue_implEintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEintgR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEintgR); instance.SetNewArray(&newArray_valimplcLcLValue_implEintgR); instance.SetDelete(&delete_valimplcLcLValue_implEintgR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEintgR); instance.SetDestructor(&destruct_valimplcLcLValue_implEintgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEintgR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEintgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEdoublegR_Dictionary(); static void valimplcLcLValue_implEdoublegR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEdoublegR(void *p = 0); static void *newArray_valimplcLcLValue_implEdoublegR(Long_t size, void *p); static void delete_valimplcLcLValue_implEdoublegR(void *p); static void deleteArray_valimplcLcLValue_implEdoublegR(void *p); static void destruct_valimplcLcLValue_implEdoublegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEdoublegR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEdoublegR); instance.SetNewArray(&newArray_valimplcLcLValue_implEdoublegR); instance.SetDelete(&delete_valimplcLcLValue_implEdoublegR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEdoublegR); instance.SetDestructor(&destruct_valimplcLcLValue_implEdoublegR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEdoublegR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEdoublegR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEstringgR_Dictionary(); static void valimplcLcLValue_implEstringgR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEstringgR(void *p = 0); static void *newArray_valimplcLcLValue_implEstringgR(Long_t size, void *p); static void delete_valimplcLcLValue_implEstringgR(void *p); static void deleteArray_valimplcLcLValue_implEstringgR(void *p); static void destruct_valimplcLcLValue_implEstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEstringgR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEstringgR); instance.SetNewArray(&newArray_valimplcLcLValue_implEstringgR); instance.SetDelete(&delete_valimplcLcLValue_implEstringgR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEstringgR); instance.SetDestructor(&destruct_valimplcLcLValue_implEstringgR); ::ROOT::AddClassAlternate("valimpl::Value_imp","valimpl::Value_imp"); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEstringgR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEstringgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEfloatgR_Dictionary(); static void valimplcLcLValue_implEfloatgR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEfloatgR(void *p = 0); static void *newArray_valimplcLcLValue_implEfloatgR(Long_t size, void *p); static void delete_valimplcLcLValue_implEfloatgR(void *p); static void deleteArray_valimplcLcLValue_implEfloatgR(void *p); static void destruct_valimplcLcLValue_implEfloatgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEfloatgR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEfloatgR); instance.SetNewArray(&newArray_valimplcLcLValue_implEfloatgR); instance.SetDelete(&delete_valimplcLcLValue_implEfloatgR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEfloatgR); instance.SetDestructor(&destruct_valimplcLcLValue_implEfloatgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEfloatgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEfloatgR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEfloatgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEunsignedsPintgR_Dictionary(); static void valimplcLcLValue_implEunsignedsPintgR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEunsignedsPintgR(void *p = 0); static void *newArray_valimplcLcLValue_implEunsignedsPintgR(Long_t size, void *p); static void delete_valimplcLcLValue_implEunsignedsPintgR(void *p); static void deleteArray_valimplcLcLValue_implEunsignedsPintgR(void *p); static void destruct_valimplcLcLValue_implEunsignedsPintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEunsignedsPintgR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEunsignedsPintgR); instance.SetNewArray(&newArray_valimplcLcLValue_implEunsignedsPintgR); instance.SetDelete(&delete_valimplcLcLValue_implEunsignedsPintgR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEunsignedsPintgR); instance.SetDestructor(&destruct_valimplcLcLValue_implEunsignedsPintgR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEunsignedsPintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEunsignedsPintgR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEunsignedsPintgR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implElonggR_Dictionary(); static void valimplcLcLValue_implElonggR_TClassManip(TClass*); static void *new_valimplcLcLValue_implElonggR(void *p = 0); static void *newArray_valimplcLcLValue_implElonggR(Long_t size, void *p); static void delete_valimplcLcLValue_implElonggR(void *p); static void deleteArray_valimplcLcLValue_implElonggR(void *p); static void destruct_valimplcLcLValue_implElonggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implElonggR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implElonggR); instance.SetNewArray(&newArray_valimplcLcLValue_implElonggR); instance.SetDelete(&delete_valimplcLcLValue_implElonggR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implElonggR); instance.SetDestructor(&destruct_valimplcLcLValue_implElonggR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implElonggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implElonggR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implElonggR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implElongsPdoublegR_Dictionary(); static void valimplcLcLValue_implElongsPdoublegR_TClassManip(TClass*); static void *new_valimplcLcLValue_implElongsPdoublegR(void *p = 0); static void *newArray_valimplcLcLValue_implElongsPdoublegR(Long_t size, void *p); static void delete_valimplcLcLValue_implElongsPdoublegR(void *p); static void deleteArray_valimplcLcLValue_implElongsPdoublegR(void *p); static void destruct_valimplcLcLValue_implElongsPdoublegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implElongsPdoublegR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implElongsPdoublegR); instance.SetNewArray(&newArray_valimplcLcLValue_implElongsPdoublegR); instance.SetDelete(&delete_valimplcLcLValue_implElongsPdoublegR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implElongsPdoublegR); instance.SetDestructor(&destruct_valimplcLcLValue_implElongsPdoublegR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implElongsPdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implElongsPdoublegR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implElongsPdoublegR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLValue_implEunsignedsPlonggR_Dictionary(); static void valimplcLcLValue_implEunsignedsPlonggR_TClassManip(TClass*); static void *new_valimplcLcLValue_implEunsignedsPlonggR(void *p = 0); static void *newArray_valimplcLcLValue_implEunsignedsPlonggR(Long_t size, void *p); static void delete_valimplcLcLValue_implEunsignedsPlonggR(void *p); static void deleteArray_valimplcLcLValue_implEunsignedsPlonggR(void *p); static void destruct_valimplcLcLValue_implEunsignedsPlonggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Value_imp*) { ::valimpl::Value_imp *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Value_imp)); static ::ROOT::TGenericClassInfo instance("valimpl::Value_imp", "Table.hh", 28, typeid(::valimpl::Value_imp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLValue_implEunsignedsPlonggR_Dictionary, isa_proxy, 4, sizeof(::valimpl::Value_imp) ); instance.SetNew(&new_valimplcLcLValue_implEunsignedsPlonggR); instance.SetNewArray(&newArray_valimplcLcLValue_implEunsignedsPlonggR); instance.SetDelete(&delete_valimplcLcLValue_implEunsignedsPlonggR); instance.SetDeleteArray(&deleteArray_valimplcLcLValue_implEunsignedsPlonggR); instance.SetDestructor(&destruct_valimplcLcLValue_implEunsignedsPlonggR); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Value_imp*) { return GenerateInitInstanceLocal((::valimpl::Value_imp*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLValue_implEunsignedsPlonggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Value_imp*)0x0)->GetClass(); valimplcLcLValue_implEunsignedsPlonggR_TClassManip(theClass); return theClass; } static void valimplcLcLValue_implEunsignedsPlonggR_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *valimplcLcLDummy_type_Dictionary(); static void valimplcLcLDummy_type_TClassManip(TClass*); static void *new_valimplcLcLDummy_type(void *p = 0); static void *newArray_valimplcLcLDummy_type(Long_t size, void *p); static void delete_valimplcLcLDummy_type(void *p); static void deleteArray_valimplcLcLDummy_type(void *p); static void destruct_valimplcLcLDummy_type(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::valimpl::Dummy_type*) { ::valimpl::Dummy_type *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::valimpl::Dummy_type)); static ::ROOT::TGenericClassInfo instance("valimpl::Dummy_type", "Table.hh", 50, typeid(::valimpl::Dummy_type), ::ROOT::Internal::DefineBehavior(ptr, ptr), &valimplcLcLDummy_type_Dictionary, isa_proxy, 4, sizeof(::valimpl::Dummy_type) ); instance.SetNew(&new_valimplcLcLDummy_type); instance.SetNewArray(&newArray_valimplcLcLDummy_type); instance.SetDelete(&delete_valimplcLcLDummy_type); instance.SetDeleteArray(&deleteArray_valimplcLcLDummy_type); instance.SetDestructor(&destruct_valimplcLcLDummy_type); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::valimpl::Dummy_type*) { return GenerateInitInstanceLocal((::valimpl::Dummy_type*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::valimpl::Dummy_type*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *valimplcLcLDummy_type_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::valimpl::Dummy_type*)0x0)->GetClass(); valimplcLcLDummy_type_TClassManip(theClass); return theClass; } static void valimplcLcLDummy_type_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Value_Dictionary(); static void Value_TClassManip(TClass*); static void *new_Value(void *p = 0); static void *newArray_Value(Long_t size, void *p); static void delete_Value(void *p); static void deleteArray_Value(void *p); static void destruct_Value(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Value*) { ::Value *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Value)); static ::ROOT::TGenericClassInfo instance("Value", "Table.hh", 88, typeid(::Value), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Value_Dictionary, isa_proxy, 4, sizeof(::Value) ); instance.SetNew(&new_Value); instance.SetNewArray(&newArray_Value); instance.SetDelete(&delete_Value); instance.SetDeleteArray(&deleteArray_Value); instance.SetDestructor(&destruct_Value); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Value*) { return GenerateInitInstanceLocal((::Value*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Value*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Value_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Value*)0x0)->GetClass(); Value_TClassManip(theClass); return theClass; } static void Value_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Value_adaptor_Dictionary(); static void Value_adaptor_TClassManip(TClass*); static void delete_Value_adaptor(void *p); static void deleteArray_Value_adaptor(void *p); static void destruct_Value_adaptor(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Value_adaptor*) { ::Value_adaptor *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Value_adaptor)); static ::ROOT::TGenericClassInfo instance("Value_adaptor", "Table.hh", 225, typeid(::Value_adaptor), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Value_adaptor_Dictionary, isa_proxy, 4, sizeof(::Value_adaptor) ); instance.SetDelete(&delete_Value_adaptor); instance.SetDeleteArray(&deleteArray_Value_adaptor); instance.SetDestructor(&destruct_Value_adaptor); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Value_adaptor*) { return GenerateInitInstanceLocal((::Value_adaptor*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Value_adaptor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Value_adaptor_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Value_adaptor*)0x0)->GetClass(); Value_adaptor_TClassManip(theClass); return theClass; } static void Value_adaptor_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Cell_Dictionary(); static void Cell_TClassManip(TClass*); static void *new_Cell(void *p = 0); static void *newArray_Cell(Long_t size, void *p); static void delete_Cell(void *p); static void deleteArray_Cell(void *p); static void destruct_Cell(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Cell*) { ::Cell *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Cell)); static ::ROOT::TGenericClassInfo instance("Cell", "Table.hh", 247, typeid(::Cell), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Cell_Dictionary, isa_proxy, 4, sizeof(::Cell) ); instance.SetNew(&new_Cell); instance.SetNewArray(&newArray_Cell); instance.SetDelete(&delete_Cell); instance.SetDeleteArray(&deleteArray_Cell); instance.SetDestructor(&destruct_Cell); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Cell*) { return GenerateInitInstanceLocal((::Cell*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Cell*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Cell_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Cell*)0x0)->GetClass(); Cell_TClassManip(theClass); return theClass; } static void Cell_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Table_row_Dictionary(); static void Table_row_TClassManip(TClass*); static void *new_Table_row(void *p = 0); static void *newArray_Table_row(Long_t size, void *p); static void delete_Table_row(void *p); static void deleteArray_Table_row(void *p); static void destruct_Table_row(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Table_row*) { ::Table_row *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Table_row)); static ::ROOT::TGenericClassInfo instance("Table_row", "Table.hh", 298, typeid(::Table_row), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Table_row_Dictionary, isa_proxy, 4, sizeof(::Table_row) ); instance.SetNew(&new_Table_row); instance.SetNewArray(&newArray_Table_row); instance.SetDelete(&delete_Table_row); instance.SetDeleteArray(&deleteArray_Table_row); instance.SetDestructor(&destruct_Table_row); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Table_row*) { return GenerateInitInstanceLocal((::Table_row*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Table_row*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Table_row_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Table_row*)0x0)->GetClass(); Table_row_TClassManip(theClass); return theClass; } static void Table_row_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *Table_Dictionary(); static void Table_TClassManip(TClass*); static void *new_Table(void *p = 0); static void *newArray_Table(Long_t size, void *p); static void delete_Table(void *p); static void deleteArray_Table(void *p); static void destruct_Table(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Table*) { ::Table *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Table)); static ::ROOT::TGenericClassInfo instance("Table", "Table.hh", 322, typeid(::Table), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Table_Dictionary, isa_proxy, 4, sizeof(::Table) ); instance.SetNew(&new_Table); instance.SetNewArray(&newArray_Table); instance.SetDelete(&delete_Table); instance.SetDeleteArray(&deleteArray_Table); instance.SetDestructor(&destruct_Table); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Table*) { return GenerateInitInstanceLocal((::Table*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Table*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Table_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Table*)0x0)->GetClass(); Table_TClassManip(theClass); return theClass; } static void Table_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","Table.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *aa_legacy_timercLcLTimer_Dictionary(); static void aa_legacy_timercLcLTimer_TClassManip(TClass*); static void *new_aa_legacy_timercLcLTimer(void *p = 0); static void *newArray_aa_legacy_timercLcLTimer(Long_t size, void *p); static void delete_aa_legacy_timercLcLTimer(void *p); static void deleteArray_aa_legacy_timercLcLTimer(void *p); static void destruct_aa_legacy_timercLcLTimer(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::aa_legacy_timer::Timer*) { ::aa_legacy_timer::Timer *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::aa_legacy_timer::Timer)); static ::ROOT::TGenericClassInfo instance("aa_legacy_timer::Timer", "rootutil.hh", 422, typeid(::aa_legacy_timer::Timer), ::ROOT::Internal::DefineBehavior(ptr, ptr), &aa_legacy_timercLcLTimer_Dictionary, isa_proxy, 4, sizeof(::aa_legacy_timer::Timer) ); instance.SetNew(&new_aa_legacy_timercLcLTimer); instance.SetNewArray(&newArray_aa_legacy_timercLcLTimer); instance.SetDelete(&delete_aa_legacy_timercLcLTimer); instance.SetDeleteArray(&deleteArray_aa_legacy_timercLcLTimer); instance.SetDestructor(&destruct_aa_legacy_timercLcLTimer); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::aa_legacy_timer::Timer*) { return GenerateInitInstanceLocal((::aa_legacy_timer::Timer*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::aa_legacy_timer::Timer*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *aa_legacy_timercLcLTimer_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::aa_legacy_timer::Timer*)0x0)->GetClass(); aa_legacy_timercLcLTimer_TClassManip(theClass); return theClass; } static void aa_legacy_timercLcLTimer_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *ticktimercLcLTickStopwatch_Dictionary(); static void ticktimercLcLTickStopwatch_TClassManip(TClass*); static void *new_ticktimercLcLTickStopwatch(void *p = 0); static void *newArray_ticktimercLcLTickStopwatch(Long_t size, void *p); static void delete_ticktimercLcLTickStopwatch(void *p); static void deleteArray_ticktimercLcLTickStopwatch(void *p); static void destruct_ticktimercLcLTickStopwatch(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ticktimer::TickStopwatch*) { ::ticktimer::TickStopwatch *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ticktimer::TickStopwatch)); static ::ROOT::TGenericClassInfo instance("ticktimer::TickStopwatch", "rootutil.hh", 533, typeid(::ticktimer::TickStopwatch), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ticktimercLcLTickStopwatch_Dictionary, isa_proxy, 4, sizeof(::ticktimer::TickStopwatch) ); instance.SetNew(&new_ticktimercLcLTickStopwatch); instance.SetNewArray(&newArray_ticktimercLcLTickStopwatch); instance.SetDelete(&delete_ticktimercLcLTickStopwatch); instance.SetDeleteArray(&deleteArray_ticktimercLcLTickStopwatch); instance.SetDestructor(&destruct_ticktimercLcLTickStopwatch); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ticktimer::TickStopwatch*) { return GenerateInitInstanceLocal((::ticktimer::TickStopwatch*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ticktimer::TickStopwatch*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ticktimercLcLTickStopwatch_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ticktimer::TickStopwatch*)0x0)->GetClass(); ticktimercLcLTickStopwatch_TClassManip(theClass); return theClass; } static void ticktimercLcLTickStopwatch_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *ticktimercLcLTickStopwatchcLcLStopper_Dictionary(); static void ticktimercLcLTickStopwatchcLcLStopper_TClassManip(TClass*); static void delete_ticktimercLcLTickStopwatchcLcLStopper(void *p); static void deleteArray_ticktimercLcLTickStopwatchcLcLStopper(void *p); static void destruct_ticktimercLcLTickStopwatchcLcLStopper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ticktimer::TickStopwatch::Stopper*) { ::ticktimer::TickStopwatch::Stopper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ticktimer::TickStopwatch::Stopper)); static ::ROOT::TGenericClassInfo instance("ticktimer::TickStopwatch::Stopper", "rootutil.hh", 585, typeid(::ticktimer::TickStopwatch::Stopper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ticktimercLcLTickStopwatchcLcLStopper_Dictionary, isa_proxy, 4, sizeof(::ticktimer::TickStopwatch::Stopper) ); instance.SetDelete(&delete_ticktimercLcLTickStopwatchcLcLStopper); instance.SetDeleteArray(&deleteArray_ticktimercLcLTickStopwatchcLcLStopper); instance.SetDestructor(&destruct_ticktimercLcLTickStopwatchcLcLStopper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ticktimer::TickStopwatch::Stopper*) { return GenerateInitInstanceLocal((::ticktimer::TickStopwatch::Stopper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ticktimer::TickStopwatch::Stopper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ticktimercLcLTickStopwatchcLcLStopper_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ticktimer::TickStopwatch::Stopper*)0x0)->GetClass(); ticktimercLcLTickStopwatchcLcLStopper_TClassManip(theClass); return theClass; } static void ticktimercLcLTickStopwatchcLcLStopper_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *ticktimercLcLTimer_Dictionary(); static void ticktimercLcLTimer_TClassManip(TClass*); static void delete_ticktimercLcLTimer(void *p); static void deleteArray_ticktimercLcLTimer(void *p); static void destruct_ticktimercLcLTimer(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ticktimer::Timer*) { ::ticktimer::Timer *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ticktimer::Timer)); static ::ROOT::TGenericClassInfo instance("ticktimer::Timer", "rootutil.hh", 686, typeid(::ticktimer::Timer), ::ROOT::Internal::DefineBehavior(ptr, ptr), &ticktimercLcLTimer_Dictionary, isa_proxy, 4, sizeof(::ticktimer::Timer) ); instance.SetDelete(&delete_ticktimercLcLTimer); instance.SetDeleteArray(&deleteArray_ticktimercLcLTimer); instance.SetDestructor(&destruct_ticktimercLcLTimer); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ticktimer::Timer*) { return GenerateInitInstanceLocal((::ticktimer::Timer*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ticktimer::Timer*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *ticktimercLcLTimer_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ticktimer::Timer*)0x0)->GetClass(); ticktimercLcLTimer_TClassManip(theClass); return theClass; } static void ticktimercLcLTimer_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *MemCounter_Dictionary(); static void MemCounter_TClassManip(TClass*); static void *new_MemCounter(void *p = 0); static void *newArray_MemCounter(Long_t size, void *p); static void delete_MemCounter(void *p); static void deleteArray_MemCounter(void *p); static void destruct_MemCounter(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MemCounter*) { ::MemCounter *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MemCounter)); static ::ROOT::TGenericClassInfo instance("MemCounter", "rootutil.hh", 808, typeid(::MemCounter), ::ROOT::Internal::DefineBehavior(ptr, ptr), &MemCounter_Dictionary, isa_proxy, 4, sizeof(::MemCounter) ); instance.SetNew(&new_MemCounter); instance.SetNewArray(&newArray_MemCounter); instance.SetDelete(&delete_MemCounter); instance.SetDeleteArray(&deleteArray_MemCounter); instance.SetDestructor(&destruct_MemCounter); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MemCounter*) { return GenerateInitInstanceLocal((::MemCounter*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MemCounter*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *MemCounter_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MemCounter*)0x0)->GetClass(); MemCounter_TClassManip(theClass); return theClass; } static void MemCounter_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *MemCountercLcLToken_Dictionary(); static void MemCountercLcLToken_TClassManip(TClass*); static void delete_MemCountercLcLToken(void *p); static void deleteArray_MemCountercLcLToken(void *p); static void destruct_MemCountercLcLToken(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MemCounter::Token*) { ::MemCounter::Token *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MemCounter::Token)); static ::ROOT::TGenericClassInfo instance("MemCounter::Token", "rootutil.hh", 817, typeid(::MemCounter::Token), ::ROOT::Internal::DefineBehavior(ptr, ptr), &MemCountercLcLToken_Dictionary, isa_proxy, 4, sizeof(::MemCounter::Token) ); instance.SetDelete(&delete_MemCountercLcLToken); instance.SetDeleteArray(&deleteArray_MemCountercLcLToken); instance.SetDestructor(&destruct_MemCountercLcLToken); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MemCounter::Token*) { return GenerateInitInstanceLocal((::MemCounter::Token*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MemCounter::Token*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *MemCountercLcLToken_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MemCounter::Token*)0x0)->GetClass(); MemCountercLcLToken_TClassManip(theClass); return theClass; } static void MemCountercLcLToken_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static void delete_Looper(void *p); static void deleteArray_Looper(void *p); static void destruct_Looper(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Looper*) { ::Looper *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Looper >(0); static ::ROOT::TGenericClassInfo instance("Looper", ::Looper::Class_Version(), "rootutil.hh", 961, typeid(::Looper), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Looper::Dictionary, isa_proxy, 4, sizeof(::Looper) ); instance.SetDelete(&delete_Looper); instance.SetDeleteArray(&deleteArray_Looper); instance.SetDestructor(&destruct_Looper); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Looper*) { return GenerateInitInstanceLocal((::Looper*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Looper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *LoopercLcLbin_Dictionary(); static void LoopercLcLbin_TClassManip(TClass*); static void *new_LoopercLcLbin(void *p = 0); static void *newArray_LoopercLcLbin(Long_t size, void *p); static void delete_LoopercLcLbin(void *p); static void deleteArray_LoopercLcLbin(void *p); static void destruct_LoopercLcLbin(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Looper::bin*) { ::Looper::bin *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Looper::bin)); static ::ROOT::TGenericClassInfo instance("Looper::bin", "rootutil.hh", 970, typeid(::Looper::bin), ::ROOT::Internal::DefineBehavior(ptr, ptr), &LoopercLcLbin_Dictionary, isa_proxy, 4, sizeof(::Looper::bin) ); instance.SetNew(&new_LoopercLcLbin); instance.SetNewArray(&newArray_LoopercLcLbin); instance.SetDelete(&delete_LoopercLcLbin); instance.SetDeleteArray(&deleteArray_LoopercLcLbin); instance.SetDestructor(&destruct_LoopercLcLbin); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Looper::bin*) { return GenerateInitInstanceLocal((::Looper::bin*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Looper::bin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *LoopercLcLbin_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Looper::bin*)0x0)->GetClass(); LoopercLcLbin_TClassManip(theClass); return theClass; } static void LoopercLcLbin_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static void delete_LoopercLcLiterator(void *p); static void deleteArray_LoopercLcLiterator(void *p); static void destruct_LoopercLcLiterator(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Looper::iterator*) { ::Looper::iterator *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Looper::iterator >(0); static ::ROOT::TGenericClassInfo instance("Looper::iterator", ::Looper::iterator::Class_Version(), "rootutil.hh", 1012, typeid(::Looper::iterator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Looper::iterator::Dictionary, isa_proxy, 4, sizeof(::Looper::iterator) ); instance.SetDelete(&delete_LoopercLcLiterator); instance.SetDeleteArray(&deleteArray_LoopercLcLiterator); instance.SetDestructor(&destruct_LoopercLcLiterator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Looper::iterator*) { return GenerateInitInstanceLocal((::Looper::iterator*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Looper::iterator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *TreeVals_Dictionary(); static void TreeVals_TClassManip(TClass*); static void delete_TreeVals(void *p); static void deleteArray_TreeVals(void *p); static void destruct_TreeVals(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TreeVals*) { ::TreeVals *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TreeVals)); static ::ROOT::TGenericClassInfo instance("TreeVals", "rootutil.hh", 1095, typeid(::TreeVals), ::ROOT::Internal::DefineBehavior(ptr, ptr), &TreeVals_Dictionary, isa_proxy, 4, sizeof(::TreeVals) ); instance.SetDelete(&delete_TreeVals); instance.SetDeleteArray(&deleteArray_TreeVals); instance.SetDestructor(&destruct_TreeVals); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TreeVals*) { return GenerateInitInstanceLocal((::TreeVals*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TreeVals*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *TreeVals_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TreeVals*)0x0)->GetClass(); TreeVals_TClassManip(theClass); return theClass; } static void TreeVals_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static TClass *TreeValscLcLiterator_Dictionary(); static void TreeValscLcLiterator_TClassManip(TClass*); static void delete_TreeValscLcLiterator(void *p); static void deleteArray_TreeValscLcLiterator(void *p); static void destruct_TreeValscLcLiterator(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TreeVals::iterator*) { ::TreeVals::iterator *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TreeVals::iterator)); static ::ROOT::TGenericClassInfo instance("TreeVals::iterator", "rootutil.hh", 1100, typeid(::TreeVals::iterator), ::ROOT::Internal::DefineBehavior(ptr, ptr), &TreeValscLcLiterator_Dictionary, isa_proxy, 4, sizeof(::TreeVals::iterator) ); instance.SetDelete(&delete_TreeValscLcLiterator); instance.SetDeleteArray(&deleteArray_TreeValscLcLiterator); instance.SetDestructor(&destruct_TreeValscLcLiterator); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TreeVals::iterator*) { return GenerateInitInstanceLocal((::TreeVals::iterator*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TreeVals::iterator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *TreeValscLcLiterator_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TreeVals::iterator*)0x0)->GetClass(); TreeValscLcLiterator_TClassManip(theClass); return theClass; } static void TreeValscLcLiterator_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","rootutil.hh"); } } // end of namespace ROOT namespace ROOT { static void *new_Mat(void *p = 0); static void *newArray_Mat(Long_t size, void *p); static void delete_Mat(void *p); static void deleteArray_Mat(void *p); static void destruct_Mat(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Mat*) { ::Mat *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Mat >(0); static ::ROOT::TGenericClassInfo instance("Mat", ::Mat::Class_Version(), "Mat.hh", 13, typeid(::Mat), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Mat::Dictionary, isa_proxy, 4, sizeof(::Mat) ); instance.SetNew(&new_Mat); instance.SetNewArray(&newArray_Mat); instance.SetDelete(&delete_Mat); instance.SetDeleteArray(&deleteArray_Mat); instance.SetDestructor(&destruct_Mat); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Mat*) { return GenerateInitInstanceLocal((::Mat*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Mat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr Looper::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Looper::Class_Name() { return "Looper"; } //______________________________________________________________________________ const char *Looper::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Looper*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Looper::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Looper*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Looper::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Looper*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Looper::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Looper*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr Looper::iterator::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Looper::iterator::Class_Name() { return "Looper::iterator"; } //______________________________________________________________________________ const char *Looper::iterator::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Looper::iterator*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Looper::iterator::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Looper::iterator*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Looper::iterator::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Looper::iterator*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Looper::iterator::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Looper::iterator*)0x0)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr Mat::fgIsA(0); // static to hold class pointer //______________________________________________________________________________ const char *Mat::Class_Name() { return "Mat"; } //______________________________________________________________________________ const char *Mat::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Mat*)0x0)->GetImplFileName(); } //______________________________________________________________________________ int Mat::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Mat*)0x0)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Mat::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mat*)0x0)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Mat::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mat*)0x0)->GetClass(); } return fgIsA; } namespace ROOT { // Wrapper around operator delete static void delete_valimplcLcLValue_imp_base(void *p) { delete ((::valimpl::Value_imp_base*)p); } static void deleteArray_valimplcLcLValue_imp_base(void *p) { delete [] ((::valimpl::Value_imp_base*)p); } static void destruct_valimplcLcLValue_imp_base(void *p) { typedef ::valimpl::Value_imp_base current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp_base namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEintgR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEintgR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEintgR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEdoublegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEdoublegR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEdoublegR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEdoublegR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEstringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEstringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEstringgR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEstringgR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEstringgR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEfloatgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEfloatgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEfloatgR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEfloatgR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEfloatgR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEunsignedsPintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEunsignedsPintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEunsignedsPintgR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEunsignedsPintgR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEunsignedsPintgR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implElonggR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implElonggR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implElonggR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implElonggR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implElonggR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implElongsPdoublegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implElongsPdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implElongsPdoublegR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implElongsPdoublegR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implElongsPdoublegR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLValue_implEunsignedsPlonggR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp : new ::valimpl::Value_imp; } static void *newArray_valimplcLcLValue_implEunsignedsPlonggR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Value_imp[nElements] : new ::valimpl::Value_imp[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLValue_implEunsignedsPlonggR(void *p) { delete ((::valimpl::Value_imp*)p); } static void deleteArray_valimplcLcLValue_implEunsignedsPlonggR(void *p) { delete [] ((::valimpl::Value_imp*)p); } static void destruct_valimplcLcLValue_implEunsignedsPlonggR(void *p) { typedef ::valimpl::Value_imp current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Value_imp namespace ROOT { // Wrappers around operator new static void *new_valimplcLcLDummy_type(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Dummy_type : new ::valimpl::Dummy_type; } static void *newArray_valimplcLcLDummy_type(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::valimpl::Dummy_type[nElements] : new ::valimpl::Dummy_type[nElements]; } // Wrapper around operator delete static void delete_valimplcLcLDummy_type(void *p) { delete ((::valimpl::Dummy_type*)p); } static void deleteArray_valimplcLcLDummy_type(void *p) { delete [] ((::valimpl::Dummy_type*)p); } static void destruct_valimplcLcLDummy_type(void *p) { typedef ::valimpl::Dummy_type current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::valimpl::Dummy_type namespace ROOT { // Wrappers around operator new static void *new_Value(void *p) { return p ? new(p) ::Value : new ::Value; } static void *newArray_Value(Long_t nElements, void *p) { return p ? new(p) ::Value[nElements] : new ::Value[nElements]; } // Wrapper around operator delete static void delete_Value(void *p) { delete ((::Value*)p); } static void deleteArray_Value(void *p) { delete [] ((::Value*)p); } static void destruct_Value(void *p) { typedef ::Value current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Value namespace ROOT { // Wrapper around operator delete static void delete_Value_adaptor(void *p) { delete ((::Value_adaptor*)p); } static void deleteArray_Value_adaptor(void *p) { delete [] ((::Value_adaptor*)p); } static void destruct_Value_adaptor(void *p) { typedef ::Value_adaptor current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Value_adaptor namespace ROOT { // Wrappers around operator new static void *new_Cell(void *p) { return p ? new(p) ::Cell : new ::Cell; } static void *newArray_Cell(Long_t nElements, void *p) { return p ? new(p) ::Cell[nElements] : new ::Cell[nElements]; } // Wrapper around operator delete static void delete_Cell(void *p) { delete ((::Cell*)p); } static void deleteArray_Cell(void *p) { delete [] ((::Cell*)p); } static void destruct_Cell(void *p) { typedef ::Cell current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Cell namespace ROOT { // Wrappers around operator new static void *new_Table_row(void *p) { return p ? new(p) ::Table_row : new ::Table_row; } static void *newArray_Table_row(Long_t nElements, void *p) { return p ? new(p) ::Table_row[nElements] : new ::Table_row[nElements]; } // Wrapper around operator delete static void delete_Table_row(void *p) { delete ((::Table_row*)p); } static void deleteArray_Table_row(void *p) { delete [] ((::Table_row*)p); } static void destruct_Table_row(void *p) { typedef ::Table_row current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Table_row namespace ROOT { // Wrappers around operator new static void *new_Table(void *p) { return p ? new(p) ::Table : new ::Table; } static void *newArray_Table(Long_t nElements, void *p) { return p ? new(p) ::Table[nElements] : new ::Table[nElements]; } // Wrapper around operator delete static void delete_Table(void *p) { delete ((::Table*)p); } static void deleteArray_Table(void *p) { delete [] ((::Table*)p); } static void destruct_Table(void *p) { typedef ::Table current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Table namespace ROOT { // Wrappers around operator new static void *new_aa_legacy_timercLcLTimer(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::aa_legacy_timer::Timer : new ::aa_legacy_timer::Timer; } static void *newArray_aa_legacy_timercLcLTimer(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::aa_legacy_timer::Timer[nElements] : new ::aa_legacy_timer::Timer[nElements]; } // Wrapper around operator delete static void delete_aa_legacy_timercLcLTimer(void *p) { delete ((::aa_legacy_timer::Timer*)p); } static void deleteArray_aa_legacy_timercLcLTimer(void *p) { delete [] ((::aa_legacy_timer::Timer*)p); } static void destruct_aa_legacy_timercLcLTimer(void *p) { typedef ::aa_legacy_timer::Timer current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::aa_legacy_timer::Timer namespace ROOT { // Wrappers around operator new static void *new_ticktimercLcLTickStopwatch(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::ticktimer::TickStopwatch : new ::ticktimer::TickStopwatch; } static void *newArray_ticktimercLcLTickStopwatch(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::ticktimer::TickStopwatch[nElements] : new ::ticktimer::TickStopwatch[nElements]; } // Wrapper around operator delete static void delete_ticktimercLcLTickStopwatch(void *p) { delete ((::ticktimer::TickStopwatch*)p); } static void deleteArray_ticktimercLcLTickStopwatch(void *p) { delete [] ((::ticktimer::TickStopwatch*)p); } static void destruct_ticktimercLcLTickStopwatch(void *p) { typedef ::ticktimer::TickStopwatch current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::ticktimer::TickStopwatch namespace ROOT { // Wrapper around operator delete static void delete_ticktimercLcLTickStopwatchcLcLStopper(void *p) { delete ((::ticktimer::TickStopwatch::Stopper*)p); } static void deleteArray_ticktimercLcLTickStopwatchcLcLStopper(void *p) { delete [] ((::ticktimer::TickStopwatch::Stopper*)p); } static void destruct_ticktimercLcLTickStopwatchcLcLStopper(void *p) { typedef ::ticktimer::TickStopwatch::Stopper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::ticktimer::TickStopwatch::Stopper namespace ROOT { // Wrapper around operator delete static void delete_ticktimercLcLTimer(void *p) { delete ((::ticktimer::Timer*)p); } static void deleteArray_ticktimercLcLTimer(void *p) { delete [] ((::ticktimer::Timer*)p); } static void destruct_ticktimercLcLTimer(void *p) { typedef ::ticktimer::Timer current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::ticktimer::Timer namespace ROOT { // Wrappers around operator new static void *new_MemCounter(void *p) { return p ? new(p) ::MemCounter : new ::MemCounter; } static void *newArray_MemCounter(Long_t nElements, void *p) { return p ? new(p) ::MemCounter[nElements] : new ::MemCounter[nElements]; } // Wrapper around operator delete static void delete_MemCounter(void *p) { delete ((::MemCounter*)p); } static void deleteArray_MemCounter(void *p) { delete [] ((::MemCounter*)p); } static void destruct_MemCounter(void *p) { typedef ::MemCounter current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::MemCounter namespace ROOT { // Wrapper around operator delete static void delete_MemCountercLcLToken(void *p) { delete ((::MemCounter::Token*)p); } static void deleteArray_MemCountercLcLToken(void *p) { delete [] ((::MemCounter::Token*)p); } static void destruct_MemCountercLcLToken(void *p) { typedef ::MemCounter::Token current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::MemCounter::Token //______________________________________________________________________________ void Looper::Streamer(TBuffer &R__b) { // Stream an object of class Looper. if (R__b.IsReading()) { R__b.ReadClassBuffer(Looper::Class(),this); } else { R__b.WriteClassBuffer(Looper::Class(),this); } } namespace ROOT { // Wrapper around operator delete static void delete_Looper(void *p) { delete ((::Looper*)p); } static void deleteArray_Looper(void *p) { delete [] ((::Looper*)p); } static void destruct_Looper(void *p) { typedef ::Looper current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Looper namespace ROOT { // Wrappers around operator new static void *new_LoopercLcLbin(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Looper::bin : new ::Looper::bin; } static void *newArray_LoopercLcLbin(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Looper::bin[nElements] : new ::Looper::bin[nElements]; } // Wrapper around operator delete static void delete_LoopercLcLbin(void *p) { delete ((::Looper::bin*)p); } static void deleteArray_LoopercLcLbin(void *p) { delete [] ((::Looper::bin*)p); } static void destruct_LoopercLcLbin(void *p) { typedef ::Looper::bin current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Looper::bin //______________________________________________________________________________ void Looper::iterator::Streamer(TBuffer &R__b) { // Stream an object of class Looper::iterator. if (R__b.IsReading()) { R__b.ReadClassBuffer(Looper::iterator::Class(),this); } else { R__b.WriteClassBuffer(Looper::iterator::Class(),this); } } namespace ROOT { // Wrapper around operator delete static void delete_LoopercLcLiterator(void *p) { delete ((::Looper::iterator*)p); } static void deleteArray_LoopercLcLiterator(void *p) { delete [] ((::Looper::iterator*)p); } static void destruct_LoopercLcLiterator(void *p) { typedef ::Looper::iterator current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Looper::iterator namespace ROOT { // Wrapper around operator delete static void delete_TreeVals(void *p) { delete ((::TreeVals*)p); } static void deleteArray_TreeVals(void *p) { delete [] ((::TreeVals*)p); } static void destruct_TreeVals(void *p) { typedef ::TreeVals current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::TreeVals namespace ROOT { // Wrapper around operator delete static void delete_TreeValscLcLiterator(void *p) { delete ((::TreeVals::iterator*)p); } static void deleteArray_TreeValscLcLiterator(void *p) { delete [] ((::TreeVals::iterator*)p); } static void destruct_TreeValscLcLiterator(void *p) { typedef ::TreeVals::iterator current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::TreeVals::iterator //______________________________________________________________________________ void Mat::Streamer(TBuffer &R__b) { // Stream an object of class Mat. if (R__b.IsReading()) { R__b.ReadClassBuffer(Mat::Class(),this); } else { R__b.WriteClassBuffer(Mat::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_Mat(void *p) { return p ? new(p) ::Mat : new ::Mat; } static void *newArray_Mat(Long_t nElements, void *p) { return p ? new(p) ::Mat[nElements] : new ::Mat[nElements]; } // Wrapper around operator delete static void delete_Mat(void *p) { delete ((::Mat*)p); } static void deleteArray_Mat(void *p) { delete [] ((::Mat*)p); } static void destruct_Mat(void *p) { typedef ::Mat current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::Mat namespace ROOT { static TClass *vectorlETable_rowgR_Dictionary(); static void vectorlETable_rowgR_TClassManip(TClass*); static void *new_vectorlETable_rowgR(void *p = 0); static void *newArray_vectorlETable_rowgR(Long_t size, void *p); static void delete_vectorlETable_rowgR(void *p); static void deleteArray_vectorlETable_rowgR(void *p); static void destruct_vectorlETable_rowgR(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), &vectorlETable_rowgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETable_rowgR); instance.SetNewArray(&newArray_vectorlETable_rowgR); instance.SetDelete(&delete_vectorlETable_rowgR); instance.SetDeleteArray(&deleteArray_vectorlETable_rowgR); instance.SetDestructor(&destruct_vectorlETable_rowgR); 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 *vectorlETable_rowgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlETable_rowgR_TClassManip(theClass); return theClass; } static void vectorlETable_rowgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETable_rowgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETable_rowgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETable_rowgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlETable_rowgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlETable_rowgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlECellgR_Dictionary(); static void vectorlECellgR_TClassManip(TClass*); static void *new_vectorlECellgR(void *p = 0); static void *newArray_vectorlECellgR(Long_t size, void *p); static void delete_vectorlECellgR(void *p); static void deleteArray_vectorlECellgR(void *p); static void destruct_vectorlECellgR(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), &vectorlECellgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlECellgR); instance.SetNewArray(&newArray_vectorlECellgR); instance.SetDelete(&delete_vectorlECellgR); instance.SetDeleteArray(&deleteArray_vectorlECellgR); instance.SetDestructor(&destruct_vectorlECellgR); 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 *vectorlECellgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlECellgR_TClassManip(theClass); return theClass; } static void vectorlECellgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlECellgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlECellgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlECellgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlECellgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlECellgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace { void TriggerDictionaryInitialization_aadOdict_Impl() { static const char* headers[] = { "aa.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 "aadOdict 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; namespace valimpl{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Value_imp_base;} namespace valimpl{template struct __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Value_imp; } namespace std{template struct __attribute__((annotate("$clingAutoload$bits/char_traits.h"))) __attribute__((annotate("$clingAutoload$string"))) char_traits; } namespace std{template class __attribute__((annotate("$clingAutoload$bits/memoryfwd.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator; } namespace valimpl{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Dummy_type;} struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Value; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Value_adaptor; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Cell; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Table_row; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Table.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Table.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Table; namespace aa_legacy_timer{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Timer;} namespace ticktimer{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) TickStopwatch;} namespace ticktimer{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Timer;} struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) MemCounter; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Looper; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@rootutil.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$rootutil.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) TreeVals; struct __attribute__((annotate(R"ATTRDUMP(file_name@@@Mat.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$Mat.hh"))) __attribute__((annotate("$clingAutoload$aa.hh"))) Mat; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "aadOdict dictionary payload" #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "aa.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "Cell", payloadCode, "@", "Head_items_that_may_differ", payloadCode, "@", "Head_items_to_be_added", payloadCode, "@", "Looper", payloadCode, "@", "Looper::fgIsA", payloadCode, "@", "Looper::iterator::fgIsA", payloadCode, "@", "Mat", payloadCode, "@", "Mat::fgIsA", payloadCode, "@", "MemCounter", payloadCode, "@", "TH3_Interpolate", payloadCode, "@", "Table", payloadCode, "@", "Table_row", payloadCode, "@", "TreeVals", payloadCode, "@", "Value", payloadCode, "@", "Value_adaptor", payloadCode, "@", "___altrks", payloadCode, "@", "_avoid", payloadCode, "@", "_split_hist", payloadCode, "@", "_trk_tostr", payloadCode, "@", "_vector_array_address_and_size", payloadCode, "@", "aa::aaver", payloadCode, "@", "aa::c_light", payloadCode, "@", "aa::cherenkov_angle", payloadCode, "@", "aa::cos_cherenkov_angle", payloadCode, "@", "aa::deg", payloadCode, "@", "aa::dndl", payloadCode, "@", "aa::pi", payloadCode, "@", "aa::print_constants", payloadCode, "@", "aa::v_light", payloadCode, "@", "aa::water_index", payloadCode, "@", "aa_git_version", payloadCode, "@", "aa_legacy_timer::Timer", payloadCode, "@", "add", payloadCode, "@", "add_truth_to_hits", payloadCode, "@", "basekey", payloadCode, "@", "best_reco_track", payloadCode, "@", "cached_interpolate", payloadCode, "@", "check", payloadCode, "@", "cherenkov_pars", payloadCode, "@", "clamp", payloadCode, "@", "clamp_bincenter", payloadCode, "@", "cling::printValue", payloadCode, "@", "cling_jit", payloadCode, "@", "cxx", payloadCode, "@", "cxx_file", payloadCode, "@", "diff", payloadCode, "@", "err", payloadCode, "@", "errorhandler", payloadCode, "@", "filetype", payloadCode, "@", "floatrange", payloadCode, "@", "get_detector_file_from_head", payloadCode, "@", "get_git_version", payloadCode, "@", "get_interpolation_consts", payloadCode, "@", "get_livetime", payloadCode, "@", "get_mem_counter", payloadCode, "@", "get_ngen", payloadCode, "@", "grid", payloadCode, "@", "h", payloadCode, "@", "hammer_projection", payloadCode, "@", "headers_are_equivalent", payloadCode, "@", "histogram_slice_y", payloadCode, "@", "interpol_xz", payloadCode, "@", "interpolate", payloadCode, "@", "interpolate_derivative", payloadCode, "@", "intr", payloadCode, "@", "join", payloadCode, "@", "mem_counter_map", payloadCode, "@", "mem_report", payloadCode, "@", "methodName", payloadCode, "@", "move_trk_to", payloadCode, "@", "normalize", payloadCode, "@", "normalize_z", payloadCode, "@", "operator*", payloadCode, "@", "operator<<", payloadCode, "@", "operator>>", payloadCode, "@", "pretty_mc_tracks", payloadCode, "@", "print_ascii", payloadCode, "@", "print_meta", payloadCode, "@", "rec_types::aashowerfit", payloadCode, "@", "rec_types::dusj", payloadCode, "@", "rec_types::jgandalf", payloadCode, "@", "rec_types::jshowerfit", payloadCode, "@", "sky_grid", payloadCode, "@", "slice_at_xy", payloadCode, "@", "slice_at_z", payloadCode, "@", "split_x", payloadCode, "@", "split_y", payloadCode, "@", "split_z", payloadCode, "@", "str_axis", payloadCode, "@", "test_intr", payloadCode, "@", "ticktimer::TickStopwatch", payloadCode, "@", "ticktimer::Timer", payloadCode, "@", "time_at", payloadCode, "@", "valimpl::Dummy_type", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp", payloadCode, "@", "valimpl::Value_imp_base", payloadCode, "@", "valimpl::operator<<", payloadCode, "@", "valimpl::operator>>", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("aa.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_aadOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_aadOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_aadOdict() { TriggerDictionaryInitialization_aadOdict_Impl(); }