src/build/sPHElectronPairContainerv1_Dict.cc

0001 // Do NOT change. Changes will be lost next time file is generated
0002
0003 #define R__DICTIONARY_FILENAME sPHElectronPairContainerv1_Dict
0004 #define R__NO_DEPRECATION
0005
0006 /*******************************************************************/
0007 #include <stddef.h>
0008 #include <stdio.h>
0009 #include <stdlib.h>
0010 #include <string.h>
0011 #include <assert.h>
0012 #define G__DICTIONARY
0013 #include "RConfig.h"
0014 #include "TClass.h"
0015 #include "TDictAttributeMap.h"
0016 #include "TInterpreter.h"
0017 #include "TROOT.h"
0018 #include "TBuffer.h"
0019 #include "TMemberInspector.h"
0020 #include "TInterpreter.h"
0021 #include "TVirtualMutex.h"
0022 #include "TError.h"
0023
0024 #ifndef G__ROOT
0025 #define G__ROOT
0026 #endif
0027
0028 #include "RtypesImp.h"
0029 #include "TIsAProxy.h"
0030 #include "TFileMergeInfo.h"
0031 #include <algorithm>
0032 #include "TCollectionProxyInfo.h"
0033 /*******************************************************************/
0034
0035 #include "TDataMember.h"
0036
0037 // The generated code does not explicitly qualifies STL entities
0038 namespace std {} using namespace std;
0039
0040 // Header files passed as explicit arguments
0041 #include "/sphenix/u/weihuma/analysis/EventMix/src/sPHElectronPairContainerv1.h"
0042
0043 // Header files passed via #pragma extra_include
0044
0045 namespace ROOT {
0046    static void *new_sPHElectronPairContainerv1(void *p = 0);
0047    static void *newArray_sPHElectronPairContainerv1(Long_t size, void *p);
0048    static void delete_sPHElectronPairContainerv1(void *p);
0049    static void deleteArray_sPHElectronPairContainerv1(void *p);
0050    static void destruct_sPHElectronPairContainerv1(void *p);
0051
0052    // Function generating the singleton type initializer
0053    static TGenericClassInfo *GenerateInitInstanceLocal(const ::sPHElectronPairContainerv1*)
0054    {
0055       ::sPHElectronPairContainerv1 *ptr = 0;
0056       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::sPHElectronPairContainerv1 >(0);
0057       static ::ROOT::TGenericClassInfo
0058          instance("sPHElectronPairContainerv1", ::sPHElectronPairContainerv1::Class_Version(), "", 13,
0059                   typeid(::sPHElectronPairContainerv1), ::ROOT::Internal::DefineBehavior(ptr, ptr),
0060                   &::sPHElectronPairContainerv1::Dictionary, isa_proxy, 4,
0061                   sizeof(::sPHElectronPairContainerv1) );
0062       instance.SetNew(&new_sPHElectronPairContainerv1);
0063       instance.SetNewArray(&newArray_sPHElectronPairContainerv1);
0064       instance.SetDelete(&delete_sPHElectronPairContainerv1);
0065       instance.SetDeleteArray(&deleteArray_sPHElectronPairContainerv1);
0066       instance.SetDestructor(&destruct_sPHElectronPairContainerv1);
0067       return &instance;
0068    }
0069    TGenericClassInfo *GenerateInitInstance(const ::sPHElectronPairContainerv1*)
0070    {
0071       return GenerateInitInstanceLocal((::sPHElectronPairContainerv1*)0);
0072    }
0073    // Static variable to force the class initialization
0074    static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sPHElectronPairContainerv1*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
0075 } // end of namespace ROOT
0076
0077 //______________________________________________________________________________
0078 atomic_TClass_ptr sPHElectronPairContainerv1::fgIsA(0);  // static to hold class pointer
0079
0080 //______________________________________________________________________________
0081 const char *sPHElectronPairContainerv1::Class_Name()
0082 {
0083    return "sPHElectronPairContainerv1";
0084 }
0085
0086 //______________________________________________________________________________
0087 const char *sPHElectronPairContainerv1::ImplFileName()
0088 {
0089    return ::ROOT::GenerateInitInstanceLocal((const ::sPHElectronPairContainerv1*)0x0)->GetImplFileName();
0090 }
0091
0092 //______________________________________________________________________________
0093 int sPHElectronPairContainerv1::ImplFileLine()
0094 {
0095    return ::ROOT::GenerateInitInstanceLocal((const ::sPHElectronPairContainerv1*)0x0)->GetImplFileLine();
0096 }
0097
0098 //______________________________________________________________________________
0099 TClass *sPHElectronPairContainerv1::Dictionary()
0100 {
0101    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::sPHElectronPairContainerv1*)0x0)->GetClass();
0102    return fgIsA;
0103 }
0104
0105 //______________________________________________________________________________
0106 TClass *sPHElectronPairContainerv1::Class()
0107 {
0108    if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::sPHElectronPairContainerv1*)0x0)->GetClass(); }
0109    return fgIsA;
0110 }
0111
0112 //______________________________________________________________________________
0113 void sPHElectronPairContainerv1::Streamer(TBuffer &R__b)
0114 {
0115    // Stream an object of class sPHElectronPairContainerv1.
0116
0117    if (R__b.IsReading()) {
0118       R__b.ReadClassBuffer(sPHElectronPairContainerv1::Class(),this);
0119    } else {
0120       R__b.WriteClassBuffer(sPHElectronPairContainerv1::Class(),this);
0121    }
0122 }
0123
0124 namespace ROOT {
0125    // Wrappers around operator new
0126    static void *new_sPHElectronPairContainerv1(void *p) {
0127       return  p ? new(p) ::sPHElectronPairContainerv1 : new ::sPHElectronPairContainerv1;
0128    }
0129    static void *newArray_sPHElectronPairContainerv1(Long_t nElements, void *p) {
0130       return p ? new(p) ::sPHElectronPairContainerv1[nElements] : new ::sPHElectronPairContainerv1[nElements];
0131    }
0132    // Wrapper around operator delete
0133    static void delete_sPHElectronPairContainerv1(void *p) {
0134       delete ((::sPHElectronPairContainerv1*)p);
0135    }
0136    static void deleteArray_sPHElectronPairContainerv1(void *p) {
0137       delete [] ((::sPHElectronPairContainerv1*)p);
0138    }
0139    static void destruct_sPHElectronPairContainerv1(void *p) {
0140       typedef ::sPHElectronPairContainerv1 current_t;
0141       ((current_t*)p)->~current_t();
0142    }
0143 } // end of namespace ROOT for class ::sPHElectronPairContainerv1
0144
0145 namespace ROOT {
0146    static TClass *maplEunsignedsPintcOsPHElectronPairv1mUgR_Dictionary();
0147    static void maplEunsignedsPintcOsPHElectronPairv1mUgR_TClassManip(TClass*);
0148    static void *new_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p = 0);
0149    static void *newArray_maplEunsignedsPintcOsPHElectronPairv1mUgR(Long_t size, void *p);
0150    static void delete_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p);
0151    static void deleteArray_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p);
0152    static void destruct_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p);
0153
0154    // Function generating the singleton type initializer
0155    static TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,sPHElectronPairv1*>*)
0156    {
0157       map<unsigned int,sPHElectronPairv1*> *ptr = 0;
0158       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,sPHElectronPairv1*>));
0159       static ::ROOT::TGenericClassInfo
0160          instance("map<unsigned int,sPHElectronPairv1*>", -2, "map", 100,
0161                   typeid(map<unsigned int,sPHElectronPairv1*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
0162                   &maplEunsignedsPintcOsPHElectronPairv1mUgR_Dictionary, isa_proxy, 0,
0163                   sizeof(map<unsigned int,sPHElectronPairv1*>) );
0164       instance.SetNew(&new_maplEunsignedsPintcOsPHElectronPairv1mUgR);
0165       instance.SetNewArray(&newArray_maplEunsignedsPintcOsPHElectronPairv1mUgR);
0166       instance.SetDelete(&delete_maplEunsignedsPintcOsPHElectronPairv1mUgR);
0167       instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcOsPHElectronPairv1mUgR);
0168       instance.SetDestructor(&destruct_maplEunsignedsPintcOsPHElectronPairv1mUgR);
0169       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<unsigned int,sPHElectronPairv1*> >()));
0170
0171       ::ROOT::AddClassAlternate("map<unsigned int,sPHElectronPairv1*>","std::map<unsigned int, sPHElectronPairv1*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, sPHElectronPairv1*> > >");
0172       return &instance;
0173    }
0174    // Static variable to force the class initialization
0175    static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<unsigned int,sPHElectronPairv1*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
0176
0177    // Dictionary for non-ClassDef classes
0178    static TClass *maplEunsignedsPintcOsPHElectronPairv1mUgR_Dictionary() {
0179       TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<unsigned int,sPHElectronPairv1*>*)0x0)->GetClass();
0180       maplEunsignedsPintcOsPHElectronPairv1mUgR_TClassManip(theClass);
0181    return theClass;
0182    }
0183
0184    static void maplEunsignedsPintcOsPHElectronPairv1mUgR_TClassManip(TClass* ){
0185    }
0186
0187 } // end of namespace ROOT
0188
0189 namespace ROOT {
0190    // Wrappers around operator new
0191    static void *new_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p) {
0192       return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<unsigned int,sPHElectronPairv1*> : new map<unsigned int,sPHElectronPairv1*>;
0193    }
0194    static void *newArray_maplEunsignedsPintcOsPHElectronPairv1mUgR(Long_t nElements, void *p) {
0195       return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<unsigned int,sPHElectronPairv1*>[nElements] : new map<unsigned int,sPHElectronPairv1*>[nElements];
0196    }
0197    // Wrapper around operator delete
0198    static void delete_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p) {
0199       delete ((map<unsigned int,sPHElectronPairv1*>*)p);
0200    }
0201    static void deleteArray_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p) {
0202       delete [] ((map<unsigned int,sPHElectronPairv1*>*)p);
0203    }
0204    static void destruct_maplEunsignedsPintcOsPHElectronPairv1mUgR(void *p) {
0205       typedef map<unsigned int,sPHElectronPairv1*> current_t;
0206       ((current_t*)p)->~current_t();
0207    }
0208 } // end of namespace ROOT for class map<unsigned int,sPHElectronPairv1*>
0209
0210 namespace {
0211   void TriggerDictionaryInitialization_sPHElectronPairContainerv1_Dict_Impl() {
0212     static const char* headers[] = {
0213 "0",
0214 0
0215     };
0216     static const char* includePaths[] = {
0217 0
0218     };
0219     static const char* fwdDeclCode = R"DICTFWDDCLS(
0220 #line 1 "sPHElectronPairContainerv1_Dict dictionary forward declarations' payload"
0221 #pragma clang diagnostic ignored "-Wkeyword-compat"
0222 #pragma clang diagnostic ignored "-Wignored-attributes"
0223 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
0224 extern int __Cling_AutoLoading_Map;
0225 class sPHElectronPairContainerv1;
0226 )DICTFWDDCLS";
0227     static const char* payloadCode = R"DICTPAYLOAD(
0228 #line 1 "sPHElectronPairContainerv1_Dict dictionary payload"
0229
0230
0231 #define _BACKWARD_BACKWARD_WARNING_H
0232 // Inline headers
0233 #ifndef SPHELECTRONPAIRCONTAINER_V1_H
0234 #define SPHELECTRONPAIRCONTAINER_V1_H
0235
0236 #include "sPHElectronPair.h"
0237 #include "sPHElectronPairv1.h"
0238 #include "sPHElectronPairContainer.h"
0239
0240 #include <cstddef>        // for size_t
0241 #include <iostream>        // for cout, ostream
0242
0243 class sPHElectronPairContainerv1 : public sPHElectronPairContainer
0244 {
0245 public:
0246
0247   typedef std::map<unsigned int, sPHElectronPairv1*> PairMap;
0248   typedef std::map<unsigned int, sPHElectronPairv1*>::const_iterator ConstIter;
0249   typedef std::map<unsigned int, sPHElectronPairv1*>::iterator Iter;
0250
0251   sPHElectronPairContainerv1();
0252   sPHElectronPairContainerv1(const sPHElectronPairContainerv1& container);
0253   sPHElectronPairContainerv1& operator=(const sPHElectronPairContainerv1& container);
0254
0255   virtual ~sPHElectronPairContainerv1();
0256
0257   void identify(std::ostream& os = std::cout) const;
0258   void Reset();
0259   void clear() { Reset(); }
0260   int isValid() const { return 1; }
0261   size_t size() const { return _map.size(); }
0262   bool empty() const { return _map.empty(); }
0263   PHObject* CloneMe() const { return new sPHElectronPairContainerv1(*this); }
0264
0265   const sPHElectronPairv1* get(unsigned int idkey) const;
0266   sPHElectronPairv1* get(unsigned int idkey);
0267   void insert(const sPHElectronPairv1* pair);
0268   size_t erase(unsigned int idkey)
0269   {
0270     delete _map[idkey];
0271     return _map.erase(idkey);
0272   }
0273
0274   ConstIter begin() const { return _map.begin(); }
0275   ConstIter find(unsigned int idkey) const { return _map.find(idkey); }
0276   ConstIter end() const { return _map.end(); }
0277
0278   Iter begin() { return _map.begin(); }
0279   Iter find(unsigned int idkey) { return _map.find(idkey); }
0280   Iter end() { return _map.end(); }
0281
0282 protected:
0283   PairMap _map;
0284   ClassDef(sPHElectronPairContainerv1, 1);
0285
0286 };
0287
0288 #endif
0289
0290
0291 #undef  _BACKWARD_BACKWARD_WARNING_H
0292 )DICTPAYLOAD";
0293     static const char* classesHeaders[] = {
0294 "sPHElectronPairContainerv1", payloadCode, "@",
0295 nullptr
0296 };
0297     static bool isInitialized = false;
0298     if (!isInitialized) {
0299       TROOT::RegisterModule("sPHElectronPairContainerv1_Dict",
0300         headers, includePaths, payloadCode, fwdDeclCode,
0301         TriggerDictionaryInitialization_sPHElectronPairContainerv1_Dict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
0302       isInitialized = true;
0303     }
0304   }
0305   static struct DictInit {
0306     DictInit() {
0307       TriggerDictionaryInitialization_sPHElectronPairContainerv1_Dict_Impl();
0308     }
0309   } __TheDictionaryInitializer;
0310 }
0311 void TriggerDictionaryInitialization_sPHElectronPairContainerv1_Dict() {
0312   TriggerDictionaryInitialization_sPHElectronPairContainerv1_Dict_Impl();
0313 }