00001
00002
00003 #ifdef _WIN32
00004 #pragma warning ( disable : 4786 )
00005 #endif
00006 #define private public
00007 #define protected public
00008 #include "../GeneratorObject/McEventDict.h"
00009 #undef private
00010 #undef protected
00011 #include "ReflectionBuilder/ReflectionBuilder.h"
00012 #include <typeinfo>
00013 using namespace seal::reflect;
00014
00015
00016 class HepMcParticleLink_dict {
00017 public:
00018 HepMcParticleLink_dict();
00019 static void* constructor_2570( void* );
00020 static void* constructor_2571( void*, const std::vector<void*>& );
00021 static void* constructor_2572( void*, const std::vector<void*>& );
00022 static void* constructor_2573( void*, const std::vector<void*>& );
00023 static void* constructor_2574( void*, const std::vector<void*>& );
00024 };
00025 static HepMcParticleLink_dict instance_8;
00026
00027 HepMcParticleLink_dict::HepMcParticleLink_dict() {
00028 ClassBuilder _c_("HepMcParticleLink", "", typeid(HepMcParticleLink), sizeof(HepMcParticleLink),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
00029 _c_.addField("m_particle", "HepMC::GenParticle*", "", (int)(&((HepMcParticleLink*)64)->m_particle)-64, PRIVATE | TRANSIENT );
00030 _c_.addField("m_extBarcode", "HepMcParticleLink::ExtendedBarCode", "", (int)(&((HepMcParticleLink*)64)->m_extBarcode)-64, PRIVATE );
00031 _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", constructor_2570, PUBLIC);
00032 _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "unsigned int; unsigned int=", constructor_2571, PUBLIC);
00033 _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMC::GenParticle*; unsigned int=", constructor_2572, PUBLIC);
00034 _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMcParticleLink&", constructor_2573, PUBLIC);
00035 _c_.addMethod("HepMcParticleLink", "", "HepMcParticleLink", "HepMC::GenParticle*; HepMC::GenEvent*", constructor_2574, PUBLIC);
00036 _c_.build();
00037 }
00038
00039 void* HepMcParticleLink_dict::constructor_2570( void* mem) {
00040 return new(mem) HepMcParticleLink();
00041 }
00042
00043 void* HepMcParticleLink_dict::constructor_2571( void* mem, const std::vector<void*>& arg) {
00044 if ( arg.size() == 1 ) {
00045 return new(mem) HepMcParticleLink(*(unsigned int*)arg[0]);
00046 }
00047 else if ( arg.size() == 2 ) {
00048 return new(mem) HepMcParticleLink(*(unsigned int*)arg[0],
00049 *(unsigned int*)arg[1]);
00050 }
00051 return 0;
00052 }
00053
00054 void* HepMcParticleLink_dict::constructor_2572( void* mem, const std::vector<void*>& arg) {
00055 if ( arg.size() == 1 ) {
00056 return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0]);
00057 }
00058 else if ( arg.size() == 2 ) {
00059 return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0],
00060 *(unsigned int*)arg[1]);
00061 }
00062 return 0;
00063 }
00064
00065 void* HepMcParticleLink_dict::constructor_2573( void* mem, const std::vector<void*>& arg) {
00066 return new(mem) HepMcParticleLink(*(const HepMcParticleLink*)arg[0]);
00067 }
00068
00069 void* HepMcParticleLink_dict::constructor_2574( void* mem, const std::vector<void*>& arg) {
00070 return new(mem) HepMcParticleLink((const HepMC::GenParticle*)arg[0],
00071 (const HepMC::GenEvent*)arg[1]);
00072 }
00073
00074
00075 class McEventCollection_dict {
00076 public:
00077 McEventCollection_dict();
00078 static int tobase_2585(void*);
00079 static void* constructor_2586( void*, const std::vector<void*>& );
00080 static void* constructor_2587( void* );
00081 static void destructor( void* o ) { ((McEventCollection*)o)->~McEventCollection(); }
00082 };
00083 static McEventCollection_dict instance_16;
00084
00085 McEventCollection_dict::McEventCollection_dict() {
00086 ClassBuilder _c_("McEventCollection", "", typeid(McEventCollection), sizeof(McEventCollection),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00087 _c_.addSuperClass("DataVector<HepMC::GenEvent>", 0, tobase_2585);
00088 _c_.addMethod("McEventCollection", "", "McEventCollection", "McEventCollection&", constructor_2586, PUBLIC);
00089 _c_.addMethod("McEventCollection", "", "McEventCollection", constructor_2587, PUBLIC);
00090 _c_.addMethod("~McEventCollection", "", destructor, PUBLIC | VIRTUAL);
00091 _c_.addProperty("ClassID", (char*)"6DE62B45-7C72-4539-92F2-3A8E739A4AC3");
00092 _c_.build();
00093 }
00094
00095 int McEventCollection_dict::tobase_2585( void* o ) {
00096 return (int)(DataVector<HepMC::GenEvent>*)(McEventCollection*)o - (int)(McEventCollection*)o;
00097 }
00098
00099 void* McEventCollection_dict::constructor_2586( void* mem, const std::vector<void*>& arg) {
00100 return new(mem) McEventCollection(*(const McEventCollection*)arg[0]);
00101 }
00102
00103 void* McEventCollection_dict::constructor_2587( void* mem) {
00104 return new(mem) McEventCollection();
00105 }
00106
00107
00108 class HepLorentzVector_dict {
00109 public:
00110 HepLorentzVector_dict();
00111 static void* constructor_3161( void*, const std::vector<void*>& );
00112 static void* constructor_3162( void*, const std::vector<void*>& );
00113 static void* constructor_3163( void*, const std::vector<void*>& );
00114 static void* constructor_3164( void* );
00115 static void* constructor_3165( void*, const std::vector<void*>& );
00116 static void* constructor_3166( void*, const std::vector<void*>& );
00117 static void* constructor_3167( void*, const std::vector<void*>& );
00118 static void destructor( void* o ) { ((HepLorentzVector*)o)->~HepLorentzVector(); }
00119 static void* constructor_3256( void*, const std::vector<void*>& );
00120 static void* constructor_3258( void*, const std::vector<void*>& );
00121 static void* constructor_3261( void*, const std::vector<void*>& );
00122 static void* constructor_3263( void*, const std::vector<void*>& );
00123 };
00124 static HepLorentzVector_dict instance_241;
00125
00126 HepLorentzVector_dict::HepLorentzVector_dict() {
00127 ClassBuilder _c_("HepLorentzVector", "", typeid(HepLorentzVector), sizeof(HepLorentzVector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
00128 _c_.addField("pp", "Hep3Vector", "", (int)(&((HepLorentzVector*)64)->pp)-64, PRIVATE );
00129 _c_.addField("ee", "double", "", (int)(&((HepLorentzVector*)64)->ee)-64, PRIVATE );
00130 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double; double", constructor_3161, PUBLIC);
00131 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double", constructor_3162, PUBLIC);
00132 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double", constructor_3163, PUBLIC);
00133 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", constructor_3164, PUBLIC);
00134 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Hep3Vector&; double", constructor_3165, PUBLIC);
00135 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; Hep3Vector&", constructor_3166, PUBLIC);
00136 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "HepLorentzVector&", constructor_3167, PUBLIC);
00137 _c_.addMethod("~HepLorentzVector", "", destructor, PUBLIC);
00138 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "double; double; double; Tcomponent", constructor_3256, PUBLIC);
00139 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Tcomponent; double; double; double", constructor_3258, PUBLIC);
00140 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Tcomponent", constructor_3261, PUBLIC);
00141 _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", "Hep3Vector&", constructor_3263, PUBLIC);
00142 _c_.build();
00143 }
00144
00145 void* HepLorentzVector_dict::constructor_3161( void* mem, const std::vector<void*>& arg) {
00146 return new(mem) HepLorentzVector(*(double*)arg[0],
00147 *(double*)arg[1],
00148 *(double*)arg[2],
00149 *(double*)arg[3]);
00150 }
00151
00152 void* HepLorentzVector_dict::constructor_3162( void* mem, const std::vector<void*>& arg) {
00153 return new(mem) HepLorentzVector(*(double*)arg[0],
00154 *(double*)arg[1],
00155 *(double*)arg[2]);
00156 }
00157
00158 void* HepLorentzVector_dict::constructor_3163( void* mem, const std::vector<void*>& arg) {
00159 return new(mem) HepLorentzVector(*(double*)arg[0]);
00160 }
00161
00162 void* HepLorentzVector_dict::constructor_3164( void* mem) {
00163 return new(mem) HepLorentzVector();
00164 }
00165
00166 void* HepLorentzVector_dict::constructor_3165( void* mem, const std::vector<void*>& arg) {
00167 return new(mem) HepLorentzVector(*(const Hep3Vector*)arg[0],
00168 *(double*)arg[1]);
00169 }
00170
00171 void* HepLorentzVector_dict::constructor_3166( void* mem, const std::vector<void*>& arg) {
00172 return new(mem) HepLorentzVector(*(double*)arg[0],
00173 *(const Hep3Vector*)arg[1]);
00174 }
00175
00176 void* HepLorentzVector_dict::constructor_3167( void* mem, const std::vector<void*>& arg) {
00177 return new(mem) HepLorentzVector(*(const HepLorentzVector*)arg[0]);
00178 }
00179
00180 void* HepLorentzVector_dict::constructor_3256( void* mem, const std::vector<void*>& arg) {
00181 return new(mem) HepLorentzVector(*(double*)arg[0],
00182 *(double*)arg[1],
00183 *(double*)arg[2],
00184 *(Tcomponent*)arg[3]);
00185 }
00186
00187 void* HepLorentzVector_dict::constructor_3258( void* mem, const std::vector<void*>& arg) {
00188 return new(mem) HepLorentzVector(*(Tcomponent*)arg[0],
00189 *(double*)arg[1],
00190 *(double*)arg[2],
00191 *(double*)arg[3]);
00192 }
00193
00194 void* HepLorentzVector_dict::constructor_3261( void* mem, const std::vector<void*>& arg) {
00195 return new(mem) HepLorentzVector(*(Tcomponent*)arg[0]);
00196 }
00197
00198 void* HepLorentzVector_dict::constructor_3263( void* mem, const std::vector<void*>& arg) {
00199 return new(mem) HepLorentzVector(*(const Hep3Vector*)arg[0]);
00200 }
00201
00202
00203 class Hep3Vector_dict {
00204 public:
00205 Hep3Vector_dict();
00206 static void* constructor_3332( void*, const std::vector<void*>& );
00207 static void* constructor_3333( void*, const std::vector<void*>& );
00208 static void destructor( void* o ) { ((Hep3Vector*)o)->~Hep3Vector(); }
00209 static void* constructor_x0( void* );
00210 };
00211 static Hep3Vector_dict instance_271;
00212
00213 Hep3Vector_dict::Hep3Vector_dict() {
00214 ClassBuilder _c_("Hep3Vector", "", typeid(Hep3Vector), sizeof(Hep3Vector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
00215 _c_.addField("dx", "double", "", (int)(&((Hep3Vector*)64)->dx)-64, PROTECTED );
00216 _c_.addField("dy", "double", "", (int)(&((Hep3Vector*)64)->dy)-64, PROTECTED );
00217 _c_.addField("dz", "double", "", (int)(&((Hep3Vector*)64)->dz)-64, PROTECTED );
00218 _c_.addMethod("Hep3Vector", "", "Hep3Vector", "double=; double=; double=", constructor_3332, PUBLIC);
00219 _c_.addMethod("Hep3Vector", "", "Hep3Vector", "Hep3Vector&", constructor_3333, PUBLIC);
00220 _c_.addMethod("~Hep3Vector", "", destructor, PUBLIC);
00221 _c_.addMethod("Hep3Vector", "", "Hep3Vector", constructor_x0, PUBLIC);
00222 _c_.build();
00223 }
00224
00225 void* Hep3Vector_dict::constructor_3332( void* mem, const std::vector<void*>& arg) {
00226 if ( arg.size() == 0 ) {
00227 return new(mem) Hep3Vector();
00228 }
00229 else if ( arg.size() == 1 ) {
00230 return new(mem) Hep3Vector(*(double*)arg[0]);
00231 }
00232 else if ( arg.size() == 2 ) {
00233 return new(mem) Hep3Vector(*(double*)arg[0],
00234 *(double*)arg[1]);
00235 }
00236 else if ( arg.size() == 3 ) {
00237 return new(mem) Hep3Vector(*(double*)arg[0],
00238 *(double*)arg[1],
00239 *(double*)arg[2]);
00240 }
00241 return 0;
00242 }
00243
00244 void* Hep3Vector_dict::constructor_3333( void* mem, const std::vector<void*>& arg) {
00245 return new(mem) Hep3Vector(*(const Hep3Vector*)arg[0]);
00246 }
00247
00248 void* Hep3Vector_dict::constructor_x0( void* mem) {
00249 return new(mem) Hep3Vector();
00250 }
00251
00252
00253 class std__basic_string_char__dict {
00254 public:
00255 std__basic_string_char__dict();
00256 static void* constructor_5273( void* );
00257 static void* constructor_5274( void*, const std::vector<void*>& );
00258 static void* constructor_5275( void*, const std::vector<void*>& );
00259 static void* constructor_5276( void*, const std::vector<void*>& );
00260 static void* constructor_5277( void*, const std::vector<void*>& );
00261 static void* constructor_5278( void*, const std::vector<void*>& );
00262 static void* constructor_5279( void*, const std::vector<void*>& );
00263 static void* constructor_5280( void*, const std::vector<void*>& );
00264 static void destructor( void* o ) { ((std::basic_string<char>*)o)->~basic_string(); }
00265 };
00266 static std__basic_string_char__dict instance_2526;
00267
00268 std__basic_string_char__dict::std__basic_string_char__dict() {
00269 ClassBuilder _c_("std::basic_string<char>", "", typeid(std::basic_string<char>), sizeof(std::basic_string<char>),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
00270 _c_.addField("_M_dataplus", "std::basic_string<char>::_Alloc_hider", "", (int)(&((std::basic_string<char>*)64)->_M_dataplus)-64, PRIVATE );
00271 _c_.addMethod("basic_string", "", "std::basic_string<char>", constructor_5273, PUBLIC);
00272 _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::allocator<char>&", constructor_5274, PUBLIC);
00273 _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&", constructor_5275, PUBLIC);
00274 _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&; unsigned int; unsigned int=", constructor_5276, PUBLIC);
00275 _c_.addMethod("basic_string", "", "std::basic_string<char>", "std::basic_string<char>&; unsigned int; unsigned int; std::allocator<char>&", constructor_5277, PUBLIC);
00276 _c_.addMethod("basic_string", "", "std::basic_string<char>", "char*; unsigned int; std::allocator<char>&=", constructor_5278, PUBLIC);
00277 _c_.addMethod("basic_string", "", "std::basic_string<char>", "char*; std::allocator<char>&=", constructor_5279, PUBLIC);
00278 _c_.addMethod("basic_string", "", "std::basic_string<char>", "unsigned int; char; std::allocator<char>&=", constructor_5280, PUBLIC);
00279 _c_.addMethod("~basic_string", "", destructor, PUBLIC);
00280 _c_.build();
00281 }
00282
00283 void* std__basic_string_char__dict::constructor_5273( void* mem) {
00284 return new(mem) std::basic_string<char>();
00285 }
00286
00287 void* std__basic_string_char__dict::constructor_5274( void* mem, const std::vector<void*>& arg) {
00288 return new(mem) std::basic_string<char>(*(const std::allocator<char>*)arg[0]);
00289 }
00290
00291 void* std__basic_string_char__dict::constructor_5275( void* mem, const std::vector<void*>& arg) {
00292 return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0]);
00293 }
00294
00295 void* std__basic_string_char__dict::constructor_5276( void* mem, const std::vector<void*>& arg) {
00296 if ( arg.size() == 2 ) {
00297 return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
00298 *(unsigned int*)arg[1]);
00299 }
00300 else if ( arg.size() == 3 ) {
00301 return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
00302 *(unsigned int*)arg[1],
00303 *(unsigned int*)arg[2]);
00304 }
00305 return 0;
00306 }
00307
00308 void* std__basic_string_char__dict::constructor_5277( void* mem, const std::vector<void*>& arg) {
00309 return new(mem) std::basic_string<char>(*(const std::basic_string<char>*)arg[0],
00310 *(unsigned int*)arg[1],
00311 *(unsigned int*)arg[2],
00312 *(const std::allocator<char>*)arg[3]);
00313 }
00314
00315 void* std__basic_string_char__dict::constructor_5278( void* mem, const std::vector<void*>& arg) {
00316 if ( arg.size() == 2 ) {
00317 return new(mem) std::basic_string<char>((const char*)arg[0],
00318 *(unsigned int*)arg[1]);
00319 }
00320 else if ( arg.size() == 3 ) {
00321 return new(mem) std::basic_string<char>((const char*)arg[0],
00322 *(unsigned int*)arg[1],
00323 *(const std::allocator<char>*)arg[2]);
00324 }
00325 return 0;
00326 }
00327
00328 void* std__basic_string_char__dict::constructor_5279( void* mem, const std::vector<void*>& arg) {
00329 if ( arg.size() == 1 ) {
00330 return new(mem) std::basic_string<char>((const char*)arg[0]);
00331 }
00332 else if ( arg.size() == 2 ) {
00333 return new(mem) std::basic_string<char>((const char*)arg[0],
00334 *(const std::allocator<char>*)arg[1]);
00335 }
00336 return 0;
00337 }
00338
00339 void* std__basic_string_char__dict::constructor_5280( void* mem, const std::vector<void*>& arg) {
00340 if ( arg.size() == 2 ) {
00341 return new(mem) std::basic_string<char>(*(unsigned int*)arg[0],
00342 *(char*)arg[1]);
00343 }
00344 else if ( arg.size() == 3 ) {
00345 return new(mem) std::basic_string<char>(*(unsigned int*)arg[0],
00346 *(char*)arg[1],
00347 *(const std::allocator<char>*)arg[2]);
00348 }
00349 return 0;
00350 }
00351
00352
00353 class HepMcParticleLink__ExtendedBarCode_dict {
00354 public:
00355 HepMcParticleLink__ExtendedBarCode_dict();
00356 static void* constructor_5408( void* );
00357 static void* constructor_5409( void*, const std::vector<void*>& );
00358 static void* constructor_5410( void*, const std::vector<void*>& );
00359 };
00360 static HepMcParticleLink__ExtendedBarCode_dict instance_2569;
00361
00362 HepMcParticleLink__ExtendedBarCode_dict::HepMcParticleLink__ExtendedBarCode_dict() {
00363 ClassBuilder _c_("HepMcParticleLink::ExtendedBarCode", "", typeid(HepMcParticleLink::ExtendedBarCode), sizeof(HepMcParticleLink::ExtendedBarCode),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PRIVATE);
00364 _c_.addField("m_extBC", "unsigned int", "", (int)(&((HepMcParticleLink::ExtendedBarCode*)64)->m_extBC)-64, PRIVATE );
00365 _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", constructor_5408, PUBLIC);
00366 _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", "unsigned int; unsigned int", constructor_5409, PUBLIC);
00367 _c_.addMethod("ExtendedBarCode", "", "HepMcParticleLink::ExtendedBarCode", "HepMcParticleLink::ExtendedBarCode&", constructor_5410, PUBLIC);
00368 _c_.build();
00369 }
00370
00371 void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5408( void* mem) {
00372 return new(mem) HepMcParticleLink::ExtendedBarCode();
00373 }
00374
00375 void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5409( void* mem, const std::vector<void*>& arg) {
00376 return new(mem) HepMcParticleLink::ExtendedBarCode(*(unsigned int*)arg[0],
00377 *(unsigned int*)arg[1]);
00378 }
00379
00380 void* HepMcParticleLink__ExtendedBarCode_dict::constructor_5410( void* mem, const std::vector<void*>& arg) {
00381 return new(mem) HepMcParticleLink::ExtendedBarCode(*(const HepMcParticleLink::ExtendedBarCode*)arg[0]);
00382 }
00383
00384
00385 class DataVector_HepMC__GenEvent__dict {
00386 public:
00387 DataVector_HepMC__GenEvent__dict();
00388 static void* constructor_5444( void*, const std::vector<void*>& );
00389 static void* constructor_5445( void*, const std::vector<void*>& );
00390 static void* constructor_5446( void*, const std::vector<void*>& );
00391 static void destructor( void* o ) { ((DataVector<HepMC::GenEvent>*)o)->~DataVector(); }
00392 static void* constructor_x1( void* );
00393 };
00394 static DataVector_HepMC__GenEvent__dict instance_2585;
00395
00396 DataVector_HepMC__GenEvent__dict::DataVector_HepMC__GenEvent__dict() {
00397 ClassBuilder _c_("DataVector<HepMC::GenEvent>", "", typeid(DataVector<HepMC::GenEvent>), sizeof(DataVector<HepMC::GenEvent>),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00398 _c_.addField("m_ownPolicy", "int", "", (int)(&((DataVector<HepMC::GenEvent>*)64)->m_ownPolicy)-64, PRIVATE );
00399 _c_.addField("m_pCont", "std::vector<HepMC::GenEvent*>", "", (int)(&((DataVector<HepMC::GenEvent>*)64)->m_pCont)-64, PRIVATE );
00400 _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "int=", constructor_5444, PUBLIC);
00401 _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "unsigned int; int=", constructor_5445, PUBLIC);
00402 _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", "DataVector<HepMC::GenEvent>&", constructor_5446, PUBLIC);
00403 _c_.addMethod("~DataVector", "", destructor, PUBLIC | VIRTUAL);
00404 _c_.addMethod("DataVector", "", "DataVector<HepMC::GenEvent>", constructor_x1, PUBLIC);
00405 _c_.build();
00406 }
00407
00408 void* DataVector_HepMC__GenEvent__dict::constructor_5444( void* mem, const std::vector<void*>& arg) {
00409 if ( arg.size() == 0 ) {
00410 return new(mem) DataVector<HepMC::GenEvent>();
00411 }
00412 else if ( arg.size() == 1 ) {
00413 return new(mem) DataVector<HepMC::GenEvent>(*(SG::OwnershipPolicy*)arg[0]);
00414 }
00415 return 0;
00416 }
00417
00418 void* DataVector_HepMC__GenEvent__dict::constructor_5445( void* mem, const std::vector<void*>& arg) {
00419 if ( arg.size() == 1 ) {
00420 return new(mem) DataVector<HepMC::GenEvent>(*(unsigned int*)arg[0]);
00421 }
00422 else if ( arg.size() == 2 ) {
00423 return new(mem) DataVector<HepMC::GenEvent>(*(unsigned int*)arg[0],
00424 *(SG::OwnershipPolicy*)arg[1]);
00425 }
00426 return 0;
00427 }
00428
00429 void* DataVector_HepMC__GenEvent__dict::constructor_5446( void* mem, const std::vector<void*>& arg) {
00430 return new(mem) DataVector<HepMC::GenEvent>(*(const DataVector<HepMC::GenEvent>*)arg[0]);
00431 }
00432
00433 void* DataVector_HepMC__GenEvent__dict::constructor_x1( void* mem) {
00434 return new(mem) DataVector<HepMC::GenEvent>();
00435 }
00436
00437
00438 class HepMC__Polarization_dict {
00439 public:
00440 HepMC__Polarization_dict();
00441 static void* constructor_5535( void*, const std::vector<void*>& );
00442 static void* constructor_5536( void*, const std::vector<void*>& );
00443 static void* constructor_5537( void*, const std::vector<void*>& );
00444 static void destructor( void* o ) { ((HepMC::Polarization*)o)->~Polarization(); }
00445 static void* constructor_x2( void* );
00446 };
00447 static HepMC__Polarization_dict instance_2595;
00448
00449 HepMC__Polarization_dict::HepMC__Polarization_dict() {
00450 ClassBuilder _c_("HepMC::Polarization", "", typeid(HepMC::Polarization), sizeof(HepMC::Polarization),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00451 _c_.addField("m_theta", "double", "", (int)(&((HepMC::Polarization*)64)->m_theta)-64, PRIVATE );
00452 _c_.addField("m_phi", "double", "", (int)(&((HepMC::Polarization*)64)->m_phi)-64, PRIVATE );
00453 _c_.addMethod("Polarization", "", "HepMC::Polarization", "double=; double=", constructor_5535, PUBLIC);
00454 _c_.addMethod("Polarization", "", "HepMC::Polarization", "HepMC::Polarization&", constructor_5536, PUBLIC);
00455 _c_.addMethod("Polarization", "", "HepMC::Polarization", "HepNormal3D&", constructor_5537, PUBLIC);
00456 _c_.addMethod("~Polarization", "", destructor, PUBLIC | VIRTUAL);
00457 _c_.addMethod("Polarization", "", "HepMC::Polarization", constructor_x2, PUBLIC);
00458 _c_.build();
00459 }
00460
00461 void* HepMC__Polarization_dict::constructor_5535( void* mem, const std::vector<void*>& arg) {
00462 if ( arg.size() == 0 ) {
00463 return new(mem) HepMC::Polarization();
00464 }
00465 else if ( arg.size() == 1 ) {
00466 return new(mem) HepMC::Polarization(*(double*)arg[0]);
00467 }
00468 else if ( arg.size() == 2 ) {
00469 return new(mem) HepMC::Polarization(*(double*)arg[0],
00470 *(double*)arg[1]);
00471 }
00472 return 0;
00473 }
00474
00475 void* HepMC__Polarization_dict::constructor_5536( void* mem, const std::vector<void*>& arg) {
00476 return new(mem) HepMC::Polarization(*(const HepMC::Polarization*)arg[0]);
00477 }
00478
00479 void* HepMC__Polarization_dict::constructor_5537( void* mem, const std::vector<void*>& arg) {
00480 return new(mem) HepMC::Polarization(*(const HepNormal3D*)arg[0]);
00481 }
00482
00483 void* HepMC__Polarization_dict::constructor_x2( void* mem) {
00484 return new(mem) HepMC::Polarization();
00485 }
00486
00487
00488 class HepMC__Flow_dict {
00489 public:
00490 HepMC__Flow_dict();
00491 static void* constructor_5555( void*, const std::vector<void*>& );
00492 static void* constructor_5556( void*, const std::vector<void*>& );
00493 static void destructor( void* o ) { ((HepMC::Flow*)o)->~Flow(); }
00494 static void* constructor_x3( void* );
00495 };
00496 static HepMC__Flow_dict instance_2596;
00497
00498 HepMC__Flow_dict::HepMC__Flow_dict() {
00499 ClassBuilder _c_("HepMC::Flow", "", typeid(HepMC::Flow), sizeof(HepMC::Flow),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00500 _c_.addField("m_particle_owner", "HepMC::GenParticle*", "", (int)(&((HepMC::Flow*)64)->m_particle_owner)-64, PRIVATE );
00501 _c_.addField("m_icode", "std::map<int,int>", "", (int)(&((HepMC::Flow*)64)->m_icode)-64, PRIVATE );
00502 _c_.addMethod("Flow", "", "HepMC::Flow", "HepMC::GenParticle*=", constructor_5555, PUBLIC);
00503 _c_.addMethod("Flow", "", "HepMC::Flow", "HepMC::Flow&", constructor_5556, PUBLIC);
00504 _c_.addMethod("~Flow", "", destructor, PUBLIC | VIRTUAL);
00505 _c_.addMethod("Flow", "", "HepMC::Flow", constructor_x3, PUBLIC);
00506 _c_.build();
00507 }
00508
00509 void* HepMC__Flow_dict::constructor_5555( void* mem, const std::vector<void*>& arg) {
00510 if ( arg.size() == 0 ) {
00511 return new(mem) HepMC::Flow();
00512 }
00513 else if ( arg.size() == 1 ) {
00514 return new(mem) HepMC::Flow((HepMC::GenParticle*)arg[0]);
00515 }
00516 return 0;
00517 }
00518
00519 void* HepMC__Flow_dict::constructor_5556( void* mem, const std::vector<void*>& arg) {
00520 return new(mem) HepMC::Flow(*(const HepMC::Flow*)arg[0]);
00521 }
00522
00523 void* HepMC__Flow_dict::constructor_x3( void* mem) {
00524 return new(mem) HepMC::Flow();
00525 }
00526
00527
00528 class HepMC__GenVertex_dict {
00529 public:
00530 HepMC__GenVertex_dict();
00531 static void* constructor_5590( void*, const std::vector<void*>& );
00532 static void* constructor_5591( void*, const std::vector<void*>& );
00533 static void destructor( void* o ) { ((HepMC::GenVertex*)o)->~GenVertex(); }
00534 static void* constructor_x4( void* );
00535 };
00536 static HepMC__GenVertex_dict instance_2597;
00537
00538 HepMC__GenVertex_dict::HepMC__GenVertex_dict() {
00539 ClassBuilder _c_("HepMC::GenVertex", "", typeid(HepMC::GenVertex), sizeof(HepMC::GenVertex),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00540 _c_.addField("m_position", "HepLorentzVector", "", (int)(&((HepMC::GenVertex*)64)->m_position)-64, PRIVATE );
00541 _c_.addField("m_particles_in", "std::set<HepMC::GenParticle*>", "", (int)(&((HepMC::GenVertex*)64)->m_particles_in)-64, PRIVATE );
00542 _c_.addField("m_particles_out", "std::set<HepMC::GenParticle*>", "", (int)(&((HepMC::GenVertex*)64)->m_particles_out)-64, PRIVATE );
00543 _c_.addField("m_id", "int", "", (int)(&((HepMC::GenVertex*)64)->m_id)-64, PRIVATE );
00544 _c_.addField("m_weights", "HepMC::WeightContainer", "", (int)(&((HepMC::GenVertex*)64)->m_weights)-64, PRIVATE );
00545 _c_.addField("m_event", "HepMC::GenEvent*", "", (int)(&((HepMC::GenVertex*)64)->m_event)-64, PRIVATE );
00546 _c_.addField("m_barcode", "int", "", (int)(&((HepMC::GenVertex*)64)->m_barcode)-64, PRIVATE );
00547 _c_.addMethod("GenVertex", "", "HepMC::GenVertex", "HepLorentzVector&=; int=; HepMC::WeightContainer&=", constructor_5590, PUBLIC);
00548 _c_.addMethod("GenVertex", "", "HepMC::GenVertex", "HepMC::GenVertex&", constructor_5591, PUBLIC);
00549 _c_.addMethod("~GenVertex", "", destructor, PUBLIC | VIRTUAL);
00550 _c_.addMethod("GenVertex", "", "HepMC::GenVertex", constructor_x4, PUBLIC);
00551 _c_.build();
00552 }
00553
00554 void* HepMC__GenVertex_dict::constructor_5590( void* mem, const std::vector<void*>& arg) {
00555 if ( arg.size() == 0 ) {
00556 return new(mem) HepMC::GenVertex();
00557 }
00558 else if ( arg.size() == 1 ) {
00559 return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0]);
00560 }
00561 else if ( arg.size() == 2 ) {
00562 return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0],
00563 *(int*)arg[1]);
00564 }
00565 else if ( arg.size() == 3 ) {
00566 return new(mem) HepMC::GenVertex(*(const HepLorentzVector*)arg[0],
00567 *(int*)arg[1],
00568 *(const HepMC::WeightContainer*)arg[2]);
00569 }
00570 return 0;
00571 }
00572
00573 void* HepMC__GenVertex_dict::constructor_5591( void* mem, const std::vector<void*>& arg) {
00574 return new(mem) HepMC::GenVertex(*(const HepMC::GenVertex*)arg[0]);
00575 }
00576
00577 void* HepMC__GenVertex_dict::constructor_x4( void* mem) {
00578 return new(mem) HepMC::GenVertex();
00579 }
00580
00581
00582 class HepMC__GenEvent_dict {
00583 public:
00584 HepMC__GenEvent_dict();
00585 static void* constructor_5641( void*, const std::vector<void*>& );
00586 static void* constructor_5642( void*, const std::vector<void*>& );
00587 static void destructor( void* o ) { ((HepMC::GenEvent*)o)->~GenEvent(); }
00588 static void* constructor_x5( void* );
00589 };
00590 static HepMC__GenEvent_dict instance_2589;
00591
00592 HepMC__GenEvent_dict::HepMC__GenEvent_dict() {
00593 ClassBuilder _c_("HepMC::GenEvent", "", typeid(HepMC::GenEvent), sizeof(HepMC::GenEvent),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00594 _c_.addField("m_signal_process_id", "int", "", (int)(&((HepMC::GenEvent*)64)->m_signal_process_id)-64, PRIVATE );
00595 _c_.addField("m_event_number", "int", "", (int)(&((HepMC::GenEvent*)64)->m_event_number)-64, PRIVATE );
00596 _c_.addField("m_event_scale", "double", "", (int)(&((HepMC::GenEvent*)64)->m_event_scale)-64, PRIVATE );
00597 _c_.addField("m_alphaQCD", "double", "", (int)(&((HepMC::GenEvent*)64)->m_alphaQCD)-64, PRIVATE );
00598 _c_.addField("m_alphaQED", "double", "", (int)(&((HepMC::GenEvent*)64)->m_alphaQED)-64, PRIVATE );
00599 _c_.addField("m_signal_process_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenEvent*)64)->m_signal_process_vertex)-64, PRIVATE );
00600 _c_.addField("m_weights", "HepMC::WeightContainer", "", (int)(&((HepMC::GenEvent*)64)->m_weights)-64, PRIVATE );
00601 _c_.addField("m_random_states", "std::vector<long int>", "", (int)(&((HepMC::GenEvent*)64)->m_random_states)-64, PRIVATE );
00602 _c_.addField("m_vertex_barcodes", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "", (int)(&((HepMC::GenEvent*)64)->m_vertex_barcodes)-64, PRIVATE );
00603 _c_.addField("m_particle_barcodes", "std::map<int,HepMC::GenParticle*>", "", (int)(&((HepMC::GenEvent*)64)->m_particle_barcodes)-64, PRIVATE );
00604 _c_.addMethod("GenEvent", "", "HepMC::GenEvent", "int=; int=; HepMC::GenVertex*=; HepMC::WeightContainer&=; std::vector<long int>&=", constructor_5641, PUBLIC);
00605 _c_.addMethod("GenEvent", "", "HepMC::GenEvent", "HepMC::GenEvent&", constructor_5642, PUBLIC);
00606 _c_.addMethod("~GenEvent", "", destructor, PUBLIC | VIRTUAL);
00607 _c_.addMethod("GenEvent", "", "HepMC::GenEvent", constructor_x5, PUBLIC);
00608 _c_.build();
00609 }
00610
00611 void* HepMC__GenEvent_dict::constructor_5641( void* mem, const std::vector<void*>& arg) {
00612 if ( arg.size() == 0 ) {
00613 return new(mem) HepMC::GenEvent();
00614 }
00615 else if ( arg.size() == 1 ) {
00616 return new(mem) HepMC::GenEvent(*(int*)arg[0]);
00617 }
00618 else if ( arg.size() == 2 ) {
00619 return new(mem) HepMC::GenEvent(*(int*)arg[0],
00620 *(int*)arg[1]);
00621 }
00622 else if ( arg.size() == 3 ) {
00623 return new(mem) HepMC::GenEvent(*(int*)arg[0],
00624 *(int*)arg[1],
00625 (HepMC::GenVertex*)arg[2]);
00626 }
00627 else if ( arg.size() == 4 ) {
00628 return new(mem) HepMC::GenEvent(*(int*)arg[0],
00629 *(int*)arg[1],
00630 (HepMC::GenVertex*)arg[2],
00631 *(const HepMC::WeightContainer*)arg[3]);
00632 }
00633 else if ( arg.size() == 5 ) {
00634 return new(mem) HepMC::GenEvent(*(int*)arg[0],
00635 *(int*)arg[1],
00636 (HepMC::GenVertex*)arg[2],
00637 *(const HepMC::WeightContainer*)arg[3],
00638 *(const std::vector<long int>*)arg[4]);
00639 }
00640 return 0;
00641 }
00642
00643 void* HepMC__GenEvent_dict::constructor_5642( void* mem, const std::vector<void*>& arg) {
00644 return new(mem) HepMC::GenEvent(*(const HepMC::GenEvent*)arg[0]);
00645 }
00646
00647 void* HepMC__GenEvent_dict::constructor_x5( void* mem) {
00648 return new(mem) HepMC::GenEvent();
00649 }
00650
00651
00652 class HepMC__GenParticle_dict {
00653 public:
00654 HepMC__GenParticle_dict();
00655 static void* constructor_5693( void* );
00656 static void* constructor_5694( void*, const std::vector<void*>& );
00657 static void* constructor_5695( void*, const std::vector<void*>& );
00658 static void destructor( void* o ) { ((HepMC::GenParticle*)o)->~GenParticle(); }
00659 };
00660 static HepMC__GenParticle_dict instance_2594;
00661
00662 HepMC__GenParticle_dict::HepMC__GenParticle_dict() {
00663 ClassBuilder _c_("HepMC::GenParticle", "", typeid(HepMC::GenParticle), sizeof(HepMC::GenParticle),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00664 _c_.addField("m_momentum", "HepLorentzVector", "", (int)(&((HepMC::GenParticle*)64)->m_momentum)-64, PRIVATE );
00665 _c_.addField("m_pdg_id", "int", "", (int)(&((HepMC::GenParticle*)64)->m_pdg_id)-64, PRIVATE );
00666 _c_.addField("m_status", "int", "", (int)(&((HepMC::GenParticle*)64)->m_status)-64, PRIVATE );
00667 _c_.addField("m_flow", "HepMC::Flow", "", (int)(&((HepMC::GenParticle*)64)->m_flow)-64, PRIVATE );
00668 _c_.addField("m_polarization", "HepMC::Polarization", "", (int)(&((HepMC::GenParticle*)64)->m_polarization)-64, PRIVATE );
00669 _c_.addField("m_production_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenParticle*)64)->m_production_vertex)-64, PRIVATE );
00670 _c_.addField("m_end_vertex", "HepMC::GenVertex*", "", (int)(&((HepMC::GenParticle*)64)->m_end_vertex)-64, PRIVATE );
00671 _c_.addField("m_barcode", "int", "", (int)(&((HepMC::GenParticle*)64)->m_barcode)-64, PRIVATE );
00672 _c_.addMethod("GenParticle", "", "HepMC::GenParticle", constructor_5693, PUBLIC);
00673 _c_.addMethod("GenParticle", "", "HepMC::GenParticle", "HepLorentzVector&; int; int=; HepMC::Flow&=; HepMC::Polarization&=", constructor_5694, PUBLIC);
00674 _c_.addMethod("GenParticle", "", "HepMC::GenParticle", "HepMC::GenParticle&", constructor_5695, PUBLIC);
00675 _c_.addMethod("~GenParticle", "", destructor, PUBLIC | VIRTUAL);
00676 _c_.build();
00677 }
00678
00679 void* HepMC__GenParticle_dict::constructor_5693( void* mem) {
00680 return new(mem) HepMC::GenParticle();
00681 }
00682
00683 void* HepMC__GenParticle_dict::constructor_5694( void* mem, const std::vector<void*>& arg) {
00684 if ( arg.size() == 2 ) {
00685 return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
00686 *(int*)arg[1]);
00687 }
00688 else if ( arg.size() == 3 ) {
00689 return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
00690 *(int*)arg[1],
00691 *(int*)arg[2]);
00692 }
00693 else if ( arg.size() == 4 ) {
00694 return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
00695 *(int*)arg[1],
00696 *(int*)arg[2],
00697 *(const HepMC::Flow*)arg[3]);
00698 }
00699 else if ( arg.size() == 5 ) {
00700 return new(mem) HepMC::GenParticle(*(const HepLorentzVector*)arg[0],
00701 *(int*)arg[1],
00702 *(int*)arg[2],
00703 *(const HepMC::Flow*)arg[3],
00704 *(const HepMC::Polarization*)arg[4]);
00705 }
00706 return 0;
00707 }
00708
00709 void* HepMC__GenParticle_dict::constructor_5695( void* mem, const std::vector<void*>& arg) {
00710 return new(mem) HepMC::GenParticle(*(const HepMC::GenParticle*)arg[0]);
00711 }
00712
00713
00714 class HepMC__WeightContainer_dict {
00715 public:
00716 HepMC__WeightContainer_dict();
00717 static void* constructor_5726( void*, const std::vector<void*>& );
00718 static void* constructor_5727( void*, const std::vector<void*>& );
00719 static void* constructor_5728( void*, const std::vector<void*>& );
00720 static void destructor( void* o ) { ((HepMC::WeightContainer*)o)->~WeightContainer(); }
00721 static void* constructor_x6( void* );
00722 };
00723 static HepMC__WeightContainer_dict instance_3617;
00724
00725 HepMC__WeightContainer_dict::HepMC__WeightContainer_dict() {
00726 ClassBuilder _c_("HepMC::WeightContainer", "", typeid(HepMC::WeightContainer), sizeof(HepMC::WeightContainer),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC | VIRTUAL);
00727 _c_.addField("m_weights", "std::vector<double>", "", (int)(&((HepMC::WeightContainer*)64)->m_weights)-64, PRIVATE );
00728 _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "unsigned int=; double&=", constructor_5726, PUBLIC);
00729 _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "std::vector<double>&", constructor_5727, PUBLIC);
00730 _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", "HepMC::WeightContainer&", constructor_5728, PUBLIC);
00731 _c_.addMethod("~WeightContainer", "", destructor, PUBLIC | VIRTUAL);
00732 _c_.addMethod("WeightContainer", "", "HepMC::WeightContainer", constructor_x6, PUBLIC);
00733 _c_.build();
00734 }
00735
00736 void* HepMC__WeightContainer_dict::constructor_5726( void* mem, const std::vector<void*>& arg) {
00737 if ( arg.size() == 0 ) {
00738 return new(mem) HepMC::WeightContainer();
00739 }
00740 else if ( arg.size() == 1 ) {
00741 return new(mem) HepMC::WeightContainer(*(unsigned int*)arg[0]);
00742 }
00743 else if ( arg.size() == 2 ) {
00744 return new(mem) HepMC::WeightContainer(*(unsigned int*)arg[0],
00745 *(const double*)arg[1]);
00746 }
00747 return 0;
00748 }
00749
00750 void* HepMC__WeightContainer_dict::constructor_5727( void* mem, const std::vector<void*>& arg) {
00751 return new(mem) HepMC::WeightContainer(*(const std::vector<double>*)arg[0]);
00752 }
00753
00754 void* HepMC__WeightContainer_dict::constructor_5728( void* mem, const std::vector<void*>& arg) {
00755 return new(mem) HepMC::WeightContainer(*(const HepMC::WeightContainer*)arg[0]);
00756 }
00757
00758 void* HepMC__WeightContainer_dict::constructor_x6( void* mem) {
00759 return new(mem) HepMC::WeightContainer();
00760 }
00761
00762
00763 class std__vector_HepMC__GenEventp__dict {
00764 public:
00765 std__vector_HepMC__GenEventp__dict();
00766 static int tobase_6652(void*);
00767 static void* constructor_6687( void*, const std::vector<void*>& );
00768 static void* constructor_6688( void*, const std::vector<void*>& );
00769 static void* constructor_6689( void*, const std::vector<void*>& );
00770 static void* constructor_6690( void*, const std::vector<void*>& );
00771 static void destructor( void* o ) { ((std::vector<HepMC::GenEvent*>*)o)->~vector(); }
00772 static void* constructor_x7( void* );
00773 static void* method_x8( void*, const std::vector<void*>& );
00774 static void* method_x9( void*, const std::vector<void*>& );
00775 };
00776 static std__vector_HepMC__GenEventp__dict instance_5421;
00777
00778 std__vector_HepMC__GenEventp__dict::std__vector_HepMC__GenEventp__dict() {
00779 ClassBuilder _c_("std::vector<HepMC::GenEvent*>", "", typeid(std::vector<HepMC::GenEvent*>), sizeof(std::vector<HepMC::GenEvent*>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
00780 _c_.addSuperClass("std::_Vector_base<HepMC::GenEvent*,std::allocator<HepMC::GenEvent*> >", 0, tobase_6652);
00781 _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "std::allocator<HepMC::GenEvent*>&=", constructor_6687, PUBLIC);
00782 _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "unsigned int; HepMC::GenEvent*&; std::allocator<HepMC::GenEvent*>&=", constructor_6688, PUBLIC);
00783 _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "unsigned int", constructor_6689, PUBLIC);
00784 _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", "std::vector<HepMC::GenEvent*>&", constructor_6690, PUBLIC);
00785 _c_.addMethod("~vector", "", destructor, PUBLIC);
00786 _c_.addMethod("vector", "", "std::vector<HepMC::GenEvent*>", constructor_x7, PUBLIC);
00787 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x8);
00788 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x9);
00789 _c_.build();
00790 }
00791
00792 int std__vector_HepMC__GenEventp__dict::tobase_6652( void* o ) {
00793 return (int)(std::_Vector_base<HepMC::GenEvent*,std::allocator<HepMC::GenEvent*> >*)(std::vector<HepMC::GenEvent*>*)o - (int)(std::vector<HepMC::GenEvent*>*)o;
00794 }
00795
00796 void* std__vector_HepMC__GenEventp__dict::constructor_6687( void* mem, const std::vector<void*>& arg) {
00797 if ( arg.size() == 0 ) {
00798 return new(mem) std::vector<HepMC::GenEvent*>();
00799 }
00800 else if ( arg.size() == 1 ) {
00801 return new(mem) std::vector<HepMC::GenEvent*>(*(const std::allocator<HepMC::GenEvent*>*)arg[0]);
00802 }
00803 return 0;
00804 }
00805
00806 void* std__vector_HepMC__GenEventp__dict::constructor_6688( void* mem, const std::vector<void*>& arg) {
00807 if ( arg.size() == 2 ) {
00808 return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0],
00809 *(HepMC::GenEvent* const*)arg[1]);
00810 }
00811 else if ( arg.size() == 3 ) {
00812 return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0],
00813 *(HepMC::GenEvent* const*)arg[1],
00814 *(const std::allocator<HepMC::GenEvent*>*)arg[2]);
00815 }
00816 return 0;
00817 }
00818
00819 void* std__vector_HepMC__GenEventp__dict::constructor_6689( void* mem, const std::vector<void*>& arg) {
00820 return new(mem) std::vector<HepMC::GenEvent*>(*(unsigned int*)arg[0]);
00821 }
00822
00823 void* std__vector_HepMC__GenEventp__dict::constructor_6690( void* mem, const std::vector<void*>& arg) {
00824 return new(mem) std::vector<HepMC::GenEvent*>(*(const std::vector<HepMC::GenEvent*>*)arg[0]);
00825 }
00826
00827 void* std__vector_HepMC__GenEventp__dict::constructor_x7( void* mem) {
00828 return new(mem) std::vector<HepMC::GenEvent*>();
00829 }
00830
00831 void* std__vector_HepMC__GenEventp__dict::method_x8( void* o, const std::vector<void*>& args)
00832 {
00833 std::vector<HepMC::GenEvent*>* v = (std::vector<HepMC::GenEvent*>*)o;
00834 size_t n = v->size();
00835 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
00836 for(std::vector<HepMC::GenEvent*>::iterator i = v->begin(); i != v->end(); i++) {
00837 ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
00838 }
00839 return 0;
00840 }
00841
00842 void* std__vector_HepMC__GenEventp__dict::method_x9( void* o, const std::vector<void*>& args)
00843 {
00844 std::vector<HepMC::GenEvent*>* v = (std::vector<HepMC::GenEvent*>*)o;
00845 size_t n = *(size_t*)args[1];
00846 if (n > 0) {
00847 for(size_t i = 0; i < n; i++) {
00848 std::vector<HepMC::GenEvent*>::value_type o = 0;
00849 ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
00850 v->push_back(o);
00851 }
00852 ;
00853 } return 0;
00854 }
00855
00856
00857 class std__map_int_int__dict {
00858 public:
00859 std__map_int_int__dict();
00860 static void destructor( void* o ) { ((std::map<int,int>*)o)->~map(); }
00861 static void* constructor_7188( void* );
00862 static void* constructor_7189( void*, const std::vector<void*>& );
00863 static void* constructor_7190( void*, const std::vector<void*>& );
00864 static void* method_x10( void*, const std::vector<void*>& );
00865 static void* method_x11( void*, const std::vector<void*>& );
00866 };
00867 static std__map_int_int__dict instance_5963;
00868
00869 std__map_int_int__dict::std__map_int_int__dict() {
00870 ClassBuilder _c_("std::map<int,int>", "", typeid(std::map<int,int>), sizeof(std::map<int,int>),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
00871 _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,int>,std::_Select1st<std::pair<const int,int> >,std::less<int>,std::allocator<std::pair<const int,int> > >", "", (int)(&((std::map<int,int>*)64)->_M_t)-64, PRIVATE );
00872 _c_.addMethod("~map", "", destructor, PUBLIC);
00873 _c_.addMethod("map", "", "std::map<int,int>", constructor_7188, PUBLIC);
00874 _c_.addMethod("map", "", "std::map<int,int>", "std::less<int>&; std::allocator<std::pair<const int,int> >&=", constructor_7189, PUBLIC);
00875 _c_.addMethod("map", "", "std::map<int,int>", "std::map<int,int>&", constructor_7190, PUBLIC);
00876 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x10);
00877 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x11);
00878 _c_.build();
00879 }
00880
00881 void* std__map_int_int__dict::constructor_7188( void* mem) {
00882 return new(mem) std::map<int,int>();
00883 }
00884
00885 void* std__map_int_int__dict::constructor_7189( void* mem, const std::vector<void*>& arg) {
00886 if ( arg.size() == 1 ) {
00887 return new(mem) std::map<int,int>(*(const std::less<int>*)arg[0]);
00888 }
00889 else if ( arg.size() == 2 ) {
00890 return new(mem) std::map<int,int>(*(const std::less<int>*)arg[0],
00891 *(const std::allocator<std::pair<const int,int> >*)arg[1]);
00892 }
00893 return 0;
00894 }
00895
00896 void* std__map_int_int__dict::constructor_7190( void* mem, const std::vector<void*>& arg) {
00897 return new(mem) std::map<int,int>(*(const std::map<int,int>*)arg[0]);
00898 }
00899
00900 void* std__map_int_int__dict::method_x10( void* o, const std::vector<void*>& args)
00901 {
00902 std::map<int,int>* v = (std::map<int,int>*)o;
00903 size_t n = v->size();
00904 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
00905 if ( n > 0 ) {
00906 for(std::map<int,int>::iterator i = v->begin(); i != v->end(); i++) {
00907 std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
00908 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
00909 }
00910 }
00911 return 0;
00912 }
00913
00914 void* std__map_int_int__dict::method_x11( void* o, const std::vector<void*>& args)
00915 {
00916 std::map<int,int>* v = (std::map<int,int>*)o;
00917 size_t n = *(size_t*)args[1];
00918 if (n > 0) {
00919 for(size_t i = 0; i < n; i++) {
00920 std::pair<std::map<int,int>::key_type, std::map<int,int>::value_type::second_type> t;
00921 std::pair<void*, void*> pt(&t.first, &t.second);
00922 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
00923 v->insert(t);
00924 }
00925 }
00926 return 0;
00927 }
00928
00929
00930 class std__set_HepMC__GenParticlep__dict {
00931 public:
00932 std__set_HepMC__GenParticlep__dict();
00933 static void destructor( void* o ) { ((std::set<HepMC::GenParticle*>*)o)->~set(); }
00934 static void* constructor_7245( void* );
00935 static void* constructor_7246( void*, const std::vector<void*>& );
00936 static void* constructor_7247( void*, const std::vector<void*>& );
00937 static void* method_x12( void*, const std::vector<void*>& );
00938 static void* method_x13( void*, const std::vector<void*>& );
00939 };
00940 static std__set_HepMC__GenParticlep__dict instance_6737;
00941
00942 std__set_HepMC__GenParticlep__dict::std__set_HepMC__GenParticlep__dict() {
00943 ClassBuilder _c_("std::set<HepMC::GenParticle*>", "", typeid(std::set<HepMC::GenParticle*>), sizeof(std::set<HepMC::GenParticle*>),std::vector<const std::type_info*>(), false, SET, 0, PUBLIC);
00944 _c_.addField("_M_t", "std::_Rb_tree<HepMC::GenParticle*,HepMC::GenParticle*,std::_Identity<HepMC::GenParticle*>,std::less<HepMC::GenParticle*>,std::allocator<HepMC::GenParticle*> >", "", (int)(&((std::set<HepMC::GenParticle*>*)64)->_M_t)-64, PRIVATE );
00945 _c_.addMethod("~set", "", destructor, PUBLIC);
00946 _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", constructor_7245, PUBLIC);
00947 _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", "std::less<HepMC::GenParticle*>&; std::allocator<HepMC::GenParticle*>&=", constructor_7246, PUBLIC);
00948 _c_.addMethod("set", "", "std::set<HepMC::GenParticle*>", "std::set<HepMC::GenParticle*>&", constructor_7247, PUBLIC);
00949 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x12);
00950 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x13);
00951 _c_.build();
00952 }
00953
00954 void* std__set_HepMC__GenParticlep__dict::constructor_7245( void* mem) {
00955 return new(mem) std::set<HepMC::GenParticle*>();
00956 }
00957
00958 void* std__set_HepMC__GenParticlep__dict::constructor_7246( void* mem, const std::vector<void*>& arg) {
00959 if ( arg.size() == 1 ) {
00960 return new(mem) std::set<HepMC::GenParticle*>(*(const std::less<HepMC::GenParticle*>*)arg[0]);
00961 }
00962 else if ( arg.size() == 2 ) {
00963 return new(mem) std::set<HepMC::GenParticle*>(*(const std::less<HepMC::GenParticle*>*)arg[0],
00964 *(const std::allocator<HepMC::GenParticle*>*)arg[1]);
00965 }
00966 return 0;
00967 }
00968
00969 void* std__set_HepMC__GenParticlep__dict::constructor_7247( void* mem, const std::vector<void*>& arg) {
00970 return new(mem) std::set<HepMC::GenParticle*>(*(const std::set<HepMC::GenParticle*>*)arg[0]);
00971 }
00972
00973 void* std__set_HepMC__GenParticlep__dict::method_x12( void* o, const std::vector<void*>& args)
00974 {
00975 std::set<HepMC::GenParticle*>* v = (std::set<HepMC::GenParticle*>*)o;
00976 size_t n = v->size();
00977 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
00978 for(std::set<HepMC::GenParticle*>::iterator i = v->begin(); i != v->end(); i++) {
00979 ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
00980 }
00981 return 0;
00982 }
00983
00984 void* std__set_HepMC__GenParticlep__dict::method_x13( void* o, const std::vector<void*>& args)
00985 {
00986 std::set<HepMC::GenParticle*>* v = (std::set<HepMC::GenParticle*>*)o;
00987 size_t n = *(size_t*)args[1];
00988 if (n > 0) {
00989 for(size_t i = 0; i < n; i++) {
00990 std::set<HepMC::GenParticle*>::value_type o = 0;
00991 ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
00992 v->insert(o);
00993 }
00994 ;
00995 } return 0;
00996 }
00997
00998
00999 class std__vector_longsint__dict {
01000 public:
01001 std__vector_longsint__dict();
01002 static int tobase_7315(void*);
01003 static void* constructor_7352( void*, const std::vector<void*>& );
01004 static void* constructor_7353( void*, const std::vector<void*>& );
01005 static void* constructor_7354( void*, const std::vector<void*>& );
01006 static void* constructor_7355( void*, const std::vector<void*>& );
01007 static void destructor( void* o ) { ((std::vector<long int>*)o)->~vector(); }
01008 static void* constructor_x14( void* );
01009 static void* method_x15( void*, const std::vector<void*>& );
01010 static void* method_x16( void*, const std::vector<void*>& );
01011 };
01012 static std__vector_longsint__dict instance_6816;
01013
01014 std__vector_longsint__dict::std__vector_longsint__dict() {
01015 ClassBuilder _c_("std::vector<long int>", "", typeid(std::vector<long int>), sizeof(std::vector<long int>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
01016 _c_.addSuperClass("std::_Vector_base<long int,std::allocator<long int> >", 0, tobase_7315);
01017 _c_.addMethod("vector", "", "std::vector<long int>", "std::allocator<long int>&=", constructor_7352, PUBLIC);
01018 _c_.addMethod("vector", "", "std::vector<long int>", "unsigned int; long int&; std::allocator<long int>&=", constructor_7353, PUBLIC);
01019 _c_.addMethod("vector", "", "std::vector<long int>", "unsigned int", constructor_7354, PUBLIC);
01020 _c_.addMethod("vector", "", "std::vector<long int>", "std::vector<long int>&", constructor_7355, PUBLIC);
01021 _c_.addMethod("~vector", "", destructor, PUBLIC);
01022 _c_.addMethod("vector", "", "std::vector<long int>", constructor_x14, PUBLIC);
01023 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x15);
01024 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x16);
01025 _c_.build();
01026 }
01027
01028 int std__vector_longsint__dict::tobase_7315( void* o ) {
01029 return (int)(std::_Vector_base<long int,std::allocator<long int> >*)(std::vector<long int>*)o - (int)(std::vector<long int>*)o;
01030 }
01031
01032 void* std__vector_longsint__dict::constructor_7352( void* mem, const std::vector<void*>& arg) {
01033 if ( arg.size() == 0 ) {
01034 return new(mem) std::vector<long int>();
01035 }
01036 else if ( arg.size() == 1 ) {
01037 return new(mem) std::vector<long int>(*(const std::allocator<long int>*)arg[0]);
01038 }
01039 return 0;
01040 }
01041
01042 void* std__vector_longsint__dict::constructor_7353( void* mem, const std::vector<void*>& arg) {
01043 if ( arg.size() == 2 ) {
01044 return new(mem) std::vector<long int>(*(unsigned int*)arg[0],
01045 *(const long int*)arg[1]);
01046 }
01047 else if ( arg.size() == 3 ) {
01048 return new(mem) std::vector<long int>(*(unsigned int*)arg[0],
01049 *(const long int*)arg[1],
01050 *(const std::allocator<long int>*)arg[2]);
01051 }
01052 return 0;
01053 }
01054
01055 void* std__vector_longsint__dict::constructor_7354( void* mem, const std::vector<void*>& arg) {
01056 return new(mem) std::vector<long int>(*(unsigned int*)arg[0]);
01057 }
01058
01059 void* std__vector_longsint__dict::constructor_7355( void* mem, const std::vector<void*>& arg) {
01060 return new(mem) std::vector<long int>(*(const std::vector<long int>*)arg[0]);
01061 }
01062
01063 void* std__vector_longsint__dict::constructor_x14( void* mem) {
01064 return new(mem) std::vector<long int>();
01065 }
01066
01067 void* std__vector_longsint__dict::method_x15( void* o, const std::vector<void*>& args)
01068 {
01069 std::vector<long int>* v = (std::vector<long int>*)o;
01070 size_t n = v->size();
01071 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
01072 for(std::vector<long int>::iterator i = v->begin(); i != v->end(); i++) {
01073 ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
01074 }
01075 return 0;
01076 }
01077
01078 void* std__vector_longsint__dict::method_x16( void* o, const std::vector<void*>& args)
01079 {
01080 std::vector<long int>* v = (std::vector<long int>*)o;
01081 size_t n = *(size_t*)args[1];
01082 if (n > 0) {
01083 for(size_t i = 0; i < n; i++) {
01084 std::vector<long int>::value_type o;
01085 ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
01086 v->push_back(o);
01087 }
01088 ;
01089 } return 0;
01090 }
01091
01092
01093 class std__map_int_HepMC__GenVertexp_std__greater_int_s__dict {
01094 public:
01095 std__map_int_HepMC__GenVertexp_std__greater_int_s__dict();
01096 static void destructor( void* o ) { ((std::map<int,HepMC::GenVertex*,std::greater<int> >*)o)->~map(); }
01097 static void* constructor_7402( void* );
01098 static void* constructor_7403( void*, const std::vector<void*>& );
01099 static void* constructor_7404( void*, const std::vector<void*>& );
01100 static void* method_x17( void*, const std::vector<void*>& );
01101 static void* method_x18( void*, const std::vector<void*>& );
01102 };
01103 static std__map_int_HepMC__GenVertexp_std__greater_int_s__dict instance_6817;
01104
01105 std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::std__map_int_HepMC__GenVertexp_std__greater_int_s__dict() {
01106 ClassBuilder _c_("std::map<int,HepMC::GenVertex*,std::greater<int> >", "", typeid(std::map<int,HepMC::GenVertex*,std::greater<int> >), sizeof(std::map<int,HepMC::GenVertex*,std::greater<int> >),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
01107 _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,HepMC::GenVertex*>,std::_Select1st<std::pair<const int,HepMC::GenVertex*> >,std::greater<int>,std::allocator<std::pair<const int,HepMC::GenVertex*> > >", "", (int)(&((std::map<int,HepMC::GenVertex*,std::greater<int> >*)64)->_M_t)-64, PRIVATE );
01108 _c_.addMethod("~map", "", destructor, PUBLIC);
01109 _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", constructor_7402, PUBLIC);
01110 _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "std::greater<int>&; std::allocator<std::pair<const int,HepMC::GenVertex*> >&=", constructor_7403, PUBLIC);
01111 _c_.addMethod("map", "", "std::map<int,HepMC::GenVertex*,std::greater<int> >", "std::map<int,HepMC::GenVertex*,std::greater<int> >&", constructor_7404, PUBLIC);
01112 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x17);
01113 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x18);
01114 _c_.build();
01115 }
01116
01117 void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7402( void* mem) {
01118 return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >();
01119 }
01120
01121 void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7403( void* mem, const std::vector<void*>& arg) {
01122 if ( arg.size() == 1 ) {
01123 return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::greater<int>*)arg[0]);
01124 }
01125 else if ( arg.size() == 2 ) {
01126 return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::greater<int>*)arg[0],
01127 *(const std::allocator<std::pair<const int,HepMC::GenVertex*> >*)arg[1]);
01128 }
01129 return 0;
01130 }
01131
01132 void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::constructor_7404( void* mem, const std::vector<void*>& arg) {
01133 return new(mem) std::map<int,HepMC::GenVertex*,std::greater<int> >(*(const std::map<int,HepMC::GenVertex*,std::greater<int> >*)arg[0]);
01134 }
01135
01136 void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::method_x17( void* o, const std::vector<void*>& args)
01137 {
01138 std::map<int,HepMC::GenVertex*,std::greater<int> >* v = (std::map<int,HepMC::GenVertex*,std::greater<int> >*)o;
01139 size_t n = v->size();
01140 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
01141 if ( n > 0 ) {
01142 for(std::map<int,HepMC::GenVertex*,std::greater<int> >::iterator i = v->begin(); i != v->end(); i++) {
01143 std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
01144 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
01145 }
01146 }
01147 return 0;
01148 }
01149
01150 void* std__map_int_HepMC__GenVertexp_std__greater_int_s__dict::method_x18( void* o, const std::vector<void*>& args)
01151 {
01152 std::map<int,HepMC::GenVertex*,std::greater<int> >* v = (std::map<int,HepMC::GenVertex*,std::greater<int> >*)o;
01153 size_t n = *(size_t*)args[1];
01154 if (n > 0) {
01155 for(size_t i = 0; i < n; i++) {
01156 std::pair<std::map<int,HepMC::GenVertex*,std::greater<int> >::key_type, std::map<int,HepMC::GenVertex*,std::greater<int> >::value_type::second_type> t;
01157 t.second = 0;
01158 std::pair<void*, void*> pt(&t.first, &t.second);
01159 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
01160 v->insert(t);
01161 }
01162 }
01163 return 0;
01164 }
01165
01166
01167 class std__map_int_HepMC__GenParticlep__dict {
01168 public:
01169 std__map_int_HepMC__GenParticlep__dict();
01170 static void destructor( void* o ) { ((std::map<int,HepMC::GenParticle*>*)o)->~map(); }
01171 static void* constructor_7461( void* );
01172 static void* constructor_7462( void*, const std::vector<void*>& );
01173 static void* constructor_7463( void*, const std::vector<void*>& );
01174 static void* method_x19( void*, const std::vector<void*>& );
01175 static void* method_x20( void*, const std::vector<void*>& );
01176 };
01177 static std__map_int_HepMC__GenParticlep__dict instance_6818;
01178
01179 std__map_int_HepMC__GenParticlep__dict::std__map_int_HepMC__GenParticlep__dict() {
01180 ClassBuilder _c_("std::map<int,HepMC::GenParticle*>", "", typeid(std::map<int,HepMC::GenParticle*>), sizeof(std::map<int,HepMC::GenParticle*>),std::vector<const std::type_info*>(), false, MAP, 0, PUBLIC);
01181 _c_.addField("_M_t", "std::_Rb_tree<int,std::pair<const int,HepMC::GenParticle*>,std::_Select1st<std::pair<const int,HepMC::GenParticle*> >,std::less<int>,std::allocator<std::pair<const int,HepMC::GenParticle*> > >", "", (int)(&((std::map<int,HepMC::GenParticle*>*)64)->_M_t)-64, PRIVATE );
01182 _c_.addMethod("~map", "", destructor, PUBLIC);
01183 _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", constructor_7461, PUBLIC);
01184 _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", "std::less<int>&; std::allocator<std::pair<const int,HepMC::GenParticle*> >&=", constructor_7462, PUBLIC);
01185 _c_.addMethod("map", "", "std::map<int,HepMC::GenParticle*>", "std::map<int,HepMC::GenParticle*>&", constructor_7463, PUBLIC);
01186 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x19);
01187 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x20);
01188 _c_.build();
01189 }
01190
01191 void* std__map_int_HepMC__GenParticlep__dict::constructor_7461( void* mem) {
01192 return new(mem) std::map<int,HepMC::GenParticle*>();
01193 }
01194
01195 void* std__map_int_HepMC__GenParticlep__dict::constructor_7462( void* mem, const std::vector<void*>& arg) {
01196 if ( arg.size() == 1 ) {
01197 return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::less<int>*)arg[0]);
01198 }
01199 else if ( arg.size() == 2 ) {
01200 return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::less<int>*)arg[0],
01201 *(const std::allocator<std::pair<const int,HepMC::GenParticle*> >*)arg[1]);
01202 }
01203 return 0;
01204 }
01205
01206 void* std__map_int_HepMC__GenParticlep__dict::constructor_7463( void* mem, const std::vector<void*>& arg) {
01207 return new(mem) std::map<int,HepMC::GenParticle*>(*(const std::map<int,HepMC::GenParticle*>*)arg[0]);
01208 }
01209
01210 void* std__map_int_HepMC__GenParticlep__dict::method_x19( void* o, const std::vector<void*>& args)
01211 {
01212 std::map<int,HepMC::GenParticle*>* v = (std::map<int,HepMC::GenParticle*>*)o;
01213 size_t n = v->size();
01214 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
01215 if ( n > 0 ) {
01216 for(std::map<int,HepMC::GenParticle*>::iterator i = v->begin(); i != v->end(); i++) {
01217 std::pair<void*,void*> pt((void*)&(*i).first, (void*)&(*i).second);
01218 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
01219 }
01220 }
01221 return 0;
01222 }
01223
01224 void* std__map_int_HepMC__GenParticlep__dict::method_x20( void* o, const std::vector<void*>& args)
01225 {
01226 std::map<int,HepMC::GenParticle*>* v = (std::map<int,HepMC::GenParticle*>*)o;
01227 size_t n = *(size_t*)args[1];
01228 if (n > 0) {
01229 for(size_t i = 0; i < n; i++) {
01230 std::pair<std::map<int,HepMC::GenParticle*>::key_type, std::map<int,HepMC::GenParticle*>::value_type::second_type> t;
01231 t.second = 0;
01232 std::pair<void*, void*> pt(&t.first, &t.second);
01233 ((void (*)(const void*, const std::vector<void*>&))args[2])(&pt, args);
01234 v->insert(t);
01235 }
01236 }
01237 return 0;
01238 }
01239
01240
01241 class std__vector_double__dict {
01242 public:
01243 std__vector_double__dict();
01244 static int tobase_7511(void*);
01245 static void* constructor_7548( void*, const std::vector<void*>& );
01246 static void* constructor_7549( void*, const std::vector<void*>& );
01247 static void* constructor_7550( void*, const std::vector<void*>& );
01248 static void* constructor_7551( void*, const std::vector<void*>& );
01249 static void destructor( void* o ) { ((std::vector<double>*)o)->~vector(); }
01250 static void* constructor_x21( void* );
01251 static void* method_x22( void*, const std::vector<void*>& );
01252 static void* method_x23( void*, const std::vector<void*>& );
01253 };
01254 static std__vector_double__dict instance_6870;
01255
01256 std__vector_double__dict::std__vector_double__dict() {
01257 ClassBuilder _c_("std::vector<double>", "", typeid(std::vector<double>), sizeof(std::vector<double>),std::vector<const std::type_info*>(), false, VECTOR, 0, PUBLIC);
01258 _c_.addSuperClass("std::_Vector_base<double,std::allocator<double> >", 0, tobase_7511);
01259 _c_.addMethod("vector", "", "std::vector<double>", "std::allocator<double>&=", constructor_7548, PUBLIC);
01260 _c_.addMethod("vector", "", "std::vector<double>", "unsigned int; double&; std::allocator<double>&=", constructor_7549, PUBLIC);
01261 _c_.addMethod("vector", "", "std::vector<double>", "unsigned int", constructor_7550, PUBLIC);
01262 _c_.addMethod("vector", "", "std::vector<double>", "std::vector<double>&", constructor_7551, PUBLIC);
01263 _c_.addMethod("~vector", "", destructor, PUBLIC);
01264 _c_.addMethod("vector", "", "std::vector<double>", constructor_x21, PUBLIC);
01265 _c_.addMethod("writeData", "", "void*", "std::vector<void*>", method_x22);
01266 _c_.addMethod("readData", "", "void*", "std::vector<void*>", method_x23);
01267 _c_.build();
01268 }
01269
01270 int std__vector_double__dict::tobase_7511( void* o ) {
01271 return (int)(std::_Vector_base<double,std::allocator<double> >*)(std::vector<double>*)o - (int)(std::vector<double>*)o;
01272 }
01273
01274 void* std__vector_double__dict::constructor_7548( void* mem, const std::vector<void*>& arg) {
01275 if ( arg.size() == 0 ) {
01276 return new(mem) std::vector<double>();
01277 }
01278 else if ( arg.size() == 1 ) {
01279 return new(mem) std::vector<double>(*(const std::allocator<double>*)arg[0]);
01280 }
01281 return 0;
01282 }
01283
01284 void* std__vector_double__dict::constructor_7549( void* mem, const std::vector<void*>& arg) {
01285 if ( arg.size() == 2 ) {
01286 return new(mem) std::vector<double>(*(unsigned int*)arg[0],
01287 *(const double*)arg[1]);
01288 }
01289 else if ( arg.size() == 3 ) {
01290 return new(mem) std::vector<double>(*(unsigned int*)arg[0],
01291 *(const double*)arg[1],
01292 *(const std::allocator<double>*)arg[2]);
01293 }
01294 return 0;
01295 }
01296
01297 void* std__vector_double__dict::constructor_7550( void* mem, const std::vector<void*>& arg) {
01298 return new(mem) std::vector<double>(*(unsigned int*)arg[0]);
01299 }
01300
01301 void* std__vector_double__dict::constructor_7551( void* mem, const std::vector<void*>& arg) {
01302 return new(mem) std::vector<double>(*(const std::vector<double>*)arg[0]);
01303 }
01304
01305 void* std__vector_double__dict::constructor_x21( void* mem) {
01306 return new(mem) std::vector<double>();
01307 }
01308
01309 void* std__vector_double__dict::method_x22( void* o, const std::vector<void*>& args)
01310 {
01311 std::vector<double>* v = (std::vector<double>*)o;
01312 size_t n = v->size();
01313 ((void (*)(size_t&, const std::vector<void*>&))args[1])(n, args);
01314 for(std::vector<double>::iterator i = v->begin(); i != v->end(); i++) {
01315 ((void (*)(const void*, const std::vector<void*>&))args[2])(&(*i), args);
01316 }
01317 return 0;
01318 }
01319
01320 void* std__vector_double__dict::method_x23( void* o, const std::vector<void*>& args)
01321 {
01322 std::vector<double>* v = (std::vector<double>*)o;
01323 size_t n = *(size_t*)args[1];
01324 if (n > 0) {
01325 for(size_t i = 0; i < n; i++) {
01326 std::vector<double>::value_type o;
01327 ((void (*)(const void*, const std::vector<void*>&))args[2])(&o, args);
01328 v->push_back(o);
01329 }
01330 ;
01331 } return 0;
01332 }
01333