Esempio n. 1
0
 // Function generating the singleton type initializer
 TGenericClassInfo *GenerateInitInstance(const TMatlab*)
 {
    TMatlab *ptr = 0;
    static ROOT::TGenericClassInfo 
       instance("TMatlab", TMatlab::Class_Version(), "TMatlab.h", 42,
                typeid(TMatlab), DefineBehavior(ptr, ptr),
                &::TMatlab::Dictionary, &TMatlab_IsA, 0,
                sizeof(TMatlab) );
    instance.SetNew(&new_TMatlab);
    instance.SetNewArray(&newArray_TMatlab);
    instance.SetDelete(&delete_TMatlab);
    instance.SetDeleteArray(&deleteArray_TMatlab);
    instance.SetDestructor(&destruct_TMatlab);
    return &instance;
 }
Esempio n. 2
0
 // Function generating the singleton type initializer
 TGenericClassInfo *GenerateInitInstance(const TmxArray*)
 {
    TmxArray *ptr = 0;
    static ROOT::TGenericClassInfo 
       instance("TmxArray", TmxArray::Class_Version(), "TmxArray.h", 30,
                typeid(TmxArray), DefineBehavior(ptr, ptr),
                &::TmxArray::Dictionary, &TmxArray_IsA, 0,
                sizeof(TmxArray) );
    instance.SetNew(&new_TmxArray);
    instance.SetNewArray(&newArray_TmxArray);
    instance.SetDelete(&delete_TmxArray);
    instance.SetDeleteArray(&deleteArray_TmxArray);
    instance.SetDestructor(&destruct_TmxArray);
    return &instance;
 }
Esempio n. 3
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const ::FvtxEventFilter*)
 {
    ::FvtxEventFilter *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::FvtxEventFilter),0);
    static ::ROOT::TGenericClassInfo 
       instance("FvtxEventFilter", "./../FvtxEventFilter.h", 30,
                typeid(::FvtxEventFilter), DefineBehavior(ptr, ptr),
                0, &FvtxEventFilter_Dictionary, isa_proxy, 3,
                sizeof(::FvtxEventFilter) );
    instance.SetNew(&new_FvtxEventFilter);
    instance.SetNewArray(&newArray_FvtxEventFilter);
    instance.SetDelete(&delete_FvtxEventFilter);
    instance.SetDeleteArray(&deleteArray_FvtxEventFilter);
    instance.SetDestructor(&destruct_FvtxEventFilter);
    return &instance;
 }
Esempio n. 4
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const ::GmpNormAna*)
 {
    ::GmpNormAna *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::GmpNormAna >(0);
    static ::ROOT::TGenericClassInfo 
       instance("GmpNormAna", ::GmpNormAna::Class_Version(), "./GmpNormAna.h", 142,
                typeid(::GmpNormAna), DefineBehavior(ptr, ptr),
                &::GmpNormAna::Dictionary, isa_proxy, 4,
                sizeof(::GmpNormAna) );
    instance.SetNew(&new_GmpNormAna);
    instance.SetNewArray(&newArray_GmpNormAna);
    instance.SetDelete(&delete_GmpNormAna);
    instance.SetDeleteArray(&deleteArray_GmpNormAna);
    instance.SetDestructor(&destruct_GmpNormAna);
    return &instance;
 }
Esempio n. 5
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const ::RapidRun*)
 {
    ::RapidRun *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RapidRun >(0);
    static ::ROOT::TGenericClassInfo 
       instance("RapidRun", ::RapidRun::Class_Version(), "./framework/include/RapidRun.h", 22,
                typeid(::RapidRun), DefineBehavior(ptr, ptr),
                &::RapidRun::Dictionary, isa_proxy, 4,
                sizeof(::RapidRun) );
    instance.SetNew(&new_RapidRun);
    instance.SetNewArray(&newArray_RapidRun);
    instance.SetDelete(&delete_RapidRun);
    instance.SetDeleteArray(&deleteArray_RapidRun);
    instance.SetDestructor(&destruct_RapidRun);
    return &instance;
 }
Esempio n. 6
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Event*)
 {
    ::Event *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Event >(0);
    static ::ROOT::TGenericClassInfo 
       instance("Event", ::Event::Class_Version(), "./Event.h", 6,
                typeid(::Event), DefineBehavior(ptr, ptr),
                &::Event::Dictionary, isa_proxy, 4,
                sizeof(::Event) );
    instance.SetNew(&new_Event);
    instance.SetNewArray(&newArray_Event);
    instance.SetDelete(&delete_Event);
    instance.SetDeleteArray(&deleteArray_Event);
    instance.SetDestructor(&destruct_Event);
    return &instance;
 }
Esempio n. 7
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const ::RunStat*)
 {
    ::RunStat *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RunStat >(0);
    static ::ROOT::TGenericClassInfo 
       instance("RunStat", ::RunStat::Class_Version(), "./RunStat.h", 7,
                typeid(::RunStat), DefineBehavior(ptr, ptr),
                &::RunStat::Dictionary, isa_proxy, 0,
                sizeof(::RunStat) );
    instance.SetNew(&new_RunStat);
    instance.SetNewArray(&newArray_RunStat);
    instance.SetDelete(&delete_RunStat);
    instance.SetDeleteArray(&deleteArray_RunStat);
    instance.SetDestructor(&destruct_RunStat);
    instance.SetStreamerFunc(&streamer_RunStat);
    return &instance;
 }
Esempio n. 8
0
 // Function generating the singleton type initializer
 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
 {
    vector<int> *ptr = 0;
    static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
    static ::ROOT::TGenericClassInfo 
       instance("vector<int>", -2, "prec_stl/vector", 49,
                typeid(vector<int>), DefineBehavior(ptr, ptr),
                0, &vectorlEintgR_Dictionary, isa_proxy, 0,
                sizeof(vector<int>) );
    instance.SetNew(&new_vectorlEintgR);
    instance.SetNewArray(&newArray_vectorlEintgR);
    instance.SetDelete(&delete_vectorlEintgR);
    instance.SetDeleteArray(&deleteArray_vectorlEintgR);
    instance.SetDestructor(&destruct_vectorlEintgR);
    instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
    return &instance;
 }