StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
PythonWrapper.h
1 // Copyright (C) 2018 Torbjorn Sjostrand.
2 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
3 // Please respect the MCnet Guidelines, see GUIDELINES for details.
4 // Author: Philip Ilten, March 2016.
5 
6 // This file contains a Python interface to Pythia 8 generated with SWIG.
7 
8 /* ----------------------------------------------------------------------------
9  * This file was automatically generated by SWIG (http://www.swig.org).
10  * Version 3.0.8
11  *
12  * This file is not intended to be easily readable and contains a number of
13  * coding conventions designed to improve portability and efficiency. Do not make
14  * changes to this file unless you know what you are doing--modify the SWIG
15  * interface file instead.
16  * ----------------------------------------------------------------------------- */
17 
18 
19 #ifndef SWIGPYTHON
20 #define SWIGPYTHON
21 #endif
22 
23 #define SWIG_DIRECTORS
24 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
25 
26 
27 #ifdef __cplusplus
28 /* SwigValueWrapper is described in swig.swg */
29 template<typename T> class SwigValueWrapper {
30  struct SwigMovePointer {
31  T *ptr;
32  SwigMovePointer(T *p) : ptr(p) { }
33  ~SwigMovePointer() { delete ptr; }
34  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
35  } pointer;
36  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
37  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
38 public:
39  SwigValueWrapper() : pointer(0) { }
40  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
41  operator T&() const { return *pointer.ptr; }
42  T *operator&() { return pointer.ptr; }
43 };
44 
45 template <typename T> T SwigValueInit() {
46  return T();
47 }
48 #endif
49 
50 /* -----------------------------------------------------------------------------
51  * This section contains generic SWIG labels for method/variable
52  * declarations/attributes, and other compiler dependent labels.
53  * ----------------------------------------------------------------------------- */
54 
55 /* template workaround for compilers that cannot correctly implement the C++ standard */
56 #ifndef SWIGTEMPLATEDISAMBIGUATOR
57 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
58 # define SWIGTEMPLATEDISAMBIGUATOR template
59 # elif defined(__HP_aCC)
60 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
61 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
62 # define SWIGTEMPLATEDISAMBIGUATOR template
63 # else
64 # define SWIGTEMPLATEDISAMBIGUATOR
65 # endif
66 #endif
67 
68 /* inline attribute */
69 #ifndef SWIGINLINE
70 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
71 # define SWIGINLINE inline
72 # else
73 # define SWIGINLINE
74 # endif
75 #endif
76 
77 /* attribute recognised by some compilers to avoid 'unused' warnings */
78 #ifndef SWIGUNUSED
79 # if defined(__GNUC__)
80 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
81 # define SWIGUNUSED __attribute__ ((__unused__))
82 # else
83 # define SWIGUNUSED
84 # endif
85 # elif defined(__ICC)
86 # define SWIGUNUSED __attribute__ ((__unused__))
87 # else
88 # define SWIGUNUSED
89 # endif
90 #endif
91 
92 #ifndef SWIG_MSC_UNSUPPRESS_4505
93 # if defined(_MSC_VER)
94 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
95 # endif
96 #endif
97 
98 #ifndef SWIGUNUSEDPARM
99 # ifdef __cplusplus
100 # define SWIGUNUSEDPARM(p)
101 # else
102 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
103 # endif
104 #endif
105 
106 /* internal SWIG method */
107 #ifndef SWIGINTERN
108 # define SWIGINTERN static SWIGUNUSED
109 #endif
110 
111 /* internal inline SWIG method */
112 #ifndef SWIGINTERNINLINE
113 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
114 #endif
115 
116 /* exporting methods */
117 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
118 # ifndef GCC_HASCLASSVISIBILITY
119 # define GCC_HASCLASSVISIBILITY
120 # endif
121 #endif
122 
123 #ifndef SWIGEXPORT
124 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
125 # if defined(STATIC_LINKED)
126 # define SWIGEXPORT
127 # else
128 # define SWIGEXPORT __declspec(dllexport)
129 # endif
130 # else
131 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
132 # define SWIGEXPORT __attribute__ ((visibility("default")))
133 # else
134 # define SWIGEXPORT
135 # endif
136 # endif
137 #endif
138 
139 /* calling conventions for Windows */
140 #ifndef SWIGSTDCALL
141 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
142 # define SWIGSTDCALL __stdcall
143 # else
144 # define SWIGSTDCALL
145 # endif
146 #endif
147 
148 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
149 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
150 # define _CRT_SECURE_NO_DEPRECATE
151 #endif
152 
153 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
154 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
155 # define _SCL_SECURE_NO_DEPRECATE
156 #endif
157 
158 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
159 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
160 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
161 #endif
162 
163 /* Intel's compiler complains if a variable which was never initialised is
164  * cast to void, which is a common idiom which we use to indicate that we
165  * are aware a variable isn't used. So we just silence that warning.
166  * See: https://github.com/swig/swig/issues/192 for more discussion.
167  */
168 #ifdef __INTEL_COMPILER
169 # pragma warning disable 592
170 #endif
171 
172 
173 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
174 /* Use debug wrappers with the Python release dll */
175 # undef _DEBUG
176 # include <Python.h>
177 # define _DEBUG
178 #else
179 # include <Python.h>
180 #endif
181 
182 /* -----------------------------------------------------------------------------
183  * swigrun.swg
184  *
185  * This file contains generic C API SWIG runtime support for pointer
186  * type checking.
187  * ----------------------------------------------------------------------------- */
188 
189 /* This should only be incremented when either the layout of swig_type_info changes,
190  or for whatever reason, the runtime changes incompatibly */
191 #define SWIG_RUNTIME_VERSION "4"
192 
193 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
194 #ifdef SWIG_TYPE_TABLE
195 # define SWIG_QUOTE_STRING(x) #x
196 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
197 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
198 #else
199 # define SWIG_TYPE_TABLE_NAME
200 #endif
201 
202 /*
203  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
204  creating a static or dynamic library from the SWIG runtime code.
205  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
206 
207  But only do this if strictly necessary, ie, if you have problems
208  with your compiler or suchlike.
209 */
210 
211 #ifndef SWIGRUNTIME
212 # define SWIGRUNTIME SWIGINTERN
213 #endif
214 
215 #ifndef SWIGRUNTIMEINLINE
216 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
217 #endif
218 
219 /* Generic buffer size */
220 #ifndef SWIG_BUFFER_SIZE
221 # define SWIG_BUFFER_SIZE 1024
222 #endif
223 
224 /* Flags for pointer conversions */
225 #define SWIG_POINTER_DISOWN 0x1
226 #define SWIG_CAST_NEW_MEMORY 0x2
227 
228 /* Flags for new pointer objects */
229 #define SWIG_POINTER_OWN 0x1
230 
231 
232 /*
233  Flags/methods for returning states.
234 
235  The SWIG conversion methods, as ConvertPtr, return an integer
236  that tells if the conversion was successful or not. And if not,
237  an error code can be returned (see swigerrors.swg for the codes).
238 
239  Use the following macros/flags to set or process the returning
240  states.
241 
242  In old versions of SWIG, code such as the following was usually written:
243 
244  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
245  // success code
246  } else {
247  //fail code
248  }
249 
250  Now you can be more explicit:
251 
252  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
253  if (SWIG_IsOK(res)) {
254  // success code
255  } else {
256  // fail code
257  }
258 
259  which is the same really, but now you can also do
260 
261  Type *ptr;
262  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
263  if (SWIG_IsOK(res)) {
264  // success code
265  if (SWIG_IsNewObj(res) {
266  ...
267  delete *ptr;
268  } else {
269  ...
270  }
271  } else {
272  // fail code
273  }
274 
275  I.e., now SWIG_ConvertPtr can return new objects and you can
276  identify the case and take care of the deallocation. Of course that
277  also requires SWIG_ConvertPtr to return new result values, such as
278 
279  int SWIG_ConvertPtr(obj, ptr,...) {
280  if (<obj is ok>) {
281  if (<need new object>) {
282  *ptr = <ptr to new allocated object>;
283  return SWIG_NEWOBJ;
284  } else {
285  *ptr = <ptr to old object>;
286  return SWIG_OLDOBJ;
287  }
288  } else {
289  return SWIG_BADOBJ;
290  }
291  }
292 
293  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
294  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
295  SWIG errors code.
296 
297  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
298  allows to return the 'cast rank', for example, if you have this
299 
300  int food(double)
301  int fooi(int);
302 
303  and you call
304 
305  food(1) // cast rank '1' (1 -> 1.0)
306  fooi(1) // cast rank '0'
307 
308  just use the SWIG_AddCast()/SWIG_CheckState()
309 */
310 
311 #define SWIG_OK (0)
312 #define SWIG_ERROR (-1)
313 #define SWIG_IsOK(r) (r >= 0)
314 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
315 
316 /* The CastRankLimit says how many bits are used for the cast rank */
317 #define SWIG_CASTRANKLIMIT (1 << 8)
318 /* The NewMask denotes the object was created (using new/malloc) */
319 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
320 /* The TmpMask is for in/out typemaps that use temporal objects */
321 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
322 /* Simple returning values */
323 #define SWIG_BADOBJ (SWIG_ERROR)
324 #define SWIG_OLDOBJ (SWIG_OK)
325 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
326 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
327 /* Check, add and del mask methods */
328 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
329 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
330 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
331 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
332 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
333 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
334 
335 /* Cast-Rank Mode */
336 #if defined(SWIG_CASTRANK_MODE)
337 # ifndef SWIG_TypeRank
338 # define SWIG_TypeRank unsigned long
339 # endif
340 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
341 # define SWIG_MAXCASTRANK (2)
342 # endif
343 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
344 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
345 SWIGINTERNINLINE int SWIG_AddCast(int r) {
346  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
347 }
348 SWIGINTERNINLINE int SWIG_CheckState(int r) {
349  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
350 }
351 #else /* no cast-rank mode */
352 # define SWIG_AddCast(r) (r)
353 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
354 #endif
355 
356 
357 #include <string.h>
358 
359 #ifdef __cplusplus
360 extern "C" {
361 #endif
362 
363 typedef void *(*swig_converter_func)(void *, int *);
364 typedef struct swig_type_info *(*swig_dycast_func)(void **);
365 
366 /* Structure to store information on one type */
367 typedef struct swig_type_info {
368  const char *name; /* mangled name of this type */
369  const char *str; /* human readable name of this type */
370  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
371  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
372  void *clientdata; /* language specific type data */
373  int owndata; /* flag if the structure owns the clientdata */
375 
376 /* Structure to store a type and conversion function used for casting */
377 typedef struct swig_cast_info {
378  swig_type_info *type; /* pointer to type that is equivalent to this type */
379  swig_converter_func converter; /* function to cast the void pointers */
380  struct swig_cast_info *next; /* pointer to next cast in linked list */
381  struct swig_cast_info *prev; /* pointer to the previous cast */
383 
384 /* Structure used to store module information
385  * Each module generates one structure like this, and the runtime collects
386  * all of these structures and stores them in a circularly linked list.*/
387 typedef struct swig_module_info {
388  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
389  size_t size; /* Number of types in this module */
390  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
391  swig_type_info **type_initial; /* Array of initially generated type structures */
392  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
393  void *clientdata; /* Language specific module data */
395 
396 /*
397  Compare two type names skipping the space characters, therefore
398  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
399 
400  Return 0 when the two name types are equivalent, as in
401  strncmp, but skipping ' '.
402 */
403 SWIGRUNTIME int
404 SWIG_TypeNameComp(const char *f1, const char *l1,
405  const char *f2, const char *l2) {
406  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
407  while ((*f1 == ' ') && (f1 != l1)) ++f1;
408  while ((*f2 == ' ') && (f2 != l2)) ++f2;
409  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
410  }
411  return (int)((l1 - f1) - (l2 - f2));
412 }
413 
414 /*
415  Check type equivalence in a name list like <name1>|<name2>|...
416  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
417 */
418 SWIGRUNTIME int
419 SWIG_TypeCmp(const char *nb, const char *tb) {
420  int equiv = 1;
421  const char* te = tb + strlen(tb);
422  const char* ne = nb;
423  while (equiv != 0 && *ne) {
424  for (nb = ne; *ne; ++ne) {
425  if (*ne == '|') break;
426  }
427  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
428  if (*ne) ++ne;
429  }
430  return equiv;
431 }
432 
433 /*
434  Check type equivalence in a name list like <name1>|<name2>|...
435  Return 0 if not equal, 1 if equal
436 */
437 SWIGRUNTIME int
438 SWIG_TypeEquiv(const char *nb, const char *tb) {
439  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
440 }
441 
442 /*
443  Check the typename
444 */
445 SWIGRUNTIME swig_cast_info *
446 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
447  if (ty) {
448  swig_cast_info *iter = ty->cast;
449  while (iter) {
450  if (strcmp(iter->type->name, c) == 0) {
451  if (iter == ty->cast)
452  return iter;
453  /* Move iter to the top of the linked list */
454  iter->prev->next = iter->next;
455  if (iter->next)
456  iter->next->prev = iter->prev;
457  iter->next = ty->cast;
458  iter->prev = 0;
459  if (ty->cast) ty->cast->prev = iter;
460  ty->cast = iter;
461  return iter;
462  }
463  iter = iter->next;
464  }
465  }
466  return 0;
467 }
468 
469 /*
470  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
471 */
472 SWIGRUNTIME swig_cast_info *
473 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
474  if (ty) {
475  swig_cast_info *iter = ty->cast;
476  while (iter) {
477  if (iter->type == from) {
478  if (iter == ty->cast)
479  return iter;
480  /* Move iter to the top of the linked list */
481  iter->prev->next = iter->next;
482  if (iter->next)
483  iter->next->prev = iter->prev;
484  iter->next = ty->cast;
485  iter->prev = 0;
486  if (ty->cast) ty->cast->prev = iter;
487  ty->cast = iter;
488  return iter;
489  }
490  iter = iter->next;
491  }
492  }
493  return 0;
494 }
495 
496 /*
497  Cast a pointer up an inheritance hierarchy
498 */
499 SWIGRUNTIMEINLINE void *
500 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
501  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
502 }
503 
504 /*
505  Dynamic pointer casting. Down an inheritance hierarchy
506 */
507 SWIGRUNTIME swig_type_info *
508 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
509  swig_type_info *lastty = ty;
510  if (!ty || !ty->dcast) return ty;
511  while (ty && (ty->dcast)) {
512  ty = (*ty->dcast)(ptr);
513  if (ty) lastty = ty;
514  }
515  return lastty;
516 }
517 
518 /*
519  Return the name associated with this type
520 */
521 SWIGRUNTIMEINLINE const char *
522 SWIG_TypeName(const swig_type_info *ty) {
523  return ty->name;
524 }
525 
526 /*
527  Return the pretty name associated with this type,
528  that is an unmangled type name in a form presentable to the user.
529 */
530 SWIGRUNTIME const char *
531 SWIG_TypePrettyName(const swig_type_info *type) {
532  /* The "str" field contains the equivalent pretty names of the
533  type, separated by vertical-bar characters. We choose
534  to print the last name, as it is often (?) the most
535  specific. */
536  if (!type) return NULL;
537  if (type->str != NULL) {
538  const char *last_name = type->str;
539  const char *s;
540  for (s = type->str; *s; s++)
541  if (*s == '|') last_name = s+1;
542  return last_name;
543  }
544  else
545  return type->name;
546 }
547 
548 /*
549  Set the clientdata field for a type
550 */
551 SWIGRUNTIME void
552 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
553  swig_cast_info *cast = ti->cast;
554  /* if (ti->clientdata == clientdata) return; */
555  ti->clientdata = clientdata;
556 
557  while (cast) {
558  if (!cast->converter) {
559  swig_type_info *tc = cast->type;
560  if (!tc->clientdata) {
561  SWIG_TypeClientData(tc, clientdata);
562  }
563  }
564  cast = cast->next;
565  }
566 }
567 SWIGRUNTIME void
568 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
569  SWIG_TypeClientData(ti, clientdata);
570  ti->owndata = 1;
571 }
572 
573 /*
574  Search for a swig_type_info structure only by mangled name
575  Search is a O(log #types)
576 
577  We start searching at module start, and finish searching when start == end.
578  Note: if start == end at the beginning of the function, we go all the way around
579  the circular list.
580 */
581 SWIGRUNTIME swig_type_info *
582 SWIG_MangledTypeQueryModule(swig_module_info *start,
583  swig_module_info *end,
584  const char *name) {
585  swig_module_info *iter = start;
586  do {
587  if (iter->size) {
588  size_t l = 0;
589  size_t r = iter->size - 1;
590  do {
591  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
592  size_t i = (l + r) >> 1;
593  const char *iname = iter->types[i]->name;
594  if (iname) {
595  int compare = strcmp(name, iname);
596  if (compare == 0) {
597  return iter->types[i];
598  } else if (compare < 0) {
599  if (i) {
600  r = i - 1;
601  } else {
602  break;
603  }
604  } else if (compare > 0) {
605  l = i + 1;
606  }
607  } else {
608  break; /* should never happen */
609  }
610  } while (l <= r);
611  }
612  iter = iter->next;
613  } while (iter != end);
614  return 0;
615 }
616 
617 /*
618  Search for a swig_type_info structure for either a mangled name or a human readable name.
619  It first searches the mangled names of the types, which is a O(log #types)
620  If a type is not found it then searches the human readable names, which is O(#types).
621 
622  We start searching at module start, and finish searching when start == end.
623  Note: if start == end at the beginning of the function, we go all the way around
624  the circular list.
625 */
626 SWIGRUNTIME swig_type_info *
627 SWIG_TypeQueryModule(swig_module_info *start,
628  swig_module_info *end,
629  const char *name) {
630  /* STEP 1: Search the name field using binary search */
631  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
632  if (ret) {
633  return ret;
634  } else {
635  /* STEP 2: If the type hasn't been found, do a complete search
636  of the str field (the human readable name) */
637  swig_module_info *iter = start;
638  do {
639  size_t i = 0;
640  for (; i < iter->size; ++i) {
641  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
642  return iter->types[i];
643  }
644  iter = iter->next;
645  } while (iter != end);
646  }
647 
648  /* neither found a match */
649  return 0;
650 }
651 
652 /*
653  Pack binary data into a string
654 */
655 SWIGRUNTIME char *
656 SWIG_PackData(char *c, void *ptr, size_t sz) {
657  static const char hex[17] = "0123456789abcdef";
658  const unsigned char *u = (unsigned char *) ptr;
659  const unsigned char *eu = u + sz;
660  for (; u != eu; ++u) {
661  unsigned char uu = *u;
662  *(c++) = hex[(uu & 0xf0) >> 4];
663  *(c++) = hex[uu & 0xf];
664  }
665  return c;
666 }
667 
668 /*
669  Unpack binary data from a string
670 */
671 SWIGRUNTIME const char *
672 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
673  unsigned char *u = (unsigned char *) ptr;
674  const unsigned char *eu = u + sz;
675  for (; u != eu; ++u) {
676  char d = *(c++);
677  unsigned char uu;
678  if ((d >= '0') && (d <= '9'))
679  uu = ((d - '0') << 4);
680  else if ((d >= 'a') && (d <= 'f'))
681  uu = ((d - ('a'-10)) << 4);
682  else
683  return (char *) 0;
684  d = *(c++);
685  if ((d >= '0') && (d <= '9'))
686  uu |= (d - '0');
687  else if ((d >= 'a') && (d <= 'f'))
688  uu |= (d - ('a'-10));
689  else
690  return (char *) 0;
691  *u = uu;
692  }
693  return c;
694 }
695 
696 /*
697  Pack 'void *' into a string buffer.
698 */
699 SWIGRUNTIME char *
700 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
701  char *r = buff;
702  if ((2*sizeof(void *) + 2) > bsz) return 0;
703  *(r++) = '_';
704  r = SWIG_PackData(r,&ptr,sizeof(void *));
705  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
706  strcpy(r,name);
707  return buff;
708 }
709 
710 SWIGRUNTIME const char *
711 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
712  if (*c != '_') {
713  if (strcmp(c,"NULL") == 0) {
714  *ptr = (void *) 0;
715  return name;
716  } else {
717  return 0;
718  }
719  }
720  return SWIG_UnpackData(++c,ptr,sizeof(void *));
721 }
722 
723 SWIGRUNTIME char *
724 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
725  char *r = buff;
726  size_t lname = (name ? strlen(name) : 0);
727  if ((2*sz + 2 + lname) > bsz) return 0;
728  *(r++) = '_';
729  r = SWIG_PackData(r,ptr,sz);
730  if (lname) {
731  strncpy(r,name,lname+1);
732  } else {
733  *r = 0;
734  }
735  return buff;
736 }
737 
738 SWIGRUNTIME const char *
739 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
740  if (*c != '_') {
741  if (strcmp(c,"NULL") == 0) {
742  memset(ptr,0,sz);
743  return name;
744  } else {
745  return 0;
746  }
747  }
748  return SWIG_UnpackData(++c,ptr,sz);
749 }
750 
751 #ifdef __cplusplus
752 }
753 #endif
754 
755 /* Errors in SWIG */
756 #define SWIG_UnknownError -1
757 #define SWIG_IOError -2
758 #define SWIG_RuntimeError -3
759 #define SWIG_IndexError -4
760 #define SWIG_TypeError -5
761 #define SWIG_DivisionByZero -6
762 #define SWIG_OverflowError -7
763 #define SWIG_SyntaxError -8
764 #define SWIG_ValueError -9
765 #define SWIG_SystemError -10
766 #define SWIG_AttributeError -11
767 #define SWIG_MemoryError -12
768 #define SWIG_NullReferenceError -13
769 
770 
771 
772 /* Compatibility macros for Python 3 */
773 #if PY_VERSION_HEX >= 0x03000000
774 
775 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
776 #define PyInt_Check(x) PyLong_Check(x)
777 #define PyInt_AsLong(x) PyLong_AsLong(x)
778 #define PyInt_FromLong(x) PyLong_FromLong(x)
779 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
780 #define PyString_Check(name) PyBytes_Check(name)
781 #define PyString_FromString(x) PyUnicode_FromString(x)
782 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
783 #define PyString_AsString(str) PyBytes_AsString(str)
784 #define PyString_Size(str) PyBytes_Size(str)
785 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
786 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
787 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
788 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
789 
790 #endif
791 
792 #ifndef Py_TYPE
793 # define Py_TYPE(op) ((op)->ob_type)
794 #endif
795 
796 /* SWIG APIs for compatibility of both Python 2 & 3 */
797 
798 #if PY_VERSION_HEX >= 0x03000000
799 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
800 #else
801 # define SWIG_Python_str_FromFormat PyString_FromFormat
802 #endif
803 
804 
805 /* Warning: This function will allocate a new string in Python 3,
806  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
807  */
808 SWIGINTERN char*
809 SWIG_Python_str_AsChar(PyObject *str)
810 {
811 #if PY_VERSION_HEX >= 0x03000000
812  char *cstr;
813  char *newstr;
814  Py_ssize_t len;
815  str = PyUnicode_AsUTF8String(str);
816  PyBytes_AsStringAndSize(str, &cstr, &len);
817  newstr = (char *) malloc(len+1);
818  memcpy(newstr, cstr, len+1);
819  Py_XDECREF(str);
820  return newstr;
821 #else
822  return PyString_AsString(str);
823 #endif
824 }
825 
826 #if PY_VERSION_HEX >= 0x03000000
827 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
828 #else
829 # define SWIG_Python_str_DelForPy3(x)
830 #endif
831 
832 
833 SWIGINTERN PyObject*
834 SWIG_Python_str_FromChar(const char *c)
835 {
836 #if PY_VERSION_HEX >= 0x03000000
837  return PyUnicode_FromString(c);
838 #else
839  return PyString_FromString(c);
840 #endif
841 }
842 
843 /* Add PyOS_snprintf for old Pythons */
844 #if PY_VERSION_HEX < 0x02020000
845 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
846 # define PyOS_snprintf _snprintf
847 # else
848 # define PyOS_snprintf snprintf
849 # endif
850 #endif
851 
852 /* A crude PyString_FromFormat implementation for old Pythons */
853 #if PY_VERSION_HEX < 0x02020000
854 
855 #ifndef SWIG_PYBUFFER_SIZE
856 # define SWIG_PYBUFFER_SIZE 1024
857 #endif
858 
859 static PyObject *
860 PyString_FromFormat(const char *fmt, ...) {
861  va_list ap;
862  char buf[SWIG_PYBUFFER_SIZE * 2];
863  int res;
864  va_start(ap, fmt);
865  res = vsnprintf(buf, sizeof(buf), fmt, ap);
866  va_end(ap);
867  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
868 }
869 #endif
870 
871 /* Add PyObject_Del for old Pythons */
872 #if PY_VERSION_HEX < 0x01060000
873 # define PyObject_Del(op) PyMem_DEL((op))
874 #endif
875 #ifndef PyObject_DEL
876 # define PyObject_DEL PyObject_Del
877 #endif
878 
879 /* A crude PyExc_StopIteration exception for old Pythons */
880 #if PY_VERSION_HEX < 0x02020000
881 # ifndef PyExc_StopIteration
882 # define PyExc_StopIteration PyExc_RuntimeError
883 # endif
884 # ifndef PyObject_GenericGetAttr
885 # define PyObject_GenericGetAttr 0
886 # endif
887 #endif
888 
889 /* Py_NotImplemented is defined in 2.1 and up. */
890 #if PY_VERSION_HEX < 0x02010000
891 # ifndef Py_NotImplemented
892 # define Py_NotImplemented PyExc_RuntimeError
893 # endif
894 #endif
895 
896 /* A crude PyString_AsStringAndSize implementation for old Pythons */
897 #if PY_VERSION_HEX < 0x02010000
898 # ifndef PyString_AsStringAndSize
899 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
900 # endif
901 #endif
902 
903 /* PySequence_Size for old Pythons */
904 #if PY_VERSION_HEX < 0x02000000
905 # ifndef PySequence_Size
906 # define PySequence_Size PySequence_Length
907 # endif
908 #endif
909 
910 /* PyBool_FromLong for old Pythons */
911 #if PY_VERSION_HEX < 0x02030000
912 static
913 PyObject *PyBool_FromLong(long ok)
914 {
915  PyObject *result = ok ? Py_True : Py_False;
916  Py_INCREF(result);
917  return result;
918 }
919 #endif
920 
921 /* Py_ssize_t for old Pythons */
922 /* This code is as recommended by: */
923 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
924 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
925 typedef int Py_ssize_t;
926 # define PY_SSIZE_T_MAX INT_MAX
927 # define PY_SSIZE_T_MIN INT_MIN
928 typedef inquiry lenfunc;
929 typedef intargfunc ssizeargfunc;
930 typedef intintargfunc ssizessizeargfunc;
931 typedef intobjargproc ssizeobjargproc;
932 typedef intintobjargproc ssizessizeobjargproc;
933 typedef getreadbufferproc readbufferproc;
934 typedef getwritebufferproc writebufferproc;
935 typedef getsegcountproc segcountproc;
936 typedef getcharbufferproc charbufferproc;
937 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
938 {
939  long result = 0;
940  PyObject *i = PyNumber_Int(x);
941  if (i) {
942  result = PyInt_AsLong(i);
943  Py_DECREF(i);
944  }
945  return result;
946 }
947 #endif
948 
949 #if PY_VERSION_HEX < 0x02050000
950 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
951 #endif
952 
953 #if PY_VERSION_HEX < 0x02040000
954 #define Py_VISIT(op) \
955  do { \
956  if (op) { \
957  int vret = visit((op), arg); \
958  if (vret) \
959  return vret; \
960  } \
961  } while (0)
962 #endif
963 
964 #if PY_VERSION_HEX < 0x02030000
965 typedef struct {
966  PyTypeObject type;
967  PyNumberMethods as_number;
968  PyMappingMethods as_mapping;
969  PySequenceMethods as_sequence;
970  PyBufferProcs as_buffer;
971  PyObject *name, *slots;
973 #endif
974 
975 #if PY_VERSION_HEX < 0x02030000
976 typedef destructor freefunc;
977 #endif
978 
979 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
980  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
981  (PY_MAJOR_VERSION > 3))
982 # define SWIGPY_USE_CAPSULE
983 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
984 #endif
985 
986 #if PY_VERSION_HEX < 0x03020000
987 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
988 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
989 #endif
990 
991 /* -----------------------------------------------------------------------------
992  * error manipulation
993  * ----------------------------------------------------------------------------- */
994 
995 SWIGRUNTIME PyObject*
996 SWIG_Python_ErrorType(int code) {
997  PyObject* type = 0;
998  switch(code) {
999  case SWIG_MemoryError:
1000  type = PyExc_MemoryError;
1001  break;
1002  case SWIG_IOError:
1003  type = PyExc_IOError;
1004  break;
1005  case SWIG_RuntimeError:
1006  type = PyExc_RuntimeError;
1007  break;
1008  case SWIG_IndexError:
1009  type = PyExc_IndexError;
1010  break;
1011  case SWIG_TypeError:
1012  type = PyExc_TypeError;
1013  break;
1014  case SWIG_DivisionByZero:
1015  type = PyExc_ZeroDivisionError;
1016  break;
1017  case SWIG_OverflowError:
1018  type = PyExc_OverflowError;
1019  break;
1020  case SWIG_SyntaxError:
1021  type = PyExc_SyntaxError;
1022  break;
1023  case SWIG_ValueError:
1024  type = PyExc_ValueError;
1025  break;
1026  case SWIG_SystemError:
1027  type = PyExc_SystemError;
1028  break;
1029  case SWIG_AttributeError:
1030  type = PyExc_AttributeError;
1031  break;
1032  default:
1033  type = PyExc_RuntimeError;
1034  }
1035  return type;
1036 }
1037 
1038 
1039 SWIGRUNTIME void
1040 SWIG_Python_AddErrorMsg(const char* mesg)
1041 {
1042  PyObject *type = 0;
1043  PyObject *value = 0;
1044  PyObject *traceback = 0;
1045 
1046  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1047  if (value) {
1048  char *tmp;
1049  PyObject *old_str = PyObject_Str(value);
1050  PyErr_Clear();
1051  Py_XINCREF(type);
1052 
1053  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1054  SWIG_Python_str_DelForPy3(tmp);
1055  Py_DECREF(old_str);
1056  Py_DECREF(value);
1057  } else {
1058  PyErr_SetString(PyExc_RuntimeError, mesg);
1059  }
1060 }
1061 
1062 #if defined(SWIG_PYTHON_NO_THREADS)
1063 # if defined(SWIG_PYTHON_THREADS)
1064 # undef SWIG_PYTHON_THREADS
1065 # endif
1066 #endif
1067 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1068 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1069 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1070 # define SWIG_PYTHON_USE_GIL
1071 # endif
1072 # endif
1073 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1074 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1075 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1076 # endif
1077 # ifdef __cplusplus /* C++ code */
1078  class SWIG_Python_Thread_Block {
1079  bool status;
1080  PyGILState_STATE state;
1081  public:
1082  void end() { if (status) { PyGILState_Release(state); status = false;} }
1083  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1084  ~SWIG_Python_Thread_Block() { end(); }
1085  };
1086  class SWIG_Python_Thread_Allow {
1087  bool status;
1088  PyThreadState *save;
1089  public:
1090  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1091  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1092  ~SWIG_Python_Thread_Allow() { end(); }
1093  };
1094 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1095 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1096 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1097 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1098 # else /* C code */
1099 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1100 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1101 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1102 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1103 # endif
1104 # else /* Old thread way, not implemented, user must provide it */
1105 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1106 # define SWIG_PYTHON_INITIALIZE_THREADS
1107 # endif
1108 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1109 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1110 # endif
1111 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1112 # define SWIG_PYTHON_THREAD_END_BLOCK
1113 # endif
1114 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1115 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1116 # endif
1117 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1118 # define SWIG_PYTHON_THREAD_END_ALLOW
1119 # endif
1120 # endif
1121 #else /* No thread support */
1122 # define SWIG_PYTHON_INITIALIZE_THREADS
1123 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1124 # define SWIG_PYTHON_THREAD_END_BLOCK
1125 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1126 # define SWIG_PYTHON_THREAD_END_ALLOW
1127 #endif
1128 
1129 /* -----------------------------------------------------------------------------
1130  * Python API portion that goes into the runtime
1131  * ----------------------------------------------------------------------------- */
1132 
1133 #ifdef __cplusplus
1134 extern "C" {
1135 #endif
1136 
1137 /* -----------------------------------------------------------------------------
1138  * Constant declarations
1139  * ----------------------------------------------------------------------------- */
1140 
1141 /* Constant Types */
1142 #define SWIG_PY_POINTER 4
1143 #define SWIG_PY_BINARY 5
1144 
1145 /* Constant information structure */
1146 typedef struct swig_const_info {
1147  int type;
1148  char *name;
1149  long lvalue;
1150  double dvalue;
1151  void *pvalue;
1152  swig_type_info **ptype;
1153 } swig_const_info;
1154 
1155 
1156 /* -----------------------------------------------------------------------------
1157  * Wrapper of PyInstanceMethod_New() used in Python 3
1158  * It is exported to the generated module, used for -fastproxy
1159  * ----------------------------------------------------------------------------- */
1160 #if PY_VERSION_HEX >= 0x03000000
1161 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1162 {
1163  return PyInstanceMethod_New(func);
1164 }
1165 #else
1166 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1167 {
1168  return NULL;
1169 }
1170 #endif
1171 
1172 #ifdef __cplusplus
1173 }
1174 #endif
1175 
1176 
1177 /* -----------------------------------------------------------------------------
1178  * pyrun.swg
1179  *
1180  * This file contains the runtime support for Python modules
1181  * and includes code for managing global variables and pointer
1182  * type checking.
1183  *
1184  * ----------------------------------------------------------------------------- */
1185 
1186 /* Common SWIG API */
1187 
1188 /* for raw pointers */
1189 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1190 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1191 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1192 
1193 #ifdef SWIGPYTHON_BUILTIN
1194 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1195 #else
1196 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1197 #endif
1198 
1199 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1200 
1201 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1202 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1203 #define swig_owntype int
1204 
1205 /* for raw packed data */
1206 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1207 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1208 
1209 /* for class or struct pointers */
1210 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1211 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1212 
1213 /* for C or C++ function pointers */
1214 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1215 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1216 
1217 /* for C++ member pointers, ie, member methods */
1218 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1219 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1220 
1221 
1222 /* Runtime API */
1223 
1224 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1225 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1226 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1227 
1228 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1229 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1230 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1231 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1232 #define SWIG_fail goto fail
1233 
1234 
1235 /* Runtime API implementation */
1236 
1237 /* Error manipulation */
1238 
1239 SWIGINTERN void
1240 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1241  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1242  PyErr_SetObject(errtype, obj);
1243  Py_DECREF(obj);
1244  SWIG_PYTHON_THREAD_END_BLOCK;
1245 }
1246 
1247 SWIGINTERN void
1248 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1249  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1250  PyErr_SetString(errtype, msg);
1251  SWIG_PYTHON_THREAD_END_BLOCK;
1252 }
1253 
1254 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1255 
1256 /* Set a constant value */
1257 
1258 #if defined(SWIGPYTHON_BUILTIN)
1259 
1260 SWIGINTERN void
1261 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1262  PyObject *s = PyString_InternFromString(key);
1263  PyList_Append(seq, s);
1264  Py_DECREF(s);
1265 }
1266 
1267 SWIGINTERN void
1268 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1269 #if PY_VERSION_HEX < 0x02030000
1270  PyDict_SetItemString(d, (char *)name, obj);
1271 #else
1272  PyDict_SetItemString(d, name, obj);
1273 #endif
1274  Py_DECREF(obj);
1275  if (public_interface)
1276  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1277 }
1278 
1279 #else
1280 
1281 SWIGINTERN void
1282 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1283 #if PY_VERSION_HEX < 0x02030000
1284  PyDict_SetItemString(d, (char *)name, obj);
1285 #else
1286  PyDict_SetItemString(d, name, obj);
1287 #endif
1288  Py_DECREF(obj);
1289 }
1290 
1291 #endif
1292 
1293 /* Append a value to the result obj */
1294 
1295 SWIGINTERN PyObject*
1296 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1297 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1298  if (!result) {
1299  result = obj;
1300  } else if (result == Py_None) {
1301  Py_DECREF(result);
1302  result = obj;
1303  } else {
1304  if (!PyList_Check(result)) {
1305  PyObject *o2 = result;
1306  result = PyList_New(1);
1307  PyList_SetItem(result, 0, o2);
1308  }
1309  PyList_Append(result,obj);
1310  Py_DECREF(obj);
1311  }
1312  return result;
1313 #else
1314  PyObject* o2;
1315  PyObject* o3;
1316  if (!result) {
1317  result = obj;
1318  } else if (result == Py_None) {
1319  Py_DECREF(result);
1320  result = obj;
1321  } else {
1322  if (!PyTuple_Check(result)) {
1323  o2 = result;
1324  result = PyTuple_New(1);
1325  PyTuple_SET_ITEM(result, 0, o2);
1326  }
1327  o3 = PyTuple_New(1);
1328  PyTuple_SET_ITEM(o3, 0, obj);
1329  o2 = result;
1330  result = PySequence_Concat(o2, o3);
1331  Py_DECREF(o2);
1332  Py_DECREF(o3);
1333  }
1334  return result;
1335 #endif
1336 }
1337 
1338 /* Unpack the argument tuple */
1339 
1340 SWIGINTERN Py_ssize_t
1341 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1342 {
1343  if (!args) {
1344  if (!min && !max) {
1345  return 1;
1346  } else {
1347  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1348  name, (min == max ? "" : "at least "), (int)min);
1349  return 0;
1350  }
1351  }
1352  if (!PyTuple_Check(args)) {
1353  if (min <= 1 && max >= 1) {
1354  Py_ssize_t i;
1355  objs[0] = args;
1356  for (i = 1; i < max; ++i) {
1357  objs[i] = 0;
1358  }
1359  return 2;
1360  }
1361  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1362  return 0;
1363  } else {
1364  Py_ssize_t l = PyTuple_GET_SIZE(args);
1365  if (l < min) {
1366  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1367  name, (min == max ? "" : "at least "), (int)min, (int)l);
1368  return 0;
1369  } else if (l > max) {
1370  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1371  name, (min == max ? "" : "at most "), (int)max, (int)l);
1372  return 0;
1373  } else {
1374  Py_ssize_t i;
1375  for (i = 0; i < l; ++i) {
1376  objs[i] = PyTuple_GET_ITEM(args, i);
1377  }
1378  for (; l < max; ++l) {
1379  objs[l] = 0;
1380  }
1381  return i + 1;
1382  }
1383  }
1384 }
1385 
1386 /* A functor is a function object with one single object argument */
1387 #if PY_VERSION_HEX >= 0x02020000
1388 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1389 #else
1390 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1391 #endif
1392 
1393 /*
1394  Helper for static pointer initialization for both C and C++ code, for example
1395  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1396 */
1397 #ifdef __cplusplus
1398 #define SWIG_STATIC_POINTER(var) var
1399 #else
1400 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1401 #endif
1402 
1403 /* -----------------------------------------------------------------------------
1404  * Pointer declarations
1405  * ----------------------------------------------------------------------------- */
1406 
1407 /* Flags for new pointer objects */
1408 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1409 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1410 
1411 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1412 
1413 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1414 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1415 
1416 #ifdef __cplusplus
1417 extern "C" {
1418 #endif
1419 
1420 /* How to access Py_None */
1421 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1422 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1423 # ifndef SWIG_PYTHON_BUILD_NONE
1424 # define SWIG_PYTHON_BUILD_NONE
1425 # endif
1426 # endif
1427 #endif
1428 
1429 #ifdef SWIG_PYTHON_BUILD_NONE
1430 # ifdef Py_None
1431 # undef Py_None
1432 # define Py_None SWIG_Py_None()
1433 # endif
1434 SWIGRUNTIMEINLINE PyObject *
1435 _SWIG_Py_None(void)
1436 {
1437  PyObject *none = Py_BuildValue((char*)"");
1438  Py_DECREF(none);
1439  return none;
1440 }
1441 SWIGRUNTIME PyObject *
1442 SWIG_Py_None(void)
1443 {
1444  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1445  return none;
1446 }
1447 #endif
1448 
1449 /* The python void return value */
1450 
1451 SWIGRUNTIMEINLINE PyObject *
1452 SWIG_Py_Void(void)
1453 {
1454  PyObject *none = Py_None;
1455  Py_INCREF(none);
1456  return none;
1457 }
1458 
1459 /* SwigPyClientData */
1460 
1461 typedef struct {
1462  PyObject *klass;
1463  PyObject *newraw;
1464  PyObject *newargs;
1465  PyObject *destroy;
1466  int delargs;
1467  int implicitconv;
1468  PyTypeObject *pytype;
1470 
1471 SWIGRUNTIMEINLINE int
1472 SWIG_Python_CheckImplicit(swig_type_info *ty)
1473 {
1474  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1475  return data ? data->implicitconv : 0;
1476 }
1477 
1478 SWIGRUNTIMEINLINE PyObject *
1479 SWIG_Python_ExceptionType(swig_type_info *desc) {
1480  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1481  PyObject *klass = data ? data->klass : 0;
1482  return (klass ? klass : PyExc_RuntimeError);
1483 }
1484 
1485 
1486 SWIGRUNTIME SwigPyClientData *
1487 SwigPyClientData_New(PyObject* obj)
1488 {
1489  if (!obj) {
1490  return 0;
1491  } else {
1492  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1493  /* the klass element */
1494  data->klass = obj;
1495  Py_INCREF(data->klass);
1496  /* the newraw method and newargs arguments used to create a new raw instance */
1497  if (PyClass_Check(obj)) {
1498  data->newraw = 0;
1499  data->newargs = obj;
1500  Py_INCREF(obj);
1501  } else {
1502 #if (PY_VERSION_HEX < 0x02020000)
1503  data->newraw = 0;
1504 #else
1505  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1506 #endif
1507  if (data->newraw) {
1508  Py_INCREF(data->newraw);
1509  data->newargs = PyTuple_New(1);
1510  PyTuple_SetItem(data->newargs, 0, obj);
1511  } else {
1512  data->newargs = obj;
1513  }
1514  Py_INCREF(data->newargs);
1515  }
1516  /* the destroy method, aka as the C++ delete method */
1517  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1518  if (PyErr_Occurred()) {
1519  PyErr_Clear();
1520  data->destroy = 0;
1521  }
1522  if (data->destroy) {
1523  int flags;
1524  Py_INCREF(data->destroy);
1525  flags = PyCFunction_GET_FLAGS(data->destroy);
1526 #ifdef METH_O
1527  data->delargs = !(flags & (METH_O));
1528 #else
1529  data->delargs = 0;
1530 #endif
1531  } else {
1532  data->delargs = 0;
1533  }
1534  data->implicitconv = 0;
1535  data->pytype = 0;
1536  return data;
1537  }
1538 }
1539 
1540 SWIGRUNTIME void
1541 SwigPyClientData_Del(SwigPyClientData *data) {
1542  Py_XDECREF(data->newraw);
1543  Py_XDECREF(data->newargs);
1544  Py_XDECREF(data->destroy);
1545 }
1546 
1547 /* =============== SwigPyObject =====================*/
1548 
1549 typedef struct {
1550  PyObject_HEAD
1551  void *ptr;
1552  swig_type_info *ty;
1553  int own;
1554  PyObject *next;
1555 #ifdef SWIGPYTHON_BUILTIN
1556  PyObject *dict;
1557 #endif
1558 } SwigPyObject;
1559 
1560 
1561 #ifdef SWIGPYTHON_BUILTIN
1562 
1563 SWIGRUNTIME PyObject *
1564 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1565 {
1566  SwigPyObject *sobj = (SwigPyObject *)v;
1567 
1568  if (!sobj->dict)
1569  sobj->dict = PyDict_New();
1570 
1571  Py_INCREF(sobj->dict);
1572  return sobj->dict;
1573 }
1574 
1575 #endif
1576 
1577 SWIGRUNTIME PyObject *
1578 SwigPyObject_long(SwigPyObject *v)
1579 {
1580  return PyLong_FromVoidPtr(v->ptr);
1581 }
1582 
1583 SWIGRUNTIME PyObject *
1584 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1585 {
1586  PyObject *res = NULL;
1587  PyObject *args = PyTuple_New(1);
1588  if (args) {
1589  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1590  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1591  if (ofmt) {
1592 #if PY_VERSION_HEX >= 0x03000000
1593  res = PyUnicode_Format(ofmt,args);
1594 #else
1595  res = PyString_Format(ofmt,args);
1596 #endif
1597  Py_DECREF(ofmt);
1598  }
1599  Py_DECREF(args);
1600  }
1601  }
1602  return res;
1603 }
1604 
1605 SWIGRUNTIME PyObject *
1606 SwigPyObject_oct(SwigPyObject *v)
1607 {
1608  return SwigPyObject_format("%o",v);
1609 }
1610 
1611 SWIGRUNTIME PyObject *
1612 SwigPyObject_hex(SwigPyObject *v)
1613 {
1614  return SwigPyObject_format("%x",v);
1615 }
1616 
1617 SWIGRUNTIME PyObject *
1618 #ifdef METH_NOARGS
1619 SwigPyObject_repr(SwigPyObject *v)
1620 #else
1621 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1622 #endif
1623 {
1624  const char *name = SWIG_TypePrettyName(v->ty);
1625  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1626  if (v->next) {
1627 # ifdef METH_NOARGS
1628  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1629 # else
1630  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1631 # endif
1632 # if PY_VERSION_HEX >= 0x03000000
1633  PyObject *joined = PyUnicode_Concat(repr, nrep);
1634  Py_DecRef(repr);
1635  Py_DecRef(nrep);
1636  repr = joined;
1637 # else
1638  PyString_ConcatAndDel(&repr,nrep);
1639 # endif
1640  }
1641  return repr;
1642 }
1643 
1644 SWIGRUNTIME int
1645 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1646 {
1647  void *i = v->ptr;
1648  void *j = w->ptr;
1649  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1650 }
1651 
1652 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1653 SWIGRUNTIME PyObject*
1654 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1655 {
1656  PyObject* res;
1657  if( op != Py_EQ && op != Py_NE ) {
1658  Py_INCREF(Py_NotImplemented);
1659  return Py_NotImplemented;
1660  }
1661  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1662  return res;
1663 }
1664 
1665 
1666 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1667 
1668 #ifdef SWIGPYTHON_BUILTIN
1669 static swig_type_info *SwigPyObject_stype = 0;
1670 SWIGRUNTIME PyTypeObject*
1671 SwigPyObject_type(void) {
1672  SwigPyClientData *cd;
1673  assert(SwigPyObject_stype);
1674  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1675  assert(cd);
1676  assert(cd->pytype);
1677  return cd->pytype;
1678 }
1679 #else
1680 SWIGRUNTIME PyTypeObject*
1681 SwigPyObject_type(void) {
1682  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1683  return type;
1684 }
1685 #endif
1686 
1687 SWIGRUNTIMEINLINE int
1688 SwigPyObject_Check(PyObject *op) {
1689 #ifdef SWIGPYTHON_BUILTIN
1690  PyTypeObject *target_tp = SwigPyObject_type();
1691  if (PyType_IsSubtype(op->ob_type, target_tp))
1692  return 1;
1693  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1694 #else
1695  return (Py_TYPE(op) == SwigPyObject_type())
1696  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1697 #endif
1698 }
1699 
1700 SWIGRUNTIME PyObject *
1701 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1702 
1703 SWIGRUNTIME void
1704 SwigPyObject_dealloc(PyObject *v)
1705 {
1706  SwigPyObject *sobj = (SwigPyObject *) v;
1707  PyObject *next = sobj->next;
1708  if (sobj->own == SWIG_POINTER_OWN) {
1709  swig_type_info *ty = sobj->ty;
1710  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1711  PyObject *destroy = data ? data->destroy : 0;
1712  if (destroy) {
1713  /* destroy is always a VARARGS method */
1714  PyObject *res;
1715 
1716  /* PyObject_CallFunction() has the potential to silently drop
1717  the active active exception. In cases of unnamed temporary
1718  variable or where we just finished iterating over a generator
1719  StopIteration will be active right now, and this needs to
1720  remain true upon return from SwigPyObject_dealloc. So save
1721  and restore. */
1722 
1723  PyObject *val = NULL, *type = NULL, *tb = NULL;
1724  PyErr_Fetch(&val, &type, &tb);
1725 
1726  if (data->delargs) {
1727  /* we need to create a temporary object to carry the destroy operation */
1728  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1729  res = SWIG_Python_CallFunctor(destroy, tmp);
1730  Py_DECREF(tmp);
1731  } else {
1732  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1733  PyObject *mself = PyCFunction_GET_SELF(destroy);
1734  res = ((*meth)(mself, v));
1735  }
1736  if (!res)
1737  PyErr_WriteUnraisable(destroy);
1738 
1739  PyErr_Restore(val, type, tb);
1740 
1741  Py_XDECREF(res);
1742  }
1743 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1744  else {
1745  const char *name = SWIG_TypePrettyName(ty);
1746  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1747  }
1748 #endif
1749  }
1750  Py_XDECREF(next);
1751  PyObject_DEL(v);
1752 }
1753 
1754 SWIGRUNTIME PyObject*
1755 SwigPyObject_append(PyObject* v, PyObject* next)
1756 {
1757  SwigPyObject *sobj = (SwigPyObject *) v;
1758 #ifndef METH_O
1759  PyObject *tmp = 0;
1760  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1761  next = tmp;
1762 #endif
1763  if (!SwigPyObject_Check(next)) {
1764  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1765  return NULL;
1766  }
1767  sobj->next = next;
1768  Py_INCREF(next);
1769  return SWIG_Py_Void();
1770 }
1771 
1772 SWIGRUNTIME PyObject*
1773 #ifdef METH_NOARGS
1774 SwigPyObject_next(PyObject* v)
1775 #else
1776 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1777 #endif
1778 {
1779  SwigPyObject *sobj = (SwigPyObject *) v;
1780  if (sobj->next) {
1781  Py_INCREF(sobj->next);
1782  return sobj->next;
1783  } else {
1784  return SWIG_Py_Void();
1785  }
1786 }
1787 
1788 SWIGINTERN PyObject*
1789 #ifdef METH_NOARGS
1790 SwigPyObject_disown(PyObject *v)
1791 #else
1792 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1793 #endif
1794 {
1795  SwigPyObject *sobj = (SwigPyObject *)v;
1796  sobj->own = 0;
1797  return SWIG_Py_Void();
1798 }
1799 
1800 SWIGINTERN PyObject*
1801 #ifdef METH_NOARGS
1802 SwigPyObject_acquire(PyObject *v)
1803 #else
1804 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1805 #endif
1806 {
1807  SwigPyObject *sobj = (SwigPyObject *)v;
1808  sobj->own = SWIG_POINTER_OWN;
1809  return SWIG_Py_Void();
1810 }
1811 
1812 SWIGINTERN PyObject*
1813 SwigPyObject_own(PyObject *v, PyObject *args)
1814 {
1815  PyObject *val = 0;
1816 #if (PY_VERSION_HEX < 0x02020000)
1817  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1818 #elif (PY_VERSION_HEX < 0x02050000)
1819  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1820 #else
1821  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1822 #endif
1823  {
1824  return NULL;
1825  }
1826  else
1827  {
1828  SwigPyObject *sobj = (SwigPyObject *)v;
1829  PyObject *obj = PyBool_FromLong(sobj->own);
1830  if (val) {
1831 #ifdef METH_NOARGS
1832  if (PyObject_IsTrue(val)) {
1833  SwigPyObject_acquire(v);
1834  } else {
1835  SwigPyObject_disown(v);
1836  }
1837 #else
1838  if (PyObject_IsTrue(val)) {
1839  SwigPyObject_acquire(v,args);
1840  } else {
1841  SwigPyObject_disown(v,args);
1842  }
1843 #endif
1844  }
1845  return obj;
1846  }
1847 }
1848 
1849 #ifdef METH_O
1850 static PyMethodDef
1851 swigobject_methods[] = {
1852  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1853  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1854  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1855  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1856  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1857  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1858  {0, 0, 0, 0}
1859 };
1860 #else
1861 static PyMethodDef
1862 swigobject_methods[] = {
1863  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1864  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1865  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1866  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1867  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1868  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1869  {0, 0, 0, 0}
1870 };
1871 #endif
1872 
1873 #if PY_VERSION_HEX < 0x02020000
1874 SWIGINTERN PyObject *
1875 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1876 {
1877  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1878 }
1879 #endif
1880 
1881 SWIGRUNTIME PyTypeObject*
1882 SwigPyObject_TypeOnce(void) {
1883  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1884 
1885  static PyNumberMethods SwigPyObject_as_number = {
1886  (binaryfunc)0, /*nb_add*/
1887  (binaryfunc)0, /*nb_subtract*/
1888  (binaryfunc)0, /*nb_multiply*/
1889  /* nb_divide removed in Python 3 */
1890 #if PY_VERSION_HEX < 0x03000000
1891  (binaryfunc)0, /*nb_divide*/
1892 #endif
1893  (binaryfunc)0, /*nb_remainder*/
1894  (binaryfunc)0, /*nb_divmod*/
1895  (ternaryfunc)0,/*nb_power*/
1896  (unaryfunc)0, /*nb_negative*/
1897  (unaryfunc)0, /*nb_positive*/
1898  (unaryfunc)0, /*nb_absolute*/
1899  (inquiry)0, /*nb_nonzero*/
1900  0, /*nb_invert*/
1901  0, /*nb_lshift*/
1902  0, /*nb_rshift*/
1903  0, /*nb_and*/
1904  0, /*nb_xor*/
1905  0, /*nb_or*/
1906 #if PY_VERSION_HEX < 0x03000000
1907  0, /*nb_coerce*/
1908 #endif
1909  (unaryfunc)SwigPyObject_long, /*nb_int*/
1910 #if PY_VERSION_HEX < 0x03000000
1911  (unaryfunc)SwigPyObject_long, /*nb_long*/
1912 #else
1913  0, /*nb_reserved*/
1914 #endif
1915  (unaryfunc)0, /*nb_float*/
1916 #if PY_VERSION_HEX < 0x03000000
1917  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1918  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1919 #endif
1920 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1921  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1922 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1923  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1924 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1925  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1926 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1927  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1928 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1929  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1930 #endif
1931  };
1932 
1933  static PyTypeObject swigpyobject_type;
1934  static int type_init = 0;
1935  if (!type_init) {
1936  const PyTypeObject tmp = {
1937  /* PyObject header changed in Python 3 */
1938 #if PY_VERSION_HEX >= 0x03000000
1939  PyVarObject_HEAD_INIT(NULL, 0)
1940 #else
1941  PyObject_HEAD_INIT(NULL)
1942  0, /* ob_size */
1943 #endif
1944  (char *)"SwigPyObject", /* tp_name */
1945  sizeof(SwigPyObject), /* tp_basicsize */
1946  0, /* tp_itemsize */
1947  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1948  0, /* tp_print */
1949 #if PY_VERSION_HEX < 0x02020000
1950  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1951 #else
1952  (getattrfunc)0, /* tp_getattr */
1953 #endif
1954  (setattrfunc)0, /* tp_setattr */
1955 #if PY_VERSION_HEX >= 0x03000000
1956  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1957 #else
1958  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1959 #endif
1960  (reprfunc)SwigPyObject_repr, /* tp_repr */
1961  &SwigPyObject_as_number, /* tp_as_number */
1962  0, /* tp_as_sequence */
1963  0, /* tp_as_mapping */
1964  (hashfunc)0, /* tp_hash */
1965  (ternaryfunc)0, /* tp_call */
1966  0, /* tp_str */
1967  PyObject_GenericGetAttr, /* tp_getattro */
1968  0, /* tp_setattro */
1969  0, /* tp_as_buffer */
1970  Py_TPFLAGS_DEFAULT, /* tp_flags */
1971  swigobject_doc, /* tp_doc */
1972  0, /* tp_traverse */
1973  0, /* tp_clear */
1974  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1975  0, /* tp_weaklistoffset */
1976 #if PY_VERSION_HEX >= 0x02020000
1977  0, /* tp_iter */
1978  0, /* tp_iternext */
1979  swigobject_methods, /* tp_methods */
1980  0, /* tp_members */
1981  0, /* tp_getset */
1982  0, /* tp_base */
1983  0, /* tp_dict */
1984  0, /* tp_descr_get */
1985  0, /* tp_descr_set */
1986  0, /* tp_dictoffset */
1987  0, /* tp_init */
1988  0, /* tp_alloc */
1989  0, /* tp_new */
1990  0, /* tp_free */
1991  0, /* tp_is_gc */
1992  0, /* tp_bases */
1993  0, /* tp_mro */
1994  0, /* tp_cache */
1995  0, /* tp_subclasses */
1996  0, /* tp_weaklist */
1997 #endif
1998 #if PY_VERSION_HEX >= 0x02030000
1999  0, /* tp_del */
2000 #endif
2001 #if PY_VERSION_HEX >= 0x02060000
2002  0, /* tp_version_tag */
2003 #endif
2004 #if PY_VERSION_HEX >= 0x03040000
2005  0, /* tp_finalize */
2006 #endif
2007 #ifdef COUNT_ALLOCS
2008  0, /* tp_allocs */
2009  0, /* tp_frees */
2010  0, /* tp_maxalloc */
2011 #if PY_VERSION_HEX >= 0x02050000
2012  0, /* tp_prev */
2013 #endif
2014  0 /* tp_next */
2015 #endif
2016  };
2017  swigpyobject_type = tmp;
2018  type_init = 1;
2019 #if PY_VERSION_HEX < 0x02020000
2020  swigpyobject_type.ob_type = &PyType_Type;
2021 #else
2022  if (PyType_Ready(&swigpyobject_type) < 0)
2023  return NULL;
2024 #endif
2025  }
2026  return &swigpyobject_type;
2027 }
2028 
2029 SWIGRUNTIME PyObject *
2030 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2031 {
2032  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2033  if (sobj) {
2034  sobj->ptr = ptr;
2035  sobj->ty = ty;
2036  sobj->own = own;
2037  sobj->next = 0;
2038  }
2039  return (PyObject *)sobj;
2040 }
2041 
2042 /* -----------------------------------------------------------------------------
2043  * Implements a simple Swig Packed type, and use it instead of string
2044  * ----------------------------------------------------------------------------- */
2045 
2046 typedef struct {
2047  PyObject_HEAD
2048  void *pack;
2049  swig_type_info *ty;
2050  size_t size;
2051 } SwigPyPacked;
2052 
2053 SWIGRUNTIME int
2054 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2055 {
2056  char result[SWIG_BUFFER_SIZE];
2057  fputs("<Swig Packed ", fp);
2058  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2059  fputs("at ", fp);
2060  fputs(result, fp);
2061  }
2062  fputs(v->ty->name,fp);
2063  fputs(">", fp);
2064  return 0;
2065 }
2066 
2067 SWIGRUNTIME PyObject *
2068 SwigPyPacked_repr(SwigPyPacked *v)
2069 {
2070  char result[SWIG_BUFFER_SIZE];
2071  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2072  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2073  } else {
2074  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2075  }
2076 }
2077 
2078 SWIGRUNTIME PyObject *
2079 SwigPyPacked_str(SwigPyPacked *v)
2080 {
2081  char result[SWIG_BUFFER_SIZE];
2082  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2083  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2084  } else {
2085  return SWIG_Python_str_FromChar(v->ty->name);
2086  }
2087 }
2088 
2089 SWIGRUNTIME int
2090 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2091 {
2092  size_t i = v->size;
2093  size_t j = w->size;
2094  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2095  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2096 }
2097 
2098 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2099 
2100 SWIGRUNTIME PyTypeObject*
2101 SwigPyPacked_type(void) {
2102  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2103  return type;
2104 }
2105 
2106 SWIGRUNTIMEINLINE int
2107 SwigPyPacked_Check(PyObject *op) {
2108  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2109  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2110 }
2111 
2112 SWIGRUNTIME void
2113 SwigPyPacked_dealloc(PyObject *v)
2114 {
2115  if (SwigPyPacked_Check(v)) {
2116  SwigPyPacked *sobj = (SwigPyPacked *) v;
2117  free(sobj->pack);
2118  }
2119  PyObject_DEL(v);
2120 }
2121 
2122 SWIGRUNTIME PyTypeObject*
2123 SwigPyPacked_TypeOnce(void) {
2124  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2125  static PyTypeObject swigpypacked_type;
2126  static int type_init = 0;
2127  if (!type_init) {
2128  const PyTypeObject tmp = {
2129  /* PyObject header changed in Python 3 */
2130 #if PY_VERSION_HEX>=0x03000000
2131  PyVarObject_HEAD_INIT(NULL, 0)
2132 #else
2133  PyObject_HEAD_INIT(NULL)
2134  0, /* ob_size */
2135 #endif
2136  (char *)"SwigPyPacked", /* tp_name */
2137  sizeof(SwigPyPacked), /* tp_basicsize */
2138  0, /* tp_itemsize */
2139  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2140  (printfunc)SwigPyPacked_print, /* tp_print */
2141  (getattrfunc)0, /* tp_getattr */
2142  (setattrfunc)0, /* tp_setattr */
2143 #if PY_VERSION_HEX>=0x03000000
2144  0, /* tp_reserved in 3.0.1 */
2145 #else
2146  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2147 #endif
2148  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2149  0, /* tp_as_number */
2150  0, /* tp_as_sequence */
2151  0, /* tp_as_mapping */
2152  (hashfunc)0, /* tp_hash */
2153  (ternaryfunc)0, /* tp_call */
2154  (reprfunc)SwigPyPacked_str, /* tp_str */
2155  PyObject_GenericGetAttr, /* tp_getattro */
2156  0, /* tp_setattro */
2157  0, /* tp_as_buffer */
2158  Py_TPFLAGS_DEFAULT, /* tp_flags */
2159  swigpacked_doc, /* tp_doc */
2160  0, /* tp_traverse */
2161  0, /* tp_clear */
2162  0, /* tp_richcompare */
2163  0, /* tp_weaklistoffset */
2164 #if PY_VERSION_HEX >= 0x02020000
2165  0, /* tp_iter */
2166  0, /* tp_iternext */
2167  0, /* tp_methods */
2168  0, /* tp_members */
2169  0, /* tp_getset */
2170  0, /* tp_base */
2171  0, /* tp_dict */
2172  0, /* tp_descr_get */
2173  0, /* tp_descr_set */
2174  0, /* tp_dictoffset */
2175  0, /* tp_init */
2176  0, /* tp_alloc */
2177  0, /* tp_new */
2178  0, /* tp_free */
2179  0, /* tp_is_gc */
2180  0, /* tp_bases */
2181  0, /* tp_mro */
2182  0, /* tp_cache */
2183  0, /* tp_subclasses */
2184  0, /* tp_weaklist */
2185 #endif
2186 #if PY_VERSION_HEX >= 0x02030000
2187  0, /* tp_del */
2188 #endif
2189 #if PY_VERSION_HEX >= 0x02060000
2190  0, /* tp_version_tag */
2191 #endif
2192 #if PY_VERSION_HEX >= 0x03040000
2193  0, /* tp_finalize */
2194 #endif
2195 #ifdef COUNT_ALLOCS
2196  0, /* tp_allocs */
2197  0, /* tp_frees */
2198  0, /* tp_maxalloc */
2199 #if PY_VERSION_HEX >= 0x02050000
2200  0, /* tp_prev */
2201 #endif
2202  0 /* tp_next */
2203 #endif
2204  };
2205  swigpypacked_type = tmp;
2206  type_init = 1;
2207 #if PY_VERSION_HEX < 0x02020000
2208  swigpypacked_type.ob_type = &PyType_Type;
2209 #else
2210  if (PyType_Ready(&swigpypacked_type) < 0)
2211  return NULL;
2212 #endif
2213  }
2214  return &swigpypacked_type;
2215 }
2216 
2217 SWIGRUNTIME PyObject *
2218 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2219 {
2220  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2221  if (sobj) {
2222  void *pack = malloc(size);
2223  if (pack) {
2224  memcpy(pack, ptr, size);
2225  sobj->pack = pack;
2226  sobj->ty = ty;
2227  sobj->size = size;
2228  } else {
2229  PyObject_DEL((PyObject *) sobj);
2230  sobj = 0;
2231  }
2232  }
2233  return (PyObject *) sobj;
2234 }
2235 
2236 SWIGRUNTIME swig_type_info *
2237 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2238 {
2239  if (SwigPyPacked_Check(obj)) {
2240  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2241  if (sobj->size != size) return 0;
2242  memcpy(ptr, sobj->pack, size);
2243  return sobj->ty;
2244  } else {
2245  return 0;
2246  }
2247 }
2248 
2249 /* -----------------------------------------------------------------------------
2250  * pointers/data manipulation
2251  * ----------------------------------------------------------------------------- */
2252 
2253 SWIGRUNTIMEINLINE PyObject *
2254 _SWIG_This(void)
2255 {
2256  return SWIG_Python_str_FromChar("this");
2257 }
2258 
2259 static PyObject *swig_this = NULL;
2260 
2261 SWIGRUNTIME PyObject *
2262 SWIG_This(void)
2263 {
2264  if (swig_this == NULL)
2265  swig_this = _SWIG_This();
2266  return swig_this;
2267 }
2268 
2269 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2270 
2271 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2272 #if PY_VERSION_HEX>=0x03000000
2273 #define SWIG_PYTHON_SLOW_GETSET_THIS
2274 #endif
2275 
2276 SWIGRUNTIME SwigPyObject *
2277 SWIG_Python_GetSwigThis(PyObject *pyobj)
2278 {
2279  PyObject *obj;
2280 
2281  if (SwigPyObject_Check(pyobj))
2282  return (SwigPyObject *) pyobj;
2283 
2284 #ifdef SWIGPYTHON_BUILTIN
2285  (void)obj;
2286 # ifdef PyWeakref_CheckProxy
2287  if (PyWeakref_CheckProxy(pyobj)) {
2288  pyobj = PyWeakref_GET_OBJECT(pyobj);
2289  if (pyobj && SwigPyObject_Check(pyobj))
2290  return (SwigPyObject*) pyobj;
2291  }
2292 # endif
2293  return NULL;
2294 #else
2295 
2296  obj = 0;
2297 
2298 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2299  if (PyInstance_Check(pyobj)) {
2300  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2301  } else {
2302  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2303  if (dictptr != NULL) {
2304  PyObject *dict = *dictptr;
2305  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2306  } else {
2307 #ifdef PyWeakref_CheckProxy
2308  if (PyWeakref_CheckProxy(pyobj)) {
2309  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2310  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2311  }
2312 #endif
2313  obj = PyObject_GetAttr(pyobj,SWIG_This());
2314  if (obj) {
2315  Py_DECREF(obj);
2316  } else {
2317  if (PyErr_Occurred()) PyErr_Clear();
2318  return 0;
2319  }
2320  }
2321  }
2322 #else
2323  obj = PyObject_GetAttr(pyobj,SWIG_This());
2324  if (obj) {
2325  Py_DECREF(obj);
2326  } else {
2327  if (PyErr_Occurred()) PyErr_Clear();
2328  return 0;
2329  }
2330 #endif
2331  if (obj && !SwigPyObject_Check(obj)) {
2332  /* a PyObject is called 'this', try to get the 'real this'
2333  SwigPyObject from it */
2334  return SWIG_Python_GetSwigThis(obj);
2335  }
2336  return (SwigPyObject *)obj;
2337 #endif
2338 }
2339 
2340 /* Acquire a pointer value */
2341 
2342 SWIGRUNTIME int
2343 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2344  if (own == SWIG_POINTER_OWN) {
2345  SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2346  if (sobj) {
2347  int oldown = sobj->own;
2348  sobj->own = own;
2349  return oldown;
2350  }
2351  }
2352  return 0;
2353 }
2354 
2355 /* Convert a pointer value */
2356 
2357 SWIGRUNTIME int
2358 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2359  int res;
2360  SwigPyObject *sobj;
2361  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2362 
2363  if (!obj)
2364  return SWIG_ERROR;
2365  if (obj == Py_None && !implicit_conv) {
2366  if (ptr)
2367  *ptr = 0;
2368  return SWIG_OK;
2369  }
2370 
2371  res = SWIG_ERROR;
2372 
2373  sobj = SWIG_Python_GetSwigThis(obj);
2374  if (own)
2375  *own = 0;
2376  while (sobj) {
2377  void *vptr = sobj->ptr;
2378  if (ty) {
2379  swig_type_info *to = sobj->ty;
2380  if (to == ty) {
2381  /* no type cast needed */
2382  if (ptr) *ptr = vptr;
2383  break;
2384  } else {
2385  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2386  if (!tc) {
2387  sobj = (SwigPyObject *)sobj->next;
2388  } else {
2389  if (ptr) {
2390  int newmemory = 0;
2391  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2392  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2393  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2394  if (own)
2395  *own = *own | SWIG_CAST_NEW_MEMORY;
2396  }
2397  }
2398  break;
2399  }
2400  }
2401  } else {
2402  if (ptr) *ptr = vptr;
2403  break;
2404  }
2405  }
2406  if (sobj) {
2407  if (own)
2408  *own = *own | sobj->own;
2409  if (flags & SWIG_POINTER_DISOWN) {
2410  sobj->own = 0;
2411  }
2412  res = SWIG_OK;
2413  } else {
2414  if (implicit_conv) {
2415  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2416  if (data && !data->implicitconv) {
2417  PyObject *klass = data->klass;
2418  if (klass) {
2419  PyObject *impconv;
2420  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2421  impconv = SWIG_Python_CallFunctor(klass, obj);
2422  data->implicitconv = 0;
2423  if (PyErr_Occurred()) {
2424  PyErr_Clear();
2425  impconv = 0;
2426  }
2427  if (impconv) {
2428  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2429  if (iobj) {
2430  void *vptr;
2431  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2432  if (SWIG_IsOK(res)) {
2433  if (ptr) {
2434  *ptr = vptr;
2435  /* transfer the ownership to 'ptr' */
2436  iobj->own = 0;
2437  res = SWIG_AddCast(res);
2438  res = SWIG_AddNewMask(res);
2439  } else {
2440  res = SWIG_AddCast(res);
2441  }
2442  }
2443  }
2444  Py_DECREF(impconv);
2445  }
2446  }
2447  }
2448  }
2449  if (!SWIG_IsOK(res) && obj == Py_None) {
2450  if (ptr)
2451  *ptr = 0;
2452  if (PyErr_Occurred())
2453  PyErr_Clear();
2454  res = SWIG_OK;
2455  }
2456  }
2457  return res;
2458 }
2459 
2460 /* Convert a function ptr value */
2461 
2462 SWIGRUNTIME int
2463 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2464  if (!PyCFunction_Check(obj)) {
2465  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2466  } else {
2467  void *vptr = 0;
2468 
2469  /* here we get the method pointer for callbacks */
2470  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2471  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2472  if (desc)
2473  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2474  if (!desc)
2475  return SWIG_ERROR;
2476  if (ty) {
2477  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2478  if (tc) {
2479  int newmemory = 0;
2480  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2481  assert(!newmemory); /* newmemory handling not yet implemented */
2482  } else {
2483  return SWIG_ERROR;
2484  }
2485  } else {
2486  *ptr = vptr;
2487  }
2488  return SWIG_OK;
2489  }
2490 }
2491 
2492 /* Convert a packed value value */
2493 
2494 SWIGRUNTIME int
2495 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2496  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2497  if (!to) return SWIG_ERROR;
2498  if (ty) {
2499  if (to != ty) {
2500  /* check type cast? */
2501  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2502  if (!tc) return SWIG_ERROR;
2503  }
2504  }
2505  return SWIG_OK;
2506 }
2507 
2508 /* -----------------------------------------------------------------------------
2509  * Create a new pointer object
2510  * ----------------------------------------------------------------------------- */
2511 
2512 /*
2513  Create a new instance object, without calling __init__, and set the
2514  'this' attribute.
2515 */
2516 
2517 SWIGRUNTIME PyObject*
2518 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2519 {
2520 #if (PY_VERSION_HEX >= 0x02020000)
2521  PyObject *inst = 0;
2522  PyObject *newraw = data->newraw;
2523  if (newraw) {
2524  inst = PyObject_Call(newraw, data->newargs, NULL);
2525  if (inst) {
2526 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2527  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2528  if (dictptr != NULL) {
2529  PyObject *dict = *dictptr;
2530  if (dict == NULL) {
2531  dict = PyDict_New();
2532  *dictptr = dict;
2533  PyDict_SetItem(dict, SWIG_This(), swig_this);
2534  }
2535  }
2536 #else
2537  PyObject *key = SWIG_This();
2538  PyObject_SetAttr(inst, key, swig_this);
2539 #endif
2540  }
2541  } else {
2542 #if PY_VERSION_HEX >= 0x03000000
2543  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2544  if (inst) {
2545  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2546  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2547  }
2548 #else
2549  PyObject *dict = PyDict_New();
2550  if (dict) {
2551  PyDict_SetItem(dict, SWIG_This(), swig_this);
2552  inst = PyInstance_NewRaw(data->newargs, dict);
2553  Py_DECREF(dict);
2554  }
2555 #endif
2556  }
2557  return inst;
2558 #else
2559 #if (PY_VERSION_HEX >= 0x02010000)
2560  PyObject *inst = 0;
2561  PyObject *dict = PyDict_New();
2562  if (dict) {
2563  PyDict_SetItem(dict, SWIG_This(), swig_this);
2564  inst = PyInstance_NewRaw(data->newargs, dict);
2565  Py_DECREF(dict);
2566  }
2567  return (PyObject *) inst;
2568 #else
2569  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2570  if (inst == NULL) {
2571  return NULL;
2572  }
2573  inst->in_class = (PyClassObject *)data->newargs;
2574  Py_INCREF(inst->in_class);
2575  inst->in_dict = PyDict_New();
2576  if (inst->in_dict == NULL) {
2577  Py_DECREF(inst);
2578  return NULL;
2579  }
2580 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2581  inst->in_weakreflist = NULL;
2582 #endif
2583 #ifdef Py_TPFLAGS_GC
2584  PyObject_GC_Init(inst);
2585 #endif
2586  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2587  return (PyObject *) inst;
2588 #endif
2589 #endif
2590 }
2591 
2592 SWIGRUNTIME void
2593 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2594 {
2595  PyObject *dict;
2596 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2597  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2598  if (dictptr != NULL) {
2599  dict = *dictptr;
2600  if (dict == NULL) {
2601  dict = PyDict_New();
2602  *dictptr = dict;
2603  }
2604  PyDict_SetItem(dict, SWIG_This(), swig_this);
2605  return;
2606  }
2607 #endif
2608  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2609  PyDict_SetItem(dict, SWIG_This(), swig_this);
2610  Py_DECREF(dict);
2611 }
2612 
2613 
2614 SWIGINTERN PyObject *
2615 SWIG_Python_InitShadowInstance(PyObject *args) {
2616  PyObject *obj[2];
2617  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2618  return NULL;
2619  } else {
2620  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2621  if (sthis) {
2622  SwigPyObject_append((PyObject*) sthis, obj[1]);
2623  } else {
2624  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2625  }
2626  return SWIG_Py_Void();
2627  }
2628 }
2629 
2630 /* Create a new pointer object */
2631 
2632 SWIGRUNTIME PyObject *
2633 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2634  SwigPyClientData *clientdata;
2635  PyObject * robj;
2636  int own;
2637 
2638  if (!ptr)
2639  return SWIG_Py_Void();
2640 
2641  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2642  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2643  if (clientdata && clientdata->pytype) {
2644  SwigPyObject *newobj;
2645  if (flags & SWIG_BUILTIN_TP_INIT) {
2646  newobj = (SwigPyObject*) self;
2647  if (newobj->ptr) {
2648  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2649  while (newobj->next)
2650  newobj = (SwigPyObject *) newobj->next;
2651  newobj->next = next_self;
2652  newobj = (SwigPyObject *)next_self;
2653 #ifdef SWIGPYTHON_BUILTIN
2654  newobj->dict = 0;
2655 #endif
2656  }
2657  } else {
2658  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2659 #ifdef SWIGPYTHON_BUILTIN
2660  newobj->dict = 0;
2661 #endif
2662  }
2663  if (newobj) {
2664  newobj->ptr = ptr;
2665  newobj->ty = type;
2666  newobj->own = own;
2667  newobj->next = 0;
2668  return (PyObject*) newobj;
2669  }
2670  return SWIG_Py_Void();
2671  }
2672 
2673  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2674 
2675  robj = SwigPyObject_New(ptr, type, own);
2676  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2677  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2678  Py_DECREF(robj);
2679  robj = inst;
2680  }
2681  return robj;
2682 }
2683 
2684 /* Create a new packed object */
2685 
2686 SWIGRUNTIMEINLINE PyObject *
2687 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2688  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2689 }
2690 
2691 /* -----------------------------------------------------------------------------*
2692  * Get type list
2693  * -----------------------------------------------------------------------------*/
2694 
2695 #ifdef SWIG_LINK_RUNTIME
2696 void *SWIG_ReturnGlobalTypeList(void *);
2697 #endif
2698 
2699 SWIGRUNTIME swig_module_info *
2700 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2701  static void *type_pointer = (void *)0;
2702  /* first check if module already created */
2703  if (!type_pointer) {
2704 #ifdef SWIG_LINK_RUNTIME
2705  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2706 #else
2707 # ifdef SWIGPY_USE_CAPSULE
2708  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2709 # else
2710  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2711  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2712 # endif
2713  if (PyErr_Occurred()) {
2714  PyErr_Clear();
2715  type_pointer = (void *)0;
2716  }
2717 #endif
2718  }
2719  return (swig_module_info *) type_pointer;
2720 }
2721 
2722 #if PY_MAJOR_VERSION < 2
2723 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2724  is copied out of Python/modsupport.c in python version 2.3.4 */
2725 SWIGINTERN int
2726 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2727 {
2728  PyObject *dict;
2729  if (!PyModule_Check(m)) {
2730  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2731  return SWIG_ERROR;
2732  }
2733  if (!o) {
2734  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2735  return SWIG_ERROR;
2736  }
2737 
2738  dict = PyModule_GetDict(m);
2739  if (dict == NULL) {
2740  /* Internal error -- modules must have a dict! */
2741  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2742  PyModule_GetName(m));
2743  return SWIG_ERROR;
2744  }
2745  if (PyDict_SetItemString(dict, name, o))
2746  return SWIG_ERROR;
2747  Py_DECREF(o);
2748  return SWIG_OK;
2749 }
2750 #endif
2751 
2752 SWIGRUNTIME void
2753 #ifdef SWIGPY_USE_CAPSULE
2754 SWIG_Python_DestroyModule(PyObject *obj)
2755 #else
2756 SWIG_Python_DestroyModule(void *vptr)
2757 #endif
2758 {
2759 #ifdef SWIGPY_USE_CAPSULE
2760  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2761 #else
2762  swig_module_info *swig_module = (swig_module_info *) vptr;
2763 #endif
2764  swig_type_info **types = swig_module->types;
2765  size_t i;
2766  for (i =0; i < swig_module->size; ++i) {
2767  swig_type_info *ty = types[i];
2768  if (ty->owndata) {
2769  SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2770  if (data) SwigPyClientData_Del(data);
2771  }
2772  }
2773  Py_DECREF(SWIG_This());
2774  swig_this = NULL;
2775 }
2776 
2777 SWIGRUNTIME void
2778 SWIG_Python_SetModule(swig_module_info *swig_module) {
2779 #if PY_VERSION_HEX >= 0x03000000
2780  /* Add a dummy module object into sys.modules */
2781  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2782 #else
2783  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2784  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2785 #endif
2786 #ifdef SWIGPY_USE_CAPSULE
2787  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2788  if (pointer && module) {
2789  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2790  } else {
2791  Py_XDECREF(pointer);
2792  }
2793 #else
2794  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2795  if (pointer && module) {
2796  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2797  } else {
2798  Py_XDECREF(pointer);
2799  }
2800 #endif
2801 }
2802 
2803 /* The python cached type query */
2804 SWIGRUNTIME PyObject *
2805 SWIG_Python_TypeCache(void) {
2806  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2807  return cache;
2808 }
2809 
2810 SWIGRUNTIME swig_type_info *
2811 SWIG_Python_TypeQuery(const char *type)
2812 {
2813  PyObject *cache = SWIG_Python_TypeCache();
2814  PyObject *key = SWIG_Python_str_FromChar(type);
2815  PyObject *obj = PyDict_GetItem(cache, key);
2816  swig_type_info *descriptor;
2817  if (obj) {
2818 #ifdef SWIGPY_USE_CAPSULE
2819  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2820 #else
2821  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2822 #endif
2823  } else {
2824  swig_module_info *swig_module = SWIG_GetModule(0);
2825  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2826  if (descriptor) {
2827 #ifdef SWIGPY_USE_CAPSULE
2828  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2829 #else
2830  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2831 #endif
2832  PyDict_SetItem(cache, key, obj);
2833  Py_DECREF(obj);
2834  }
2835  }
2836  Py_DECREF(key);
2837  return descriptor;
2838 }
2839 
2840 /*
2841  For backward compatibility only
2842 */
2843 #define SWIG_POINTER_EXCEPTION 0
2844 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2845 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2846 
2847 SWIGRUNTIME int
2848 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2849 {
2850  if (PyErr_Occurred()) {
2851  PyObject *type = 0;
2852  PyObject *value = 0;
2853  PyObject *traceback = 0;
2854  PyErr_Fetch(&type, &value, &traceback);
2855  if (value) {
2856  char *tmp;
2857  PyObject *old_str = PyObject_Str(value);
2858  Py_XINCREF(type);
2859  PyErr_Clear();
2860  if (infront) {
2861  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2862  } else {
2863  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2864  }
2865  SWIG_Python_str_DelForPy3(tmp);
2866  Py_DECREF(old_str);
2867  }
2868  return 1;
2869  } else {
2870  return 0;
2871  }
2872 }
2873 
2874 SWIGRUNTIME int
2875 SWIG_Python_ArgFail(int argnum)
2876 {
2877  if (PyErr_Occurred()) {
2878  /* add information about failing argument */
2879  char mesg[256];
2880  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2881  return SWIG_Python_AddErrMesg(mesg, 1);
2882  } else {
2883  return 0;
2884  }
2885 }
2886 
2887 SWIGRUNTIMEINLINE const char *
2888 SwigPyObject_GetDesc(PyObject *self)
2889 {
2890  SwigPyObject *v = (SwigPyObject *)self;
2891  swig_type_info *ty = v ? v->ty : 0;
2892  return ty ? ty->str : "";
2893 }
2894 
2895 SWIGRUNTIME void
2896 SWIG_Python_TypeError(const char *type, PyObject *obj)
2897 {
2898  if (type) {
2899 #if defined(SWIG_COBJECT_TYPES)
2900  if (obj && SwigPyObject_Check(obj)) {
2901  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2902  if (otype) {
2903  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2904  type, otype);
2905  return;
2906  }
2907  } else
2908 #endif
2909  {
2910  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2911  if (otype) {
2912  PyObject *str = PyObject_Str(obj);
2913  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2914  if (cstr) {
2915  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2916  type, otype, cstr);
2917  SWIG_Python_str_DelForPy3(cstr);
2918  } else {
2919  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2920  type, otype);
2921  }
2922  Py_XDECREF(str);
2923  return;
2924  }
2925  }
2926  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2927  } else {
2928  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2929  }
2930 }
2931 
2932 
2933 /* Convert a pointer value, signal an exception on a type mismatch */
2934 SWIGRUNTIME void *
2935 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2936  void *result;
2937  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2938  PyErr_Clear();
2939 #if SWIG_POINTER_EXCEPTION
2940  if (flags) {
2941  SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2942  SWIG_Python_ArgFail(argnum);
2943  }
2944 #endif
2945  }
2946  return result;
2947 }
2948 
2949 #ifdef SWIGPYTHON_BUILTIN
2950 SWIGRUNTIME int
2951 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2952  PyTypeObject *tp = obj->ob_type;
2953  PyObject *descr;
2954  PyObject *encoded_name;
2955  descrsetfunc f;
2956  int res = -1;
2957 
2958 # ifdef Py_USING_UNICODE
2959  if (PyString_Check(name)) {
2960  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2961  if (!name)
2962  return -1;
2963  } else if (!PyUnicode_Check(name))
2964 # else
2965  if (!PyString_Check(name))
2966 # endif
2967  {
2968  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2969  return -1;
2970  } else {
2971  Py_INCREF(name);
2972  }
2973 
2974  if (!tp->tp_dict) {
2975  if (PyType_Ready(tp) < 0)
2976  goto done;
2977  }
2978 
2979  descr = _PyType_Lookup(tp, name);
2980  f = NULL;
2981  if (descr != NULL)
2982  f = descr->ob_type->tp_descr_set;
2983  if (!f) {
2984  if (PyString_Check(name)) {
2985  encoded_name = name;
2986  Py_INCREF(name);
2987  } else {
2988  encoded_name = PyUnicode_AsUTF8String(name);
2989  }
2990  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2991  Py_DECREF(encoded_name);
2992  } else {
2993  res = f(descr, obj, value);
2994  }
2995 
2996  done:
2997  Py_DECREF(name);
2998  return res;
2999 }
3000 #endif
3001 
3002 
3003 #ifdef __cplusplus
3004 }
3005 #endif
3006 
3007 
3008 
3009 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3010 
3011 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3012 
3013 
3014 
3015  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3016 
3017 /* -----------------------------------------------------------------------------
3018  * director_common.swg
3019  *
3020  * This file contains support for director classes which is common between
3021  * languages.
3022  * ----------------------------------------------------------------------------- */
3023 
3024 /*
3025  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
3026  'Swig' namespace. This could be useful for multi-modules projects.
3027 */
3028 #ifdef SWIG_DIRECTOR_STATIC
3029 /* Force anonymous (static) namespace */
3030 #define Swig
3031 #endif
3032 /* -----------------------------------------------------------------------------
3033  * director.swg
3034  *
3035  * This file contains support for director classes so that Python proxy
3036  * methods can be called from C++.
3037  * ----------------------------------------------------------------------------- */
3038 
3039 #ifndef SWIG_DIRECTOR_PYTHON_HEADER_
3040 #define SWIG_DIRECTOR_PYTHON_HEADER_
3041 
3042 #include <string>
3043 #include <iostream>
3044 #include <exception>
3045 #include <vector>
3046 #include <map>
3047 
3048 
3049 /*
3050  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
3051  table', and avoid multiple GetAttr calls to retrieve the python
3052  methods.
3053 */
3054 
3055 #ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
3056 #ifndef SWIG_PYTHON_DIRECTOR_VTABLE
3057 #define SWIG_PYTHON_DIRECTOR_VTABLE
3058 #endif
3059 #endif
3060 
3061 
3062 
3063 /*
3064  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
3065  Undefined Exception Handler provided by swig.
3066 */
3067 #ifndef SWIG_DIRECTOR_NO_UEH
3068 #ifndef SWIG_DIRECTOR_UEH
3069 #define SWIG_DIRECTOR_UEH
3070 #endif
3071 #endif
3072 
3073 
3074 /*
3075  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
3076  native C++ RTTI and dynamic_cast<>. But be aware that directors
3077  could stop working when using this option.
3078 */
3079 #ifdef SWIG_DIRECTOR_NORTTI
3080 /*
3081  When we don't use the native C++ RTTI, we implement a minimal one
3082  only for Directors.
3083 */
3084 # ifndef SWIG_DIRECTOR_RTDIR
3085 # define SWIG_DIRECTOR_RTDIR
3086 
3087 namespace Swig {
3088  class Director;
3089  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
3090  static std::map<void *, Director *> rtdir_map;
3091  return rtdir_map;
3092  }
3093 
3094  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
3095  get_rtdir_map()[vptr] = rtdir;
3096  }
3097 
3098  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
3099  std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
3100  Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
3101  return rtdir;
3102  }
3103 }
3104 # endif /* SWIG_DIRECTOR_RTDIR */
3105 
3106 # define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
3107 # define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)
3108 
3109 #else
3110 
3111 # define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
3112 # define SWIG_DIRECTOR_RGTR(ARG1, ARG2)
3113 
3114 #endif /* SWIG_DIRECTOR_NORTTI */
3115 
3116 extern "C" {
3117  struct swig_type_info;
3118 }
3119 
3120 namespace Swig {
3121 
3122  /* memory handler */
3123  struct GCItem {
3124  virtual ~GCItem() {}
3125 
3126  virtual int get_own() const {
3127  return 0;
3128  }
3129  };
3130 
3131  struct GCItem_var {
3132  GCItem_var(GCItem *item = 0) : _item(item) {
3133  }
3134 
3135  GCItem_var& operator=(GCItem *item) {
3136  GCItem *tmp = _item;
3137  _item = item;
3138  delete tmp;
3139  return *this;
3140  }
3141 
3142  ~GCItem_var() {
3143  delete _item;
3144  }
3145 
3146  GCItem * operator->() const {
3147  return _item;
3148  }
3149 
3150  private:
3151  GCItem *_item;
3152  };
3153 
3155  GCItem_Object(int own) : _own(own) {
3156  }
3157 
3158  virtual ~GCItem_Object() {
3159  }
3160 
3161  int get_own() const {
3162  return _own;
3163  }
3164 
3165  private:
3166  int _own;
3167  };
3168 
3169  template <typename Type>
3170  struct GCItem_T : GCItem {
3171  GCItem_T(Type *ptr) : _ptr(ptr) {
3172  }
3173 
3174  virtual ~GCItem_T() {
3175  delete _ptr;
3176  }
3177 
3178  private:
3179  Type *_ptr;
3180  };
3181 
3182  template <typename Type>
3183  struct GCArray_T : GCItem {
3184  GCArray_T(Type *ptr) : _ptr(ptr) {
3185  }
3186 
3187  virtual ~GCArray_T() {
3188  delete[] _ptr;
3189  }
3190 
3191  private:
3192  Type *_ptr;
3193  };
3194 
3195  /* base class for director exceptions */
3196  class DirectorException : public std::exception {
3197  protected:
3198  std::string swig_msg;
3199  public:
3200  DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
3201  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3202  if (msg[0]) {
3203  swig_msg += " ";
3204  swig_msg += msg;
3205  }
3206  if (!PyErr_Occurred()) {
3207  PyErr_SetString(error, what());
3208  }
3209  SWIG_PYTHON_THREAD_END_BLOCK;
3210  }
3211 
3212  virtual ~DirectorException() throw() {
3213  }
3214 
3215  /* Deprecated, use what() instead */
3216  const char *getMessage() const {
3217  return what();
3218  }
3219 
3220  const char *what() const throw() {
3221  return swig_msg.c_str();
3222  }
3223 
3224  static void raise(PyObject *error, const char *msg) {
3225  throw DirectorException(error, msg);
3226  }
3227 
3228  static void raise(const char *msg) {
3229  raise(PyExc_RuntimeError, msg);
3230  }
3231  };
3232 
3233  /* unknown exception handler */
3235 #ifdef SWIG_DIRECTOR_UEH
3236  static void handler() {
3237  try {
3238  throw;
3239  } catch (DirectorException& e) {
3240  std::cerr << "SWIG Director exception caught:" << std::endl
3241  << e.what() << std::endl;
3242  } catch (std::exception& e) {
3243  std::cerr << "std::exception caught: "<< e.what() << std::endl;
3244  } catch (...) {
3245  std::cerr << "Unknown exception caught." << std::endl;
3246  }
3247 
3248  std::cerr << std::endl
3249  << "Python interpreter traceback:" << std::endl;
3250  PyErr_Print();
3251  std::cerr << std::endl;
3252 
3253  std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
3254  << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
3255  << std::endl
3256  << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
3257  throw;
3258  }
3259 
3260  public:
3261 
3262  std::unexpected_handler old;
3263  UnknownExceptionHandler(std::unexpected_handler nh = handler) {
3264  old = std::set_unexpected(nh);
3265  }
3266 
3268  std::set_unexpected(old);
3269  }
3270 #endif
3271  };
3272 
3273  /* type mismatch in the return value from a python method call */
3275  public:
3276  DirectorTypeMismatchException(PyObject *error, const char *msg="")
3277  : DirectorException(error, "SWIG director type mismatch", msg) {
3278  }
3279 
3280  DirectorTypeMismatchException(const char *msg="")
3281  : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
3282  }
3283 
3284  static void raise(PyObject *error, const char *msg) {
3285  throw DirectorTypeMismatchException(error, msg);
3286  }
3287 
3288  static void raise(const char *msg) {
3289  throw DirectorTypeMismatchException(msg);
3290  }
3291  };
3292 
3293  /* any python exception that occurs during a director method call */
3295  public:
3296  DirectorMethodException(const char *msg = "")
3297  : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
3298  }
3299 
3300  static void raise(const char *msg) {
3301  throw DirectorMethodException(msg);
3302  }
3303  };
3304 
3305  /* attempt to call a pure virtual method via a director method */
3307  public:
3308  DirectorPureVirtualException(const char *msg = "")
3309  : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
3310  }
3311 
3312  static void raise(const char *msg) {
3313  throw DirectorPureVirtualException(msg);
3314  }
3315  };
3316 
3317 
3318 #if defined(SWIG_PYTHON_THREADS)
3319 /* __THREAD__ is the old macro to activate some thread support */
3320 # if !defined(__THREAD__)
3321 # define __THREAD__ 1
3322 # endif
3323 #endif
3324 
3325 #ifdef __THREAD__
3326 # include "pythread.h"
3327  class Guard {
3328  PyThread_type_lock &mutex_;
3329 
3330  public:
3331  Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
3332  PyThread_acquire_lock(mutex_, WAIT_LOCK);
3333  }
3334 
3335  ~Guard() {
3336  PyThread_release_lock(mutex_);
3337  }
3338  };
3339 # define SWIG_GUARD(mutex) Guard _guard(mutex)
3340 #else
3341 # define SWIG_GUARD(mutex)
3342 #endif
3343 
3344  /* director base class */
3345  class Director {
3346  private:
3347  /* pointer to the wrapped python object */
3348  PyObject *swig_self;
3349  /* flag indicating whether the object is owned by python or c++ */
3350  mutable bool swig_disown_flag;
3351 
3352  /* decrement the reference count of the wrapped python object */
3353  void swig_decref() const {
3354  if (swig_disown_flag) {
3355  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3356  Py_DECREF(swig_self);
3357  SWIG_PYTHON_THREAD_END_BLOCK;
3358  }
3359  }
3360 
3361  public:
3362  /* wrap a python object. */
3363  Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
3364  }
3365 
3366  /* discard our reference at destruction */
3367  virtual ~Director() {
3368  swig_decref();
3369  }
3370 
3371  /* return a pointer to the wrapped python object */
3372  PyObject *swig_get_self() const {
3373  return swig_self;
3374  }
3375 
3376  /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
3377  void swig_disown() const {
3378  if (!swig_disown_flag) {
3379  swig_disown_flag=true;
3380  swig_incref();
3381  }
3382  }
3383 
3384  /* increase the reference count of the wrapped python object */
3385  void swig_incref() const {
3386  if (swig_disown_flag) {
3387  Py_INCREF(swig_self);
3388  }
3389  }
3390 
3391  /* methods to implement pseudo protected director members */
3392  virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
3393  return true;
3394  }
3395 
3396  virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
3397  }
3398 
3399  /* ownership management */
3400  private:
3401  typedef std::map<void *, GCItem_var> swig_ownership_map;
3402  mutable swig_ownership_map swig_owner;
3403 #ifdef __THREAD__
3404  static PyThread_type_lock swig_mutex_own;
3405 #endif
3406 
3407  public:
3408  template <typename Type>
3409  void swig_acquire_ownership_array(Type *vptr) const {
3410  if (vptr) {
3411  SWIG_GUARD(swig_mutex_own);
3412  swig_owner[vptr] = new GCArray_T<Type>(vptr);
3413  }
3414  }
3415 
3416  template <typename Type>
3417  void swig_acquire_ownership(Type *vptr) const {
3418  if (vptr) {
3419  SWIG_GUARD(swig_mutex_own);
3420  swig_owner[vptr] = new GCItem_T<Type>(vptr);
3421  }
3422  }
3423 
3424  void swig_acquire_ownership_obj(void *vptr, int own) const {
3425  if (vptr && own) {
3426  SWIG_GUARD(swig_mutex_own);
3427  swig_owner[vptr] = new GCItem_Object(own);
3428  }
3429  }
3430 
3431  int swig_release_ownership(void *vptr) const {
3432  int own = 0;
3433  if (vptr) {
3434  SWIG_GUARD(swig_mutex_own);
3435  swig_ownership_map::iterator iter = swig_owner.find(vptr);
3436  if (iter != swig_owner.end()) {
3437  own = iter->second->get_own();
3438  swig_owner.erase(iter);
3439  }
3440  }
3441  return own;
3442  }
3443 
3444  template <typename Type>
3445  static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
3446  SwigPyObject *sobj = (SwigPyObject *)pyobj;
3447  sobj->own = 0;
3448  Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
3449  if (d)
3450  d->swig_disown();
3451  return PyWeakref_NewProxy(pyobj, NULL);
3452  }
3453  };
3454 
3455 #ifdef __THREAD__
3456  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
3457 #endif
3458 }
3459 
3460 #endif
3461 
3462 /* -------- TYPES TABLE (BEGIN) -------- */
3463 
3464 #define SWIGTYPE_p_Pythia8__AlpgenHooks swig_types[0]
3465 #define SWIGTYPE_p_Pythia8__AlpgenPar swig_types[1]
3466 #define SWIGTYPE_p_Pythia8__AlphaEM swig_types[2]
3467 #define SWIGTYPE_p_Pythia8__AlphaStrong swig_types[3]
3468 #define SWIGTYPE_p_Pythia8__Angantyr swig_types[4]
3469 #define SWIGTYPE_p_Pythia8__BeamParticle swig_types[5]
3470 #define SWIGTYPE_p_Pythia8__BeamRemnants swig_types[6]
3471 #define SWIGTYPE_p_Pythia8__BeamShape swig_types[7]
3472 #define SWIGTYPE_p_Pythia8__BoseEinstein swig_types[8]
3473 #define SWIGTYPE_p_Pythia8__BoseEinsteinHadron swig_types[9]
3474 #define SWIGTYPE_p_Pythia8__CJKL swig_types[10]
3475 #define SWIGTYPE_p_Pythia8__CTEQ5L swig_types[11]
3476 #define SWIGTYPE_p_Pythia8__CTEQ6pdf swig_types[12]
3477 #define SWIGTYPE_p_Pythia8__CellJet swig_types[13]
3478 #define SWIGTYPE_p_Pythia8__ClusterJet swig_types[14]
3479 #define SWIGTYPE_p_Pythia8__Clustering swig_types[15]
3480 #define SWIGTYPE_p_Pythia8__ColConfig swig_types[16]
3481 #define SWIGTYPE_p_Pythia8__ColSinglet swig_types[17]
3482 #define SWIGTYPE_p_Pythia8__ColourDipole swig_types[18]
3483 #define SWIGTYPE_p_Pythia8__ColourJunction swig_types[19]
3484 #define SWIGTYPE_p_Pythia8__ColourParticle swig_types[20]
3485 #define SWIGTYPE_p_Pythia8__ColourReconnection swig_types[21]
3486 #define SWIGTYPE_p_Pythia8__ColourTracing swig_types[22]
3487 #define SWIGTYPE_p_Pythia8__CombineMatchingInput swig_types[23]
3488 #define SWIGTYPE_p_Pythia8__CoupSM swig_types[24]
3489 #define SWIGTYPE_p_Pythia8__CoupSUSY swig_types[25]
3490 #define SWIGTYPE_p_Pythia8__Couplings swig_types[26]
3491 #define SWIGTYPE_p_Pythia8__DecayChannel swig_types[27]
3492 #define SWIGTYPE_p_Pythia8__DecayHandler swig_types[28]
3493 #define SWIGTYPE_p_Pythia8__DoubleStrikman swig_types[29]
3494 #define SWIGTYPE_p_Pythia8__DummyForStreams swig_types[30]
3495 #define SWIGTYPE_p_Pythia8__EPAexternal swig_types[31]
3496 #define SWIGTYPE_p_Pythia8__EPPS16 swig_types[32]
3497 #define SWIGTYPE_p_Pythia8__EPS09 swig_types[33]
3498 #define SWIGTYPE_p_Pythia8__Event swig_types[34]
3499 #define SWIGTYPE_p_Pythia8__EventInfo swig_types[35]
3500 #define SWIGTYPE_p_Pythia8__FVec swig_types[36]
3501 #define SWIGTYPE_p_Pythia8__Flag swig_types[37]
3502 #define SWIGTYPE_p_Pythia8__FlavContainer swig_types[38]
3503 #define SWIGTYPE_p_Pythia8__FlavourRope swig_types[39]
3504 #define SWIGTYPE_p_Pythia8__GLISSANDOModel swig_types[40]
3505 #define SWIGTYPE_p_Pythia8__GRV94L swig_types[41]
3506 #define SWIGTYPE_p_Pythia8__GRVpiL swig_types[42]
3507 #define SWIGTYPE_p_Pythia8__GammaKinematics swig_types[43]
3508 #define SWIGTYPE_p_Pythia8__GammaMatrix swig_types[44]
3509 #define SWIGTYPE_p_Pythia8__GammaPoint swig_types[45]
3510 #define SWIGTYPE_p_Pythia8__HEPEUP swig_types[46]
3511 #define SWIGTYPE_p_Pythia8__HEPRUP swig_types[47]
3512 #define SWIGTYPE_p_Pythia8__HIInfo swig_types[48]
3513 #define SWIGTYPE_p_Pythia8__HIUserHooks swig_types[49]
3514 #define SWIGTYPE_p_Pythia8__HJSlowJet swig_types[50]
3515 #define SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions swig_types[51]
3516 #define SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions swig_types[52]
3517 #define SWIGTYPE_p_Pythia8__HMETau2FivePions swig_types[53]
3518 #define SWIGTYPE_p_Pythia8__HMETau2FourPions swig_types[54]
3519 #define SWIGTYPE_p_Pythia8__HMETau2Meson swig_types[55]
3520 #define SWIGTYPE_p_Pythia8__HMETau2PhaseSpace swig_types[56]
3521 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesons swig_types[57]
3522 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric swig_types[58]
3523 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons swig_types[59]
3524 #define SWIGTYPE_p_Pythia8__HMETau2ThreePions swig_types[60]
3525 #define SWIGTYPE_p_Pythia8__HMETau2TwoLeptons swig_types[61]
3526 #define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector swig_types[62]
3527 #define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar swig_types[63]
3528 #define SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma swig_types[64]
3529 #define SWIGTYPE_p_Pythia8__HMETauDecay swig_types[65]
3530 #define SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions swig_types[66]
3531 #define SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions swig_types[67]
3532 #define SWIGTYPE_p_Pythia8__HMEW2TwoFermions swig_types[68]
3533 #define SWIGTYPE_p_Pythia8__HMEX2TwoFermions swig_types[69]
3534 #define SWIGTYPE_p_Pythia8__HMEZ2TwoFermions swig_types[70]
3535 #define SWIGTYPE_p_Pythia8__HVStringFlav swig_types[71]
3536 #define SWIGTYPE_p_Pythia8__HVStringPT swig_types[72]
3537 #define SWIGTYPE_p_Pythia8__HVStringZ swig_types[73]
3538 #define SWIGTYPE_p_Pythia8__HadronLevel swig_types[74]
3539 #define SWIGTYPE_p_Pythia8__HadronScatter swig_types[75]
3540 #define SWIGTYPE_p_Pythia8__HadronScatterPair swig_types[76]
3541 #define SWIGTYPE_p_Pythia8__HardDiffraction swig_types[77]
3542 #define SWIGTYPE_p_Pythia8__HardProcess swig_types[78]
3543 #define SWIGTYPE_p_Pythia8__HeavyIons swig_types[79]
3544 #define SWIGTYPE_p_Pythia8__HelicityMatrixElement swig_types[80]
3545 #define SWIGTYPE_p_Pythia8__HelicityParticle swig_types[81]
3546 #define SWIGTYPE_p_Pythia8__HiddenValleyFragmentation swig_types[82]
3547 #define SWIGTYPE_p_Pythia8__Hist swig_types[83]
3548 #define SWIGTYPE_p_Pythia8__HistPlot swig_types[84]
3549 #define SWIGTYPE_p_Pythia8__History swig_types[85]
3550 #define SWIGTYPE_p_Pythia8__ImpactParameterGenerator swig_types[86]
3551 #define SWIGTYPE_p_Pythia8__InBeam swig_types[87]
3552 #define SWIGTYPE_p_Pythia8__InPair swig_types[88]
3553 #define SWIGTYPE_p_Pythia8__Info swig_types[89]
3554 #define SWIGTYPE_p_Pythia8__Isospin swig_types[90]
3555 #define SWIGTYPE_p_Pythia8__JetMatching swig_types[91]
3556 #define SWIGTYPE_p_Pythia8__JetMatchingAlpgen swig_types[92]
3557 #define SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen swig_types[93]
3558 #define SWIGTYPE_p_Pythia8__JetMatchingMadgraph swig_types[94]
3559 #define SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen swig_types[95]
3560 #define SWIGTYPE_p_Pythia8__Junction swig_types[96]
3561 #define SWIGTYPE_p_Pythia8__JunctionSplitting swig_types[97]
3562 #define SWIGTYPE_p_Pythia8__LHAGrid1 swig_types[98]
3563 #define SWIGTYPE_p_Pythia8__LHAPDF swig_types[99]
3564 #define SWIGTYPE_p_Pythia8__LHAParticle swig_types[100]
3565 #define SWIGTYPE_p_Pythia8__LHAProcess swig_types[101]
3566 #define SWIGTYPE_p_Pythia8__LHAgenerator swig_types[102]
3567 #define SWIGTYPE_p_Pythia8__LHAinitrwgt swig_types[103]
3568 #define SWIGTYPE_p_Pythia8__LHArwgt swig_types[104]
3569 #define SWIGTYPE_p_Pythia8__LHAscales swig_types[105]
3570 #define SWIGTYPE_p_Pythia8__LHAup swig_types[106]
3571 #define SWIGTYPE_p_Pythia8__LHAupAlpgen swig_types[107]
3572 #define SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8 swig_types[108]
3573 #define SWIGTYPE_p_Pythia8__LHAupHelaconia swig_types[109]
3574 #define SWIGTYPE_p_Pythia8__LHAupLHEF swig_types[110]
3575 #define SWIGTYPE_p_Pythia8__LHAupMadgraph swig_types[111]
3576 #define SWIGTYPE_p_Pythia8__LHAweight swig_types[112]
3577 #define SWIGTYPE_p_Pythia8__LHAweightgroup swig_types[113]
3578 #define SWIGTYPE_p_Pythia8__LHAweights swig_types[114]
3579 #define SWIGTYPE_p_Pythia8__LHAwgt swig_types[115]
3580 #define SWIGTYPE_p_Pythia8__LHEF3FromPythia8 swig_types[116]
3581 #define SWIGTYPE_p_Pythia8__LHblockT_double_t swig_types[117]
3582 #define SWIGTYPE_p_Pythia8__LHblockT_int_t swig_types[118]
3583 #define SWIGTYPE_p_Pythia8__LHblockT_std__string_t swig_types[119]
3584 #define SWIGTYPE_p_Pythia8__LHdecayChannel swig_types[120]
3585 #define SWIGTYPE_p_Pythia8__LHdecayTable swig_types[121]
3586 #define SWIGTYPE_p_Pythia8__LHgenericBlock swig_types[122]
3587 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t swig_types[123]
3588 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t swig_types[124]
3589 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t swig_types[125]
3590 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t swig_types[126]
3591 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t swig_types[127]
3592 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_7_t swig_types[128]
3593 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_8_t swig_types[129]
3594 #define SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t swig_types[130]
3595 #define SWIGTYPE_p_Pythia8__Lepton swig_types[131]
3596 #define SWIGTYPE_p_Pythia8__Lepton2gamma swig_types[132]
3597 #define SWIGTYPE_p_Pythia8__LeptonPoint swig_types[133]
3598 #define SWIGTYPE_p_Pythia8__LundFFAvg swig_types[134]
3599 #define SWIGTYPE_p_Pythia8__LundFFRaw swig_types[135]
3600 #define SWIGTYPE_p_Pythia8__MBReconUserHooks swig_types[136]
3601 #define SWIGTYPE_p_Pythia8__MSTWpdf swig_types[137]
3602 #define SWIGTYPE_p_Pythia8__MVec swig_types[138]
3603 #define SWIGTYPE_p_Pythia8__MadgraphPar swig_types[139]
3604 #define SWIGTYPE_p_Pythia8__Merging swig_types[140]
3605 #define SWIGTYPE_p_Pythia8__MergingHooks swig_types[141]
3606 #define SWIGTYPE_p_Pythia8__MiniStringFragmentation swig_types[142]
3607 #define SWIGTYPE_p_Pythia8__Mode swig_types[143]
3608 #define SWIGTYPE_p_Pythia8__MultiRadial swig_types[144]
3609 #define SWIGTYPE_p_Pythia8__MultipartonInteractions swig_types[145]
3610 #define SWIGTYPE_p_Pythia8__NNPDF swig_types[146]
3611 #define SWIGTYPE_p_Pythia8__NaiveSubCollisionModel swig_types[147]
3612 #define SWIGTYPE_p_Pythia8__NeutrinoPoint swig_types[148]
3613 #define SWIGTYPE_p_Pythia8__Nucleon swig_types[149]
3614 #define SWIGTYPE_p_Pythia8__NucleusModel swig_types[150]
3615 #define SWIGTYPE_p_Pythia8__OverlappingRopeDipole swig_types[151]
3616 #define SWIGTYPE_p_Pythia8__PDF swig_types[152]
3617 #define SWIGTYPE_p_Pythia8__PDF__PDFEnvelope swig_types[153]
3618 #define SWIGTYPE_p_Pythia8__PVec swig_types[154]
3619 #define SWIGTYPE_p_Pythia8__Parm swig_types[155]
3620 #define SWIGTYPE_p_Pythia8__Particle swig_types[156]
3621 #define SWIGTYPE_p_Pythia8__ParticleData swig_types[157]
3622 #define SWIGTYPE_p_Pythia8__ParticleDataEntry swig_types[158]
3623 #define SWIGTYPE_p_Pythia8__ParticleDecays swig_types[159]
3624 #define SWIGTYPE_p_Pythia8__PartonLevel swig_types[160]
3625 #define SWIGTYPE_p_Pythia8__PartonSystem swig_types[161]
3626 #define SWIGTYPE_p_Pythia8__PartonSystems swig_types[162]
3627 #define SWIGTYPE_p_Pythia8__PartonVertex swig_types[163]
3628 #define SWIGTYPE_p_Pythia8__PhaseSpace swig_types[164]
3629 #define SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy swig_types[165]
3630 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive swig_types[166]
3631 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic swig_types[167]
3632 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive swig_types[168]
3633 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma swig_types[169]
3634 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz swig_types[170]
3635 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive swig_types[171]
3636 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl swig_types[172]
3637 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl swig_types[173]
3638 #define SWIGTYPE_p_Pythia8__PhaseSpaceLHA swig_types[174]
3639 #define SWIGTYPE_p_Pythia8__PomFix swig_types[175]
3640 #define SWIGTYPE_p_Pythia8__PomH1FitAB swig_types[176]
3641 #define SWIGTYPE_p_Pythia8__PomH1Jets swig_types[177]
3642 #define SWIGTYPE_p_Pythia8__PomHISASD swig_types[178]
3643 #define SWIGTYPE_p_Pythia8__PowhegHooks swig_types[179]
3644 #define SWIGTYPE_p_Pythia8__PowhegProcs swig_types[180]
3645 #define SWIGTYPE_p_Pythia8__ProcessContainer swig_types[181]
3646 #define SWIGTYPE_p_Pythia8__ProcessLevel swig_types[182]
3647 #define SWIGTYPE_p_Pythia8__ProgressLog swig_types[183]
3648 #define SWIGTYPE_p_Pythia8__ProtonPoint swig_types[184]
3649 #define SWIGTYPE_p_Pythia8__Pythia swig_types[185]
3650 #define SWIGTYPE_p_Pythia8__RHadrons swig_types[186]
3651 #define SWIGTYPE_p_Pythia8__Reader swig_types[187]
3652 #define SWIGTYPE_p_Pythia8__ResolvedParton swig_types[188]
3653 #define SWIGTYPE_p_Pythia8__ResonanceChar swig_types[189]
3654 #define SWIGTYPE_p_Pythia8__ResonanceDecays swig_types[190]
3655 #define SWIGTYPE_p_Pythia8__ResonanceExcited swig_types[191]
3656 #define SWIGTYPE_p_Pythia8__ResonanceFour swig_types[192]
3657 #define SWIGTYPE_p_Pythia8__ResonanceGeneric swig_types[193]
3658 #define SWIGTYPE_p_Pythia8__ResonanceGluino swig_types[194]
3659 #define SWIGTYPE_p_Pythia8__ResonanceGmZ swig_types[195]
3660 #define SWIGTYPE_p_Pythia8__ResonanceGraviton swig_types[196]
3661 #define SWIGTYPE_p_Pythia8__ResonanceH swig_types[197]
3662 #define SWIGTYPE_p_Pythia8__ResonanceHchg swig_types[198]
3663 #define SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft swig_types[199]
3664 #define SWIGTYPE_p_Pythia8__ResonanceHchgchgRight swig_types[200]
3665 #define SWIGTYPE_p_Pythia8__ResonanceKKgluon swig_types[201]
3666 #define SWIGTYPE_p_Pythia8__ResonanceLeptoquark swig_types[202]
3667 #define SWIGTYPE_p_Pythia8__ResonanceNeut swig_types[203]
3668 #define SWIGTYPE_p_Pythia8__ResonanceNuRight swig_types[204]
3669 #define SWIGTYPE_p_Pythia8__ResonanceRhorizontal swig_types[205]
3670 #define SWIGTYPE_p_Pythia8__ResonanceS swig_types[206]
3671 #define SWIGTYPE_p_Pythia8__ResonanceSlepton swig_types[207]
3672 #define SWIGTYPE_p_Pythia8__ResonanceSquark swig_types[208]
3673 #define SWIGTYPE_p_Pythia8__ResonanceTop swig_types[209]
3674 #define SWIGTYPE_p_Pythia8__ResonanceW swig_types[210]
3675 #define SWIGTYPE_p_Pythia8__ResonanceWRight swig_types[211]
3676 #define SWIGTYPE_p_Pythia8__ResonanceWidths swig_types[212]
3677 #define SWIGTYPE_p_Pythia8__ResonanceWprime swig_types[213]
3678 #define SWIGTYPE_p_Pythia8__ResonanceZRight swig_types[214]
3679 #define SWIGTYPE_p_Pythia8__ResonanceZp swig_types[215]
3680 #define SWIGTYPE_p_Pythia8__ResonanceZprime swig_types[216]
3681 #define SWIGTYPE_p_Pythia8__Rndm swig_types[217]
3682 #define SWIGTYPE_p_Pythia8__RndmEngine swig_types[218]
3683 #define SWIGTYPE_p_Pythia8__RopeDipole swig_types[219]
3684 #define SWIGTYPE_p_Pythia8__RopeDipoleEnd swig_types[220]
3685 #define SWIGTYPE_p_Pythia8__RopeFragPars swig_types[221]
3686 #define SWIGTYPE_p_Pythia8__Ropewalk swig_types[222]
3687 #define SWIGTYPE_p_Pythia8__RotBstMatrix swig_types[223]
3688 #define SWIGTYPE_p_Pythia8__SLHAinterface swig_types[224]
3689 #define SWIGTYPE_p_Pythia8__SUSYResonanceWidths swig_types[225]
3690 #define SWIGTYPE_p_Pythia8__Settings swig_types[226]
3691 #define SWIGTYPE_p_Pythia8__SetupContainers swig_types[227]
3692 #define SWIGTYPE_p_Pythia8__Sigma0AB2AB swig_types[228]
3693 #define SWIGTYPE_p_Pythia8__Sigma0AB2AX swig_types[229]
3694 #define SWIGTYPE_p_Pythia8__Sigma0AB2AXB swig_types[230]
3695 #define SWIGTYPE_p_Pythia8__Sigma0AB2XB swig_types[231]
3696 #define SWIGTYPE_p_Pythia8__Sigma0AB2XX swig_types[232]
3697 #define SWIGTYPE_p_Pythia8__Sigma0Process swig_types[233]
3698 #define SWIGTYPE_p_Pythia8__Sigma0nonDiffractive swig_types[234]
3699 #define SWIGTYPE_p_Pythia8__Sigma1Process swig_types[235]
3700 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar swig_types[236]
3701 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2H swig_types[237]
3702 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg swig_types[238]
3703 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal swig_types[239]
3704 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2W swig_types[240]
3705 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight swig_types[241]
3706 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime swig_types[242]
3707 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight swig_types[243]
3708 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX swig_types[244]
3709 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv swig_types[245]
3710 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ swig_types[246]
3711 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime swig_types[247]
3712 #define SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime swig_types[248]
3713 #define SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar swig_types[249]
3714 #define SWIGTYPE_p_Pythia8__Sigma1gg2H swig_types[250]
3715 #define SWIGTYPE_p_Pythia8__Sigma1gg2S2XX swig_types[251]
3716 #define SWIGTYPE_p_Pythia8__Sigma1gmgm2H swig_types[252]
3717 #define SWIGTYPE_p_Pythia8__Sigma1lgm2lStar swig_types[253]
3718 #define SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg swig_types[254]
3719 #define SWIGTYPE_p_Pythia8__Sigma1qg2qStar swig_types[255]
3720 #define SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark swig_types[256]
3721 #define SWIGTYPE_p_Pythia8__Sigma1qq2antisquark swig_types[257]
3722 #define SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar swig_types[258]
3723 #define SWIGTYPE_p_Pythia8__Sigma2Process swig_types[259]
3724 #define SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar swig_types[260]
3725 #define SWIGTYPE_p_Pythia8__Sigma2QCqq2qq swig_types[261]
3726 #define SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar swig_types[262]
3727 #define SWIGTYPE_p_Pythia8__Sigma2SUSY swig_types[263]
3728 #define SWIGTYPE_p_Pythia8__Sigma2ff2fftW swig_types[264]
3729 #define SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ swig_types[265]
3730 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12 swig_types[266]
3731 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ swig_types[267]
3732 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW swig_types[268]
3733 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HW swig_types[269]
3734 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ swig_types[270]
3735 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12 swig_types[271]
3736 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg swig_types[272]
3737 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg swig_types[273]
3738 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ swig_types[274]
3739 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma swig_types[275]
3740 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma swig_types[276]
3741 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar swig_types[277]
3742 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar swig_types[278]
3743 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2WW swig_types[279]
3744 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm swig_types[280]
3745 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW swig_types[281]
3746 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH swig_types[282]
3747 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar swig_types[283]
3748 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW swig_types[284]
3749 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm swig_types[285]
3750 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ swig_types[286]
3751 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma swig_types[287]
3752 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm swig_types[288]
3753 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ swig_types[289]
3754 #define SWIGTYPE_p_Pythia8__Sigma2ffbarWggm swig_types[290]
3755 #define SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW swig_types[291]
3756 #define SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm swig_types[292]
3757 #define SWIGTYPE_p_Pythia8__Sigma2fgm2Wf swig_types[293]
3758 #define SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf swig_types[294]
3759 #define SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg swig_types[295]
3760 #define SWIGTYPE_p_Pythia8__Sigma2gg2Hglt swig_types[296]
3761 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg swig_types[297]
3762 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma swig_types[298]
3763 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg swig_types[299]
3764 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar swig_types[300]
3765 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar swig_types[301]
3766 #define SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar swig_types[302]
3767 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar swig_types[303]
3768 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g swig_types[304]
3769 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g swig_types[305]
3770 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11 swig_types[306]
3771 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g swig_types[307]
3772 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm swig_types[308]
3773 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g swig_types[309]
3774 #define SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj swig_types[310]
3775 #define SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma swig_types[311]
3776 #define SWIGTYPE_p_Pythia8__Sigma2gg2gg swig_types[312]
3777 #define SWIGTYPE_p_Pythia8__Sigma2gg2ggamma swig_types[313]
3778 #define SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino swig_types[314]
3779 #define SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar swig_types[315]
3780 #define SWIGTYPE_p_Pythia8__Sigma2gg2qqbar swig_types[316]
3781 #define SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark swig_types[317]
3782 #define SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar swig_types[318]
3783 #define SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar swig_types[319]
3784 #define SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl swig_types[320]
3785 #define SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq swig_types[321]
3786 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq swig_types[322]
3787 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hq swig_types[323]
3788 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt swig_types[324]
3789 #define SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq swig_types[325]
3790 #define SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg swig_types[326]
3791 #define SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl swig_types[327]
3792 #define SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q swig_types[328]
3793 #define SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q swig_types[329]
3794 #define SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj swig_types[330]
3795 #define SWIGTYPE_p_Pythia8__Sigma2qg2Wq swig_types[331]
3796 #define SWIGTYPE_p_Pythia8__Sigma2qg2Zpq2XXj swig_types[332]
3797 #define SWIGTYPE_p_Pythia8__Sigma2qg2charsquark swig_types[333]
3798 #define SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark swig_types[334]
3799 #define SWIGTYPE_p_Pythia8__Sigma2qg2gmZq swig_types[335]
3800 #define SWIGTYPE_p_Pythia8__Sigma2qg2qg swig_types[336]
3801 #define SWIGTYPE_p_Pythia8__Sigma2qg2qgamma swig_types[337]
3802 #define SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino swig_types[338]
3803 #define SWIGTYPE_p_Pythia8__Sigma2qgm2qg swig_types[339]
3804 #define SWIGTYPE_p_Pythia8__Sigma2qgm2qgm swig_types[340]
3805 #define SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq swig_types[341]
3806 #define SWIGTYPE_p_Pythia8__Sigma2qq2QqtW swig_types[342]
3807 #define SWIGTYPE_p_Pythia8__Sigma2qq2qStarq swig_types[343]
3808 #define SWIGTYPE_p_Pythia8__Sigma2qq2qq swig_types[344]
3809 #define SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark swig_types[345]
3810 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg swig_types[346]
3811 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt swig_types[347]
3812 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg swig_types[348]
3813 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg swig_types[349]
3814 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew swig_types[350]
3815 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar swig_types[351]
3816 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar swig_types[352]
3817 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g swig_types[353]
3818 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11 swig_types[354]
3819 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g swig_types[355]
3820 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg swig_types[356]
3821 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj swig_types[357]
3822 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar swig_types[358]
3823 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0 swig_types[359]
3824 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino swig_types[360]
3825 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0 swig_types[361]
3826 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino swig_types[362]
3827 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gg swig_types[363]
3828 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma swig_types[364]
3829 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino swig_types[365]
3830 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg swig_types[366]
3831 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar swig_types[367]
3832 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar swig_types[368]
3833 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar swig_types[369]
3834 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew swig_types[370]
3835 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton swig_types[371]
3836 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark swig_types[372]
3837 #define SWIGTYPE_p_Pythia8__Sigma3Process swig_types[373]
3838 #define SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW swig_types[374]
3839 #define SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW swig_types[375]
3840 #define SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ swig_types[376]
3841 #define SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar swig_types[377]
3842 #define SWIGTYPE_p_Pythia8__Sigma3gg2ggg swig_types[378]
3843 #define SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg swig_types[379]
3844 #define SWIGTYPE_p_Pythia8__Sigma3qg2qgg swig_types[380]
3845 #define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff swig_types[381]
3846 #define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame swig_types[382]
3847 #define SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff swig_types[383]
3848 #define SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame swig_types[384]
3849 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar swig_types[385]
3850 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg swig_types[386]
3851 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff swig_types[387]
3852 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame swig_types[388]
3853 #define SWIGTYPE_p_Pythia8__SigmaABMST swig_types[389]
3854 #define SWIGTYPE_p_Pythia8__SigmaLHAProcess swig_types[390]
3855 #define SWIGTYPE_p_Pythia8__SigmaMBR swig_types[391]
3856 #define SWIGTYPE_p_Pythia8__SigmaMultiparton swig_types[392]
3857 #define SWIGTYPE_p_Pythia8__SigmaOniaSetup swig_types[393]
3858 #define SWIGTYPE_p_Pythia8__SigmaPartialWave swig_types[394]
3859 #define SWIGTYPE_p_Pythia8__SigmaProcess swig_types[395]
3860 #define SWIGTYPE_p_Pythia8__SigmaRPP swig_types[396]
3861 #define SWIGTYPE_p_Pythia8__SigmaSaSDL swig_types[397]
3862 #define SWIGTYPE_p_Pythia8__SigmaTotAux swig_types[398]
3863 #define SWIGTYPE_p_Pythia8__SigmaTotOwn swig_types[399]
3864 #define SWIGTYPE_p_Pythia8__SigmaTotal swig_types[400]
3865 #define SWIGTYPE_p_Pythia8__SingleCell swig_types[401]
3866 #define SWIGTYPE_p_Pythia8__SingleCellJet swig_types[402]
3867 #define SWIGTYPE_p_Pythia8__SingleClusterJet swig_types[403]
3868 #define SWIGTYPE_p_Pythia8__SingleSlowJet swig_types[404]
3869 #define SWIGTYPE_p_Pythia8__SlowJet swig_types[405]
3870 #define SWIGTYPE_p_Pythia8__SlowJetHook swig_types[406]
3871 #define SWIGTYPE_p_Pythia8__SpaceDipoleEnd swig_types[407]
3872 #define SWIGTYPE_p_Pythia8__SpaceShower swig_types[408]
3873 #define SWIGTYPE_p_Pythia8__Sphericity swig_types[409]
3874 #define SWIGTYPE_p_Pythia8__StauWidths swig_types[410]
3875 #define SWIGTYPE_p_Pythia8__StringEnd swig_types[411]
3876 #define SWIGTYPE_p_Pythia8__StringFlav swig_types[412]
3877 #define SWIGTYPE_p_Pythia8__StringFragmentation swig_types[413]
3878 #define SWIGTYPE_p_Pythia8__StringLength swig_types[414]
3879 #define SWIGTYPE_p_Pythia8__StringPT swig_types[415]
3880 #define SWIGTYPE_p_Pythia8__StringRegion swig_types[416]
3881 #define SWIGTYPE_p_Pythia8__StringSystem swig_types[417]
3882 #define SWIGTYPE_p_Pythia8__StringVertex swig_types[418]
3883 #define SWIGTYPE_p_Pythia8__StringZ swig_types[419]
3884 #define SWIGTYPE_p_Pythia8__SubCollision swig_types[420]
3885 #define SWIGTYPE_p_Pythia8__SubCollisionModel swig_types[421]
3886 #define SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst swig_types[422]
3887 #define SWIGTYPE_p_Pythia8__SuppressSmallPT swig_types[423]
3888 #define SWIGTYPE_p_Pythia8__SusyLesHouches swig_types[424]
3889 #define SWIGTYPE_p_Pythia8__TauDecays swig_types[425]
3890 #define SWIGTYPE_p_Pythia8__Thrust swig_types[426]
3891 #define SWIGTYPE_p_Pythia8__TimeDipoleEnd swig_types[427]
3892 #define SWIGTYPE_p_Pythia8__TimeShower swig_types[428]
3893 #define SWIGTYPE_p_Pythia8__TopReconUserHooks swig_types[429]
3894 #define SWIGTYPE_p_Pythia8__TrialReconnection swig_types[430]
3895 #define SWIGTYPE_p_Pythia8__UserHooks swig_types[431]
3896 #define SWIGTYPE_p_Pythia8__UserHooksVector swig_types[432]
3897 #define SWIGTYPE_p_Pythia8__Vec4 swig_types[433]
3898 #define SWIGTYPE_p_Pythia8__WVec swig_types[434]
3899 #define SWIGTYPE_p_Pythia8__Wave4 swig_types[435]
3900 #define SWIGTYPE_p_Pythia8__WeakShowerMEs swig_types[436]
3901 #define SWIGTYPE_p_Pythia8__WidthFunction swig_types[437]
3902 #define SWIGTYPE_p_Pythia8__WoodsSaxonModel swig_types[438]
3903 #define SWIGTYPE_p_Pythia8__Word swig_types[439]
3904 #define SWIGTYPE_p_Pythia8__Writer swig_types[440]
3905 #define SWIGTYPE_p_Pythia8__XMLTag swig_types[441]
3906 #define SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface swig_types[442]
3907 #define SWIGTYPE_p_Pythia8__nPDF swig_types[443]
3908 #define SWIGTYPE_p_State swig_types[444]
3909 #define SWIGTYPE_p_a_3__std__complexT_double_t swig_types[445]
3910 #define SWIGTYPE_p_a_4__std__complexT_double_t swig_types[446]
3911 #define SWIGTYPE_p_a_6__std__complexT_double_t swig_types[447]
3912 #define SWIGTYPE_p_a_7__std__complexT_double_t swig_types[448]
3913 #define SWIGTYPE_p_a_8__double swig_types[449]
3914 #define SWIGTYPE_p_allocator_type swig_types[450]
3915 #define SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[451]
3916 #define SWIGTYPE_p_bool swig_types[452]
3917 #define SWIGTYPE_p_char swig_types[453]
3918 #define SWIGTYPE_p_char_type swig_types[454]
3919 #define SWIGTYPE_p_const_reference swig_types[455]
3920 #define SWIGTYPE_p_difference_type swig_types[456]
3921 #define SWIGTYPE_p_double swig_types[457]
3922 #define SWIGTYPE_p_f_enum_std__ios_base__event_r_std__ios_base_int__void swig_types[458]
3923 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[459]
3924 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[460]
3925 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[461]
3926 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[462]
3927 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[463]
3928 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[464]
3929 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[465]
3930 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[466]
3931 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[467]
3932 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[468]
3933 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[469]
3934 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[470]
3935 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[471]
3936 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[472]
3937 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[473]
3938 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[474]
3939 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[475]
3940 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[476]
3941 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[477]
3942 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[478]
3943 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[479]
3944 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[480]
3945 #define SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base swig_types[481]
3946 #define SWIGTYPE_p_first_type swig_types[482]
3947 #define SWIGTYPE_p_float swig_types[483]
3948 #define SWIGTYPE_p_fmtflags swig_types[484]
3949 #define SWIGTYPE_p_ifstream swig_types[485]
3950 #define SWIGTYPE_p_int swig_types[486]
3951 #define SWIGTYPE_p_int_type swig_types[487]
3952 #define SWIGTYPE_p_iostate swig_types[488]
3953 #define SWIGTYPE_p_key_type swig_types[489]
3954 #define SWIGTYPE_p_long swig_types[490]
3955 #define SWIGTYPE_p_long_double swig_types[491]
3956 #define SWIGTYPE_p_long_long swig_types[492]
3957 #define SWIGTYPE_p_mapped_type swig_types[493]
3958 #define SWIGTYPE_p_off_type swig_types[494]
3959 #define SWIGTYPE_p_openmode swig_types[495]
3960 #define SWIGTYPE_p_p_PyObject swig_types[496]
3961 #define SWIGTYPE_p_p_Pythia8__ColourDipole swig_types[497]
3962 #define SWIGTYPE_p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[498]
3963 #define SWIGTYPE_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[499]
3964 #define SWIGTYPE_p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[500]
3965 #define SWIGTYPE_p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[501]
3966 #define SWIGTYPE_p_p_void swig_types[502]
3967 #define SWIGTYPE_p_pos_t swig_types[503]
3968 #define SWIGTYPE_p_pos_type swig_types[504]
3969 #define SWIGTYPE_p_reference swig_types[505]
3970 #define SWIGTYPE_p_second_type swig_types[506]
3971 #define SWIGTYPE_p_seekdir swig_types[507]
3972 #define SWIGTYPE_p_short swig_types[508]
3973 #define SWIGTYPE_p_size_t swig_types[509]
3974 #define SWIGTYPE_p_size_type swig_types[510]
3975 #define SWIGTYPE_p_state_type swig_types[511]
3976 #define SWIGTYPE_p_std__allocatorT_Pythia8__Clustering_t swig_types[512]
3977 #define SWIGTYPE_p_std__allocatorT_Pythia8__HelicityParticle_t swig_types[513]
3978 #define SWIGTYPE_p_std__allocatorT_Pythia8__ProcessContainer_p_t swig_types[514]
3979 #define SWIGTYPE_p_std__allocatorT_Pythia8__ResonanceWidths_p_t swig_types[515]
3980 #define SWIGTYPE_p_std__allocatorT_Pythia8__SigmaProcess_p_t swig_types[516]
3981 #define SWIGTYPE_p_std__allocatorT_Pythia8__Vec4_t swig_types[517]
3982 #define SWIGTYPE_p_std__allocatorT_bool_t swig_types[518]
3983 #define SWIGTYPE_p_std__allocatorT_double_t swig_types[519]
3984 #define SWIGTYPE_p_std__allocatorT_int_t swig_types[520]
3985 #define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[521]
3986 #define SWIGTYPE_p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t swig_types[522]
3987 #define SWIGTYPE_p_std__allocatorT_std__pairT_int_const_int_t_t swig_types[523]
3988 #define SWIGTYPE_p_std__allocatorT_std__pairT_int_int_t_t swig_types[524]
3989 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t swig_types[525]
3990 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t swig_types[526]
3991 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t swig_types[527]
3992 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t swig_types[528]
3993 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t swig_types[529]
3994 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t swig_types[530]
3995 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t swig_types[531]
3996 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t swig_types[532]
3997 #define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[533]
3998 #define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[534]
3999 #define SWIGTYPE_p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t swig_types[535]
4000 #define SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[536]
4001 #define SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[537]
4002 #define SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[538]
4003 #define SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[539]
4004 #define SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[540]
4005 #define SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[541]
4006 #define SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t swig_types[542]
4007 #define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[543]
4008 #define SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[544]
4009 #define SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[545]
4010 #define SWIGTYPE_p_std__complexT_double_t swig_types[546]
4011 #define SWIGTYPE_p_std__ifstream swig_types[547]
4012 #define SWIGTYPE_p_std__invalid_argument swig_types[548]
4013 #define SWIGTYPE_p_std__ios_base swig_types[549]
4014 #define SWIGTYPE_p_std__lessT_double_t swig_types[550]
4015 #define SWIGTYPE_p_std__lessT_int_t swig_types[551]
4016 #define SWIGTYPE_p_std__lessT_std__string_t swig_types[552]
4017 #define SWIGTYPE_p_std__locale swig_types[553]
4018 #define SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t swig_types[554]
4019 #define SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t swig_types[555]
4020 #define SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t swig_types[556]
4021 #define SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t swig_types[557]
4022 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t swig_types[558]
4023 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t swig_types[559]
4024 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t swig_types[560]
4025 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t swig_types[561]
4026 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t swig_types[562]
4027 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t swig_types[563]
4028 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t swig_types[564]
4029 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t swig_types[565]
4030 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t swig_types[566]
4031 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t swig_types[567]
4032 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t swig_types[568]
4033 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t swig_types[569]
4034 #define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[570]
4035 #define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t swig_types[571]
4036 #define SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t swig_types[572]
4037 #define SWIGTYPE_p_std__ofstream swig_types[573]
4038 #define SWIGTYPE_p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t swig_types[574]
4039 #define SWIGTYPE_p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t swig_types[575]
4040 #define SWIGTYPE_p_std__pairT_double_double_t swig_types[576]
4041 #define SWIGTYPE_p_std__pairT_int_int_t swig_types[577]
4042 #define SWIGTYPE_p_std__pairT_long_long_t swig_types[578]
4043 #define SWIGTYPE_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t swig_types[579]
4044 #define SWIGTYPE_p_std__string swig_types[580]
4045 #define SWIGTYPE_p_std__string__size_type swig_types[581]
4046 #define SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t swig_types[582]
4047 #define SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t swig_types[583]
4048 #define SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t swig_types[584]
4049 #define SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t swig_types[585]
4050 #define SWIGTYPE_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t swig_types[586]
4051 #define SWIGTYPE_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t swig_types[587]
4052 #define SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t swig_types[588]
4053 #define SWIGTYPE_p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t swig_types[589]
4054 #define SWIGTYPE_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t swig_types[590]
4055 #define SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t swig_types[591]
4056 #define SWIGTYPE_p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t swig_types[592]
4057 #define SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t swig_types[593]
4058 #define SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t swig_types[594]
4059 #define SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t swig_types[595]
4060 #define SWIGTYPE_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t swig_types[596]
4061 #define SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t swig_types[597]
4062 #define SWIGTYPE_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t swig_types[598]
4063 #define SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t swig_types[599]
4064 #define SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t swig_types[600]
4065 #define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[601]
4066 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[602]
4067 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[603]
4068 #define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[604]
4069 #define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[605]
4070 #define SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t swig_types[606]
4071 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[607]
4072 #define SWIGTYPE_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t swig_types[608]
4073 #define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[609]
4074 #define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[610]
4075 #define SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t swig_types[611]
4076 #define SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t swig_types[612]
4077 #define SWIGTYPE_p_streamoff swig_types[613]
4078 #define SWIGTYPE_p_streampos swig_types[614]
4079 #define SWIGTYPE_p_stringstream swig_types[615]
4080 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[616]
4081 #define SWIGTYPE_p_traits_type swig_types[617]
4082 #define SWIGTYPE_p_unsigned_int swig_types[618]
4083 #define SWIGTYPE_p_unsigned_long swig_types[619]
4084 #define SWIGTYPE_p_unsigned_long_long swig_types[620]
4085 #define SWIGTYPE_p_unsigned_short swig_types[621]
4086 #define SWIGTYPE_p_value_type swig_types[622]
4087 static swig_type_info *swig_types[624];
4088 static swig_module_info swig_module = {swig_types, 623, 0, 0, 0, 0};
4089 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
4090 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
4091 
4092 /* -------- TYPES TABLE (END) -------- */
4093 
4094 #if (PY_VERSION_HEX <= 0x02000000)
4095 # if !defined(SWIG_PYTHON_CLASSIC)
4096 # error "This python version requires swig to be run with the '-classic' option"
4097 # endif
4098 #endif
4099 
4100 /*-----------------------------------------------
4101  @(target):= _pythia8.so
4102  ------------------------------------------------*/
4103 #if PY_VERSION_HEX >= 0x03000000
4104 # define SWIG_init PyInit__pythia8
4105 
4106 #else
4107 # define SWIG_init init_pythia8
4108 
4109 #endif
4110 #define SWIG_name "_pythia8"
4111 
4112 #define SWIGVERSION 0x030008
4113 #define SWIG_VERSION SWIGVERSION
4114 
4115 
4116 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
4117 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
4118 
4119 
4120 #include <stdexcept>
4121 
4122 
4123 namespace swig {
4125  protected:
4126  PyObject *_obj;
4127 
4128  public:
4129  SwigPtr_PyObject() :_obj(0)
4130  {
4131  }
4132 
4133  SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
4134  {
4135  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4136  Py_XINCREF(_obj);
4137  SWIG_PYTHON_THREAD_END_BLOCK;
4138  }
4139 
4140  SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
4141  {
4142  if (initial_ref) {
4143  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4144  Py_XINCREF(_obj);
4145  SWIG_PYTHON_THREAD_END_BLOCK;
4146  }
4147  }
4148 
4149  SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
4150  {
4151  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4152  Py_XINCREF(item._obj);
4153  Py_XDECREF(_obj);
4154  _obj = item._obj;
4155  SWIG_PYTHON_THREAD_END_BLOCK;
4156  return *this;
4157  }
4158 
4159  ~SwigPtr_PyObject()
4160  {
4161  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4162  Py_XDECREF(_obj);
4163  SWIG_PYTHON_THREAD_END_BLOCK;
4164  }
4165 
4166  operator PyObject *() const
4167  {
4168  return _obj;
4169  }
4170 
4171  PyObject *operator->() const
4172  {
4173  return _obj;
4174  }
4175  };
4176 }
4177 
4178 
4179 namespace swig {
4181  SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
4182 
4183  SwigVar_PyObject & operator = (PyObject* obj)
4184  {
4185  Py_XDECREF(_obj);
4186  _obj = obj;
4187  return *this;
4188  }
4189  };
4190 }
4191 
4192 
4193 #include <cstddef>
4194 
4195 
4196 #include <string>
4197 
4198 
4199 #include <iostream>
4200 
4201 #if PY_VERSION_HEX >= 0x03020000
4202 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
4203 #else
4204 # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
4205 #endif
4206 
4207 
4208 #include <stdexcept>
4209 
4210 
4211 #if defined(__GNUC__)
4212 # if __GNUC__ == 2 && __GNUC_MINOR <= 96
4213 # define SWIG_STD_NOMODERN_STL
4214 # endif
4215 #endif
4216 
4217 
4218 #include <stddef.h>
4219 
4220 
4221 namespace swig {
4223  };
4224 
4226  private:
4227  SwigPtr_PyObject _seq;
4228 
4229  protected:
4230  SwigPyIterator(PyObject *seq) : _seq(seq)
4231  {
4232  }
4233 
4234  public:
4235  virtual ~SwigPyIterator() {}
4236 
4237  // Access iterator method, required by Python
4238  virtual PyObject *value() const = 0;
4239 
4240  // Forward iterator method, required by Python
4241  virtual SwigPyIterator *incr(size_t n = 1) = 0;
4242 
4243  // Backward iterator method, very common in C++, but not required in Python
4244  virtual SwigPyIterator *decr(size_t /*n*/ = 1)
4245  {
4246  throw stop_iteration();
4247  }
4248 
4249  // Random access iterator methods, but not required in Python
4250  virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
4251  {
4252  throw std::invalid_argument("operation not supported");
4253  }
4254 
4255  virtual bool equal (const SwigPyIterator &/*x*/) const
4256  {
4257  throw std::invalid_argument("operation not supported");
4258  }
4259 
4260  // C++ common/needed methods
4261  virtual SwigPyIterator *copy() const = 0;
4262 
4263  PyObject *next()
4264  {
4265  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
4266  PyObject *obj = value();
4267  incr();
4268  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
4269  return obj;
4270  }
4271 
4272  /* Make an alias for Python 3.x */
4273  PyObject *__next__()
4274  {
4275  return next();
4276  }
4277 
4278  PyObject *previous()
4279  {
4280  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
4281  decr();
4282  PyObject *obj = value();
4283  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
4284  return obj;
4285  }
4286 
4287  SwigPyIterator *advance(ptrdiff_t n)
4288  {
4289  return (n > 0) ? incr(n) : decr(-n);
4290  }
4291 
4292  bool operator == (const SwigPyIterator& x) const
4293  {
4294  return equal(x);
4295  }
4296 
4297  bool operator != (const SwigPyIterator& x) const
4298  {
4299  return ! operator==(x);
4300  }
4301 
4302  SwigPyIterator& operator += (ptrdiff_t n)
4303  {
4304  return *advance(n);
4305  }
4306 
4307  SwigPyIterator& operator -= (ptrdiff_t n)
4308  {
4309  return *advance(-n);
4310  }
4311 
4312  SwigPyIterator* operator + (ptrdiff_t n) const
4313  {
4314  return copy()->advance(n);
4315  }
4316 
4317  SwigPyIterator* operator - (ptrdiff_t n) const
4318  {
4319  return copy()->advance(-n);
4320  }
4321 
4322  ptrdiff_t operator - (const SwigPyIterator& x) const
4323  {
4324  return x.distance(*this);
4325  }
4326 
4327  static swig_type_info* descriptor() {
4328  static int init = 0;
4329  static swig_type_info* desc = 0;
4330  if (!init) {
4331  desc = SWIG_TypeQuery("swig::SwigPyIterator *");
4332  init = 1;
4333  }
4334  return desc;
4335  }
4336  };
4337 
4338 #if defined(SWIGPYTHON_BUILTIN)
4339  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
4340  {
4341  Py_INCREF(pyself);
4342  return pyself;
4343  }
4344 #endif
4345 }
4346 
4347 
4348 SWIGINTERN int
4349 SWIG_AsVal_double (PyObject *obj, double *val)
4350 {
4351  int res = SWIG_TypeError;
4352  if (PyFloat_Check(obj)) {
4353  if (val) *val = PyFloat_AsDouble(obj);
4354  return SWIG_OK;
4355 #if PY_VERSION_HEX < 0x03000000
4356  } else if (PyInt_Check(obj)) {
4357  if (val) *val = PyInt_AsLong(obj);
4358  return SWIG_OK;
4359 #endif
4360  } else if (PyLong_Check(obj)) {
4361  double v = PyLong_AsDouble(obj);
4362  if (!PyErr_Occurred()) {
4363  if (val) *val = v;
4364  return SWIG_OK;
4365  } else {
4366  PyErr_Clear();
4367  }
4368  }
4369 #ifdef SWIG_PYTHON_CAST_MODE
4370  {
4371  int dispatch = 0;
4372  double d = PyFloat_AsDouble(obj);
4373  if (!PyErr_Occurred()) {
4374  if (val) *val = d;
4375  return SWIG_AddCast(SWIG_OK);
4376  } else {
4377  PyErr_Clear();
4378  }
4379  if (!dispatch) {
4380  long v = PyLong_AsLong(obj);
4381  if (!PyErr_Occurred()) {
4382  if (val) *val = v;
4383  return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
4384  } else {
4385  PyErr_Clear();
4386  }
4387  }
4388  }
4389 #endif
4390  return res;
4391 }
4392 
4393 
4394 #include <float.h>
4395 
4396 
4397 #include <math.h>
4398 
4399 
4400 SWIGINTERNINLINE int
4401 SWIG_CanCastAsInteger(double *d, double min, double max) {
4402  double x = *d;
4403  if ((min <= x && x <= max)) {
4404  double fx = floor(x);
4405  double cx = ceil(x);
4406  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
4407  if ((errno == EDOM) || (errno == ERANGE)) {
4408  errno = 0;
4409  } else {
4410  double summ, reps, diff;
4411  if (rd < x) {
4412  diff = x - rd;
4413  } else if (rd > x) {
4414  diff = rd - x;
4415  } else {
4416  return 1;
4417  }
4418  summ = rd + x;
4419  reps = diff/summ;
4420  if (reps < 8*DBL_EPSILON) {
4421  *d = rd;
4422  return 1;
4423  }
4424  }
4425  }
4426  return 0;
4427 }
4428 
4429 
4430 SWIGINTERN int
4431 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
4432 {
4433 #if PY_VERSION_HEX < 0x03000000
4434  if (PyInt_Check(obj)) {
4435  long v = PyInt_AsLong(obj);
4436  if (v >= 0) {
4437  if (val) *val = v;
4438  return SWIG_OK;
4439  } else {
4440  return SWIG_OverflowError;
4441  }
4442  } else
4443 #endif
4444  if (PyLong_Check(obj)) {
4445  unsigned long v = PyLong_AsUnsignedLong(obj);
4446  if (!PyErr_Occurred()) {
4447  if (val) *val = v;
4448  return SWIG_OK;
4449  } else {
4450  PyErr_Clear();
4451  return SWIG_OverflowError;
4452  }
4453  }
4454 #ifdef SWIG_PYTHON_CAST_MODE
4455  {
4456  int dispatch = 0;
4457  unsigned long v = PyLong_AsUnsignedLong(obj);
4458  if (!PyErr_Occurred()) {
4459  if (val) *val = v;
4460  return SWIG_AddCast(SWIG_OK);
4461  } else {
4462  PyErr_Clear();
4463  }
4464  if (!dispatch) {
4465  double d;
4466  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
4467  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
4468  if (val) *val = (unsigned long)(d);
4469  return res;
4470  }
4471  }
4472  }
4473 #endif
4474  return SWIG_TypeError;
4475 }
4476 
4477 
4478 SWIGINTERNINLINE int
4479 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
4480 {
4481  unsigned long v;
4482  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
4483  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
4484  return res;
4485 }
4486 
4487 
4488  #define SWIG_From_long PyLong_FromLong
4489 
4490 
4491 SWIGINTERNINLINE PyObject *
4492 SWIG_From_ptrdiff_t (ptrdiff_t value)
4493 {
4494  return SWIG_From_long (static_cast< long >(value));
4495 }
4496 
4497 
4498 SWIGINTERNINLINE PyObject*
4499  SWIG_From_bool (bool value)
4500 {
4501  return PyBool_FromLong(value ? 1 : 0);
4502 }
4503 
4504 
4505 SWIGINTERN int
4506 SWIG_AsVal_long (PyObject *obj, long* val)
4507 {
4508 #if PY_VERSION_HEX < 0x03000000
4509  if (PyInt_Check(obj)) {
4510  if (val) *val = PyInt_AsLong(obj);
4511  return SWIG_OK;
4512  } else
4513 #endif
4514  if (PyLong_Check(obj)) {
4515  long v = PyLong_AsLong(obj);
4516  if (!PyErr_Occurred()) {
4517  if (val) *val = v;
4518  return SWIG_OK;
4519  } else {
4520  PyErr_Clear();
4521  return SWIG_OverflowError;
4522  }
4523  }
4524 #ifdef SWIG_PYTHON_CAST_MODE
4525  {
4526  int dispatch = 0;
4527  long v = PyInt_AsLong(obj);
4528  if (!PyErr_Occurred()) {
4529  if (val) *val = v;
4530  return SWIG_AddCast(SWIG_OK);
4531  } else {
4532  PyErr_Clear();
4533  }
4534  if (!dispatch) {
4535  double d;
4536  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
4537  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
4538  if (val) *val = (long)(d);
4539  return res;
4540  }
4541  }
4542  }
4543 #endif
4544  return SWIG_TypeError;
4545 }
4546 
4547 
4548 SWIGINTERNINLINE int
4549 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
4550 {
4551  long v;
4552  int res = SWIG_AsVal_long (obj, val ? &v : 0);
4553  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
4554  return res;
4555 }
4556 
4557 
4558 #include <algorithm>
4559 
4560 
4561 #include <vector>
4562 
4563 
4564 #include <utility>
4565 
4566 
4567 #include <map>
4568 
4569 
4570 #include <algorithm>
4571 
4572 
4573 #include <deque>
4574 
4575 
4576 #include <set>
4577 
4578 
4579 #include <list>
4580 
4581 
4582 #ifndef SWIG_STD_NOMODERN_STL
4583 # include <ios>
4584 #else
4585 # include <streambuf.h>
4586 #endif
4587 
4588 
4589 SWIGINTERNINLINE PyObject*
4590  SWIG_From_int (int value)
4591 {
4592  return PyInt_FromLong((long) value);
4593 }
4594 
4595 
4596 #include <limits.h>
4597 #if !defined(SWIG_NO_LLONG_MAX)
4598 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
4599 # define LLONG_MAX __LONG_LONG_MAX__
4600 # define LLONG_MIN (-LLONG_MAX - 1LL)
4601 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
4602 # endif
4603 #endif
4604 
4605 
4606 SWIGINTERN int
4607 SWIG_AsVal_int (PyObject * obj, int *val)
4608 {
4609  long v;
4610  int res = SWIG_AsVal_long (obj, &v);
4611  if (SWIG_IsOK(res)) {
4612  if ((v < INT_MIN || v > INT_MAX)) {
4613  return SWIG_OverflowError;
4614  } else {
4615  if (val) *val = static_cast< int >(v);
4616  }
4617  }
4618  return res;
4619 }
4620 
4621 
4622 SWIGINTERNINLINE PyObject*
4623 SWIG_From_unsigned_SS_long (unsigned long value)
4624 {
4625  return (value > LONG_MAX) ?
4626  PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value));
4627 }
4628 
4629 
4630 SWIGINTERNINLINE PyObject *
4631 SWIG_From_size_t (size_t value)
4632 {
4633  return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
4634 }
4635 
4636 
4637 SWIGINTERN int
4638 SWIG_AsVal_bool (PyObject *obj, bool *val)
4639 {
4640  int r;
4641  if (!PyBool_Check(obj))
4642  return SWIG_ERROR;
4643  r = PyObject_IsTrue(obj);
4644  if (r == -1)
4645  return SWIG_ERROR;
4646  if (val) *val = r ? true : false;
4647  return SWIG_OK;
4648 }
4649 
4650 
4651 SWIGINTERN swig_type_info*
4652 SWIG_pchar_descriptor(void)
4653 {
4654  static int init = 0;
4655  static swig_type_info* info = 0;
4656  if (!init) {
4657  info = SWIG_TypeQuery("_p_char");
4658  init = 1;
4659  }
4660  return info;
4661 }
4662 
4663 
4664 SWIGINTERNINLINE PyObject *
4665 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4666 {
4667  if (carray) {
4668  if (size > INT_MAX) {
4669  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4670  return pchar_descriptor ?
4671  SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4672  } else {
4673 #if PY_VERSION_HEX >= 0x03000000
4674 #if PY_VERSION_HEX >= 0x03010000
4675  return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
4676 #else
4677  return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4678 #endif
4679 #else
4680  return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4681 #endif
4682  }
4683  } else {
4684  return SWIG_Py_Void();
4685  }
4686 }
4687 
4688 
4689 SWIGINTERNINLINE PyObject *
4690 SWIG_From_char (char c)
4691 {
4692  return SWIG_FromCharPtrAndSize(&c,1);
4693 }
4694 
4695 
4696 SWIGINTERN int
4697 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4698 {
4699 #if PY_VERSION_HEX>=0x03000000
4700  if (PyUnicode_Check(obj))
4701 #else
4702  if (PyString_Check(obj))
4703 #endif
4704  {
4705  char *cstr; Py_ssize_t len;
4706 #if PY_VERSION_HEX>=0x03000000
4707  if (!alloc && cptr) {
4708  /* We can't allow converting without allocation, since the internal
4709  representation of string in Python 3 is UCS-2/UCS-4 but we require
4710  a UTF-8 representation.
4711  TODO(bhy) More detailed explanation */
4712  return SWIG_RuntimeError;
4713  }
4714  obj = PyUnicode_AsUTF8String(obj);
4715  PyBytes_AsStringAndSize(obj, &cstr, &len);
4716  if(alloc) *alloc = SWIG_NEWOBJ;
4717 #else
4718  PyString_AsStringAndSize(obj, &cstr, &len);
4719 #endif
4720  if (cptr) {
4721  if (alloc) {
4722  /*
4723  In python the user should not be able to modify the inner
4724  string representation. To warranty that, if you define
4725  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4726  buffer is always returned.
4727 
4728  The default behavior is just to return the pointer value,
4729  so, be careful.
4730  */
4731 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4732  if (*alloc != SWIG_OLDOBJ)
4733 #else
4734  if (*alloc == SWIG_NEWOBJ)
4735 #endif
4736  {
4737  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4738  *alloc = SWIG_NEWOBJ;
4739  } else {
4740  *cptr = cstr;
4741  *alloc = SWIG_OLDOBJ;
4742  }
4743  } else {
4744  #if PY_VERSION_HEX>=0x03000000
4745  assert(0); /* Should never reach here in Python 3 */
4746  #endif
4747  *cptr = SWIG_Python_str_AsChar(obj);
4748  }
4749  }
4750  if (psize) *psize = len + 1;
4751 #if PY_VERSION_HEX>=0x03000000
4752  Py_XDECREF(obj);
4753 #endif
4754  return SWIG_OK;
4755  } else {
4756 #if defined(SWIG_PYTHON_2_UNICODE)
4757 #if PY_VERSION_HEX<0x03000000
4758  if (PyUnicode_Check(obj)) {
4759  char *cstr; Py_ssize_t len;
4760  if (!alloc && cptr) {
4761  return SWIG_RuntimeError;
4762  }
4763  obj = PyUnicode_AsUTF8String(obj);
4764  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
4765  if (cptr) {
4766  if (alloc) *alloc = SWIG_NEWOBJ;
4767  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4768  }
4769  if (psize) *psize = len + 1;
4770 
4771  Py_XDECREF(obj);
4772  return SWIG_OK;
4773  } else {
4774  Py_XDECREF(obj);
4775  }
4776  }
4777 #endif
4778 #endif
4779 
4780  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4781  if (pchar_descriptor) {
4782  void* vptr = 0;
4783  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4784  if (cptr) *cptr = (char *) vptr;
4785  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4786  if (alloc) *alloc = SWIG_OLDOBJ;
4787  return SWIG_OK;
4788  }
4789  }
4790  }
4791  return SWIG_TypeError;
4792 }
4793 
4794 
4795 SWIGINTERN int
4796 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
4797 {
4798  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
4799  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
4800  if (SWIG_IsOK(res)) {
4801  /* special case of single char conversion when we don't need space for NUL */
4802  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
4803  if (csize <= size) {
4804  if (val) {
4805  if (csize) memcpy(val, cptr, csize*sizeof(char));
4806  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
4807  }
4808  if (alloc == SWIG_NEWOBJ) {
4809  delete[] cptr;
4810  res = SWIG_DelNewMask(res);
4811  }
4812  return res;
4813  }
4814  if (alloc == SWIG_NEWOBJ) delete[] cptr;
4815  }
4816  return SWIG_TypeError;
4817 }
4818 
4819 
4820 SWIGINTERN int
4821 SWIG_AsVal_char (PyObject * obj, char *val)
4822 {
4823  int res = SWIG_AsCharArray(obj, val, 1);
4824  if (!SWIG_IsOK(res)) {
4825  long v;
4826  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
4827  if (SWIG_IsOK(res)) {
4828  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
4829  if (val) *val = static_cast< char >(v);
4830  } else {
4831  res = SWIG_OverflowError;
4832  }
4833  }
4834  }
4835  return res;
4836 }
4837 
4838 
4839 #include <iostream>
4840 
4841 
4842 SWIGINTERN int
4843 SWIG_AsVal_short (PyObject * obj, short *val)
4844 {
4845  long v;
4846  int res = SWIG_AsVal_long (obj, &v);
4847  if (SWIG_IsOK(res)) {
4848  if ((v < SHRT_MIN || v > SHRT_MAX)) {
4849  return SWIG_OverflowError;
4850  } else {
4851  if (val) *val = static_cast< short >(v);
4852  }
4853  }
4854  return res;
4855 }
4856 
4857 
4858 SWIGINTERN int
4859 SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
4860 {
4861  unsigned long v;
4862  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
4863  if (SWIG_IsOK(res)) {
4864  if ((v > USHRT_MAX)) {
4865  return SWIG_OverflowError;
4866  } else {
4867  if (val) *val = static_cast< unsigned short >(v);
4868  }
4869  }
4870  return res;
4871 }
4872 
4873 
4874 SWIGINTERN int
4875 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
4876 {
4877  unsigned long v;
4878  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
4879  if (SWIG_IsOK(res)) {
4880  if ((v > UINT_MAX)) {
4881  return SWIG_OverflowError;
4882  } else {
4883  if (val) *val = static_cast< unsigned int >(v);
4884  }
4885  }
4886  return res;
4887 }
4888 
4889 
4890 SWIGINTERN int
4891 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
4892 {
4893  int res = SWIG_TypeError;
4894  if (PyLong_Check(obj)) {
4895  long long v = PyLong_AsLongLong(obj);
4896  if (!PyErr_Occurred()) {
4897  if (val) *val = v;
4898  return SWIG_OK;
4899  } else {
4900  PyErr_Clear();
4901  res = SWIG_OverflowError;
4902  }
4903  } else {
4904  long v;
4905  res = SWIG_AsVal_long (obj,&v);
4906  if (SWIG_IsOK(res)) {
4907  if (val) *val = v;
4908  return res;
4909  }
4910  }
4911 #ifdef SWIG_PYTHON_CAST_MODE
4912  {
4913  const double mant_max = 1LL << DBL_MANT_DIG;
4914  const double mant_min = -mant_max;
4915  double d;
4916  res = SWIG_AsVal_double (obj,&d);
4917  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
4918  if (val) *val = (long long)(d);
4919  return SWIG_AddCast(res);
4920  }
4921  res = SWIG_TypeError;
4922  }
4923 #endif
4924  return res;
4925 }
4926 
4927 
4928 SWIGINTERN int
4929 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
4930 {
4931  int res = SWIG_TypeError;
4932  if (PyLong_Check(obj)) {
4933  unsigned long long v = PyLong_AsUnsignedLongLong(obj);
4934  if (!PyErr_Occurred()) {
4935  if (val) *val = v;
4936  return SWIG_OK;
4937  } else {
4938  PyErr_Clear();
4939  res = SWIG_OverflowError;
4940  }
4941  } else {
4942  unsigned long v;
4943  res = SWIG_AsVal_unsigned_SS_long (obj,&v);
4944  if (SWIG_IsOK(res)) {
4945  if (val) *val = v;
4946  return res;
4947  }
4948  }
4949 #ifdef SWIG_PYTHON_CAST_MODE
4950  {
4951  const double mant_max = 1LL << DBL_MANT_DIG;
4952  double d;
4953  res = SWIG_AsVal_double (obj,&d);
4954  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
4955  if (val) *val = (unsigned long long)(d);
4956  return SWIG_AddCast(res);
4957  }
4958  res = SWIG_TypeError;
4959  }
4960 #endif
4961  return res;
4962 }
4963 
4964 
4965 /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
4966 #ifndef SWIG_isfinite
4967 # if defined(isfinite)
4968 # define SWIG_isfinite(X) (isfinite(X))
4969 # elif defined(_MSC_VER)
4970 # define SWIG_isfinite(X) (_finite(X))
4971 # elif defined(__sun) && defined(__SVR4)
4972 # include <ieeefp.h>
4973 # define SWIG_isfinite(X) (finite(X))
4974 # endif
4975 #endif
4976 
4977 
4978 /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
4979 #ifdef SWIG_isfinite
4980 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
4981 #else
4982 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
4983 #endif
4984 
4985 
4986 SWIGINTERN int
4987 SWIG_AsVal_float (PyObject * obj, float *val)
4988 {
4989  double v;
4990  int res = SWIG_AsVal_double (obj, &v);
4991  if (SWIG_IsOK(res)) {
4992  if (SWIG_Float_Overflow_Check(v)) {
4993  return SWIG_OverflowError;
4994  } else {
4995  if (val) *val = static_cast< float >(v);
4996  }
4997  }
4998  return res;
4999 }
5000 
5001 SWIGINTERN std::basic_ostream< char,std::char_traits< char > > &std_basic_ostream_Sl_char_Sg__operator_Sl__Sl___SWIG_17(std::basic_ostream< char > *self,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &s){
5002  *self << s;
5003  return *self;
5004  }
5005 
5006 
5007 
5008 
5009 #ifndef SWIG_STD_NOMODERN_STL
5010 #include <streambuf>
5011 #else
5012 #include <streambuf.h>
5013 #endif
5014 
5015 
5016 #include <sstream>
5017 
5018 
5019 #include <complex>
5020 
5021 
5022 namespace swig {
5023  template <class Type>
5025  typedef Type noconst_type;
5026  };
5027 
5028  template <class Type>
5029  struct noconst_traits<const Type> {
5030  typedef Type noconst_type;
5031  };
5032 
5033  /*
5034  type categories
5035  */
5036  struct pointer_category { };
5037  struct value_category { };
5038 
5039  /*
5040  General traits that provides type_name and type_info
5041  */
5042  template <class Type> struct traits { };
5043 
5044  template <class Type>
5045  inline const char* type_name() {
5047  }
5048 
5049  template <class Type>
5050  struct traits_info {
5051  static swig_type_info *type_query(std::string name) {
5052  name += " *";
5053  return SWIG_TypeQuery(name.c_str());
5054  }
5055  static swig_type_info *type_info() {
5056  static swig_type_info *info = type_query(type_name<Type>());
5057  return info;
5058  }
5059  };
5060 
5061  template <class Type>
5062  inline swig_type_info *type_info() {
5064  }
5065 
5066  /*
5067  Partial specialization for pointers
5068  */
5069  template <class Type> struct traits <Type *> {
5070  typedef pointer_category category;
5071  static std::string make_ptr_name(const char* name) {
5072  std::string ptrname = name;
5073  ptrname += " *";
5074  return ptrname;
5075  }
5076  static const char* type_name() {
5077  static std::string name = make_ptr_name(swig::type_name<Type>());
5078  return name.c_str();
5079  }
5080  };
5081 
5082  template <class Type, class Category>
5083  struct traits_as { };
5084 
5085  template <class Type, class Category>
5086  struct traits_check { };
5087 
5088 }
5089 
5090 
5091 namespace swig {
5092  /*
5093  Traits that provides the from method
5094  */
5095  template <class Type> struct traits_from_ptr {
5096  static PyObject *from(Type *val, int owner = 0) {
5097  return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
5098  }
5099  };
5100 
5101  template <class Type> struct traits_from {
5102  static PyObject *from(const Type& val) {
5103  return traits_from_ptr<Type>::from(new Type(val), 1);
5104  }
5105  };
5106 
5107  template <class Type> struct traits_from<Type *> {
5108  static PyObject *from(Type* val) {
5109  return traits_from_ptr<Type>::from(val, 0);
5110  }
5111  };
5112 
5113  template <class Type> struct traits_from<const Type *> {
5114  static PyObject *from(const Type* val) {
5115  return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
5116  }
5117  };
5118 
5119 
5120  template <class Type>
5121  inline PyObject *from(const Type& val) {
5122  return traits_from<Type>::from(val);
5123  }
5124 
5125  template <class Type>
5126  inline PyObject *from_ptr(Type* val, int owner) {
5127  return traits_from_ptr<Type>::from(val, owner);
5128  }
5129 
5130  /*
5131  Traits that provides the asval/as/check method
5132  */
5133  template <class Type>
5134  struct traits_asptr {
5135  static int asptr(PyObject *obj, Type **val) {
5136  Type *p;
5137  int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
5138  if (SWIG_IsOK(res)) {
5139  if (val) *val = p;
5140  }
5141  return res;
5142  }
5143  };
5144 
5145  template <class Type>
5146  inline int asptr(PyObject *obj, Type **vptr) {
5147  return traits_asptr<Type>::asptr(obj, vptr);
5148  }
5149 
5150  template <class Type>
5151  struct traits_asval {
5152  static int asval(PyObject *obj, Type *val) {
5153  if (val) {
5154  Type *p = 0;
5155  int res = traits_asptr<Type>::asptr(obj, &p);
5156  if (!SWIG_IsOK(res)) return res;
5157  if (p) {
5158  typedef typename noconst_traits<Type>::noconst_type noconst_type;
5159  *(const_cast<noconst_type*>(val)) = *p;
5160  if (SWIG_IsNewObj(res)){
5161  delete p;
5162  res = SWIG_DelNewMask(res);
5163  }
5164  return res;
5165  } else {
5166  return SWIG_ERROR;
5167  }
5168  } else {
5169  return traits_asptr<Type>::asptr(obj, (Type **)(0));
5170  }
5171  }
5172  };
5173 
5174  template <class Type> struct traits_asval<Type*> {
5175  static int asval(PyObject *obj, Type **val) {
5176  if (val) {
5177  typedef typename noconst_traits<Type>::noconst_type noconst_type;
5178  noconst_type *p = 0;
5179  int res = traits_asptr<noconst_type>::asptr(obj, &p);
5180  if (SWIG_IsOK(res)) {
5181  *(const_cast<noconst_type**>(val)) = p;
5182  }
5183  return res;
5184  } else {
5185  return traits_asptr<Type>::asptr(obj, (Type **)(0));
5186  }
5187  }
5188  };
5189 
5190  template <class Type>
5191  inline int asval(PyObject *obj, Type *val) {
5192  return traits_asval<Type>::asval(obj, val);
5193  }
5194 
5195  template <class Type>
5196  struct traits_as<Type, value_category> {
5197  static Type as(PyObject *obj, bool throw_error) {
5198  Type v;
5199  int res = asval(obj, &v);
5200  if (!obj || !SWIG_IsOK(res)) {
5201  if (!PyErr_Occurred()) {
5202  ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5203  }
5204  if (throw_error) throw std::invalid_argument("bad type");
5205  }
5206  return v;
5207  }
5208  };
5209 
5210  template <class Type>
5211  struct traits_as<Type, pointer_category> {
5212  static Type as(PyObject *obj, bool throw_error) {
5213  Type *v = 0;
5214  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
5215  if (SWIG_IsOK(res) && v) {
5216  if (SWIG_IsNewObj(res)) {
5217  Type r(*v);
5218  delete v;
5219  return r;
5220  } else {
5221  return *v;
5222  }
5223  } else {
5224  // Uninitialized return value, no Type() constructor required.
5225  static Type *v_def = (Type*) malloc(sizeof(Type));
5226  if (!PyErr_Occurred()) {
5227  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5228  }
5229  if (throw_error) throw std::invalid_argument("bad type");
5230  memset(v_def,0,sizeof(Type));
5231  return *v_def;
5232  }
5233  }
5234  };
5235 
5236  template <class Type>
5237  struct traits_as<Type*, pointer_category> {
5238  static Type* as(PyObject *obj, bool throw_error) {
5239  Type *v = 0;
5240  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
5241  if (SWIG_IsOK(res)) {
5242  return v;
5243  } else {
5244  if (!PyErr_Occurred()) {
5245  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5246  }
5247  if (throw_error) throw std::invalid_argument("bad type");
5248  return 0;
5249  }
5250  }
5251  };
5252 
5253  template <class Type>
5254  inline Type as(PyObject *obj, bool te = false) {
5256  }
5257 
5258  template <class Type>
5260  static bool check(PyObject *obj) {
5261  int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
5262  return SWIG_IsOK(res) ? true : false;
5263  }
5264  };
5265 
5266  template <class Type>
5268  static bool check(PyObject *obj) {
5269  int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
5270  return SWIG_IsOK(res) ? true : false;
5271  }
5272  };
5273 
5274  template <class Type>
5275  inline bool check(PyObject *obj) {
5277  }
5278 }
5279 
5280 
5281 namespace swig {
5282  template <> struct traits< int > {
5283  typedef value_category category;
5284  static const char* type_name() { return"int"; }
5285  };
5286  template <> struct traits_asval< int > {
5287  typedef int value_type;
5288  static int asval(PyObject *obj, value_type *val) {
5289  return SWIG_AsVal_int (obj, val);
5290  }
5291  };
5292  template <> struct traits_from< int > {
5293  typedef int value_type;
5294  static PyObject *from(const value_type& val) {
5295  return SWIG_From_int (val);
5296  }
5297  };
5298 }
5299 
5300 
5301  namespace swig {
5302 
5303 
5304 
5305 
5306 
5307 
5308 
5309 
5310 
5311 
5312 
5313 
5314 
5315 
5316 
5317 
5318 
5319 
5320 
5321 
5322 
5323 
5324 
5325 
5326 
5327 
5328 
5329 
5330 
5331 
5332 
5333 
5334 
5335 
5336 
5337 
5338 
5339 
5340 
5341 
5342 
5343 
5344 
5345 
5346 
5347 
5348 
5349 
5350 
5351  template <class T, class U >
5352  struct traits_asptr<std::pair<T,U> > {
5353  typedef std::pair<T,U> value_type;
5354 
5355  static int get_pair(PyObject* first, PyObject* second,
5356  std::pair<T,U> **val)
5357  {
5358  if (val) {
5359  value_type *vp = (new std::pair<T,U>);
5360  T *pfirst = &(vp->first);
5361  int res1 = swig::asval((PyObject*)first, pfirst);
5362  if (!SWIG_IsOK(res1)) return res1;
5363  U *psecond = &(vp->second);
5364  int res2 = swig::asval((PyObject*)second, psecond);
5365  if (!SWIG_IsOK(res2)) return res2;
5366  *val = vp;
5367  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
5368  } else {
5369  T *pfirst = 0;
5370  int res1 = swig::asval((PyObject*)first, pfirst);
5371  if (!SWIG_IsOK(res1)) return res1;
5372  U *psecond = 0;
5373  int res2 = swig::asval((PyObject*)second, psecond);
5374  if (!SWIG_IsOK(res2)) return res2;
5375  return res1 > res2 ? res1 : res2;
5376  }
5377  }
5378 
5379  static int asptr(PyObject *obj, std::pair<T,U> **val) {
5380  int res = SWIG_ERROR;
5381  if (PyTuple_Check(obj)) {
5382  if (PyTuple_GET_SIZE(obj) == 2) {
5383  res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
5384  }
5385  } else if (PySequence_Check(obj)) {
5386  if (PySequence_Size(obj) == 2) {
5387  swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
5388  swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
5389  res = get_pair(first, second, val);
5390  }
5391  } else {
5392  value_type *p;
5393  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
5394  if (SWIG_IsOK(res) && val) *val = p;
5395  }
5396  return res;
5397  }
5398  };
5399 
5400 
5401  template <class T, class U >
5402  struct traits_from<std::pair<T,U> > {
5403  static PyObject *from(const std::pair<T,U>& val) {
5404  PyObject* obj = PyTuple_New(2);
5405  PyTuple_SetItem(obj,0,swig::from(val.first));
5406  PyTuple_SetItem(obj,1,swig::from(val.second));
5407  return obj;
5408  }
5409  };
5410  }
5411 
5412 
5413 
5414 
5415 
5416 
5417 
5418 
5419 
5420 
5421 
5422 
5423 
5424 
5425 
5426 
5427 
5428 
5429 
5430 
5431 
5432 
5433 
5434 
5435 
5436 
5437 
5438 
5439 
5440 
5441 
5442 
5443 
5444 
5445 
5446 
5447 
5448  namespace swig {
5449  template <> struct traits<std::pair< int, int > > {
5450  typedef pointer_category category;
5451  static const char* type_name() {
5452  return "std::pair<" "int" "," "int" " >";
5453  }
5454  };
5455  }
5456 
5457 
5458 #include <functional>
5459 
5460 namespace std {
5461  template <>
5462  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
5463  {
5464  bool
5465  operator()(PyObject * v, PyObject *w) const
5466  {
5467  bool res;
5468  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
5469  res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
5470  /* This may fall into a case of inconsistent
5471  eg. ObjA > ObjX > ObjB
5472  but ObjA < ObjB
5473  */
5474  if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
5475  {
5476  /* Objects can't be compared, this mostly occurred in Python 3.0 */
5477  /* Compare their ptr directly for a workaround */
5478  res = (v < w);
5479  PyErr_Clear();
5480  }
5481  SWIG_PYTHON_THREAD_END_BLOCK;
5482  return res;
5483  }
5484  };
5485 
5486  template <>
5487  struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
5488  {
5489  bool
5490  operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
5491  {
5492  return std::less<PyObject *>()(v, w);
5493  }
5494  };
5495 
5496  template <>
5497  struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
5498  {
5499  bool
5500  operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
5501  {
5502  return std::less<PyObject *>()(v, w);
5503  }
5504  };
5505 
5506 }
5507 
5508 namespace swig {
5509  template <> struct traits<PyObject *> {
5510  typedef value_category category;
5511  static const char* type_name() { return "PyObject *"; }
5512  };
5513 
5514  template <> struct traits_asval<PyObject * > {
5515  typedef PyObject * value_type;
5516  static int asval(PyObject *obj, value_type *val) {
5517  if (val) *val = obj;
5518  return SWIG_OK;
5519  }
5520  };
5521 
5522  template <>
5523  struct traits_check<PyObject *, value_category> {
5524  static bool check(PyObject *) {
5525  return true;
5526  }
5527  };
5528 
5529  template <> struct traits_from<PyObject *> {
5530  typedef PyObject * value_type;
5531  static PyObject *from(const value_type& val) {
5532  Py_XINCREF(val);
5533  return val;
5534  }
5535  };
5536 
5537 }
5538 
5539 namespace swig {
5540  template <class Difference>
5541  inline size_t
5542  check_index(Difference i, size_t size, bool insert = false) {
5543  if ( i < 0 ) {
5544  if ((size_t) (-i) <= size)
5545  return (size_t) (i + size);
5546  } else if ( (size_t) i < size ) {
5547  return (size_t) i;
5548  } else if (insert && ((size_t) i == size)) {
5549  return size;
5550  }
5551  throw std::out_of_range("index out of range");
5552  }
5553 
5554  template <class Difference>
5555  void
5556  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
5557  if (step == 0) {
5558  throw std::invalid_argument("slice step cannot be zero");
5559  } else if (step > 0) {
5560  // Required range: 0 <= i < size, 0 <= j < size
5561  if (i < 0) {
5562  ii = 0;
5563  } else if (i < (Difference)size) {
5564  ii = i;
5565  } else if (insert && (i >= (Difference)size)) {
5566  ii = (Difference)size;
5567  }
5568  if ( j < 0 ) {
5569  jj = 0;
5570  } else {
5571  jj = (j < (Difference)size) ? j : (Difference)size;
5572  }
5573  } else {
5574  // Required range: -1 <= i < size-1, -1 <= j < size-1
5575  if (i < -1) {
5576  ii = -1;
5577  } else if (i < (Difference) size) {
5578  ii = i;
5579  } else if (i >= (Difference)(size-1)) {
5580  ii = (Difference)(size-1);
5581  }
5582  if (j < -1) {
5583  jj = -1;
5584  } else {
5585  jj = (j < (Difference)size ) ? j : (Difference)(size-1);
5586  }
5587  }
5588  }
5589 
5590  template <class Sequence, class Difference>
5591  inline typename Sequence::iterator
5592  getpos(Sequence* self, Difference i) {
5593  typename Sequence::iterator pos = self->begin();
5594  std::advance(pos, check_index(i,self->size()));
5595  return pos;
5596  }
5597 
5598  template <class Sequence, class Difference>
5599  inline typename Sequence::const_iterator
5600  cgetpos(const Sequence* self, Difference i) {
5601  typename Sequence::const_iterator pos = self->begin();
5602  std::advance(pos, check_index(i,self->size()));
5603  return pos;
5604  }
5605 
5606  template <class Sequence>
5607  inline void
5608  erase(Sequence* seq, const typename Sequence::iterator& position) {
5609  seq->erase(position);
5610  }
5611 
5612  template <class Sequence, class Difference>
5613  inline Sequence*
5614  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
5615  typename Sequence::size_type size = self->size();
5616  Difference ii = 0;
5617  Difference jj = 0;
5618  swig::slice_adjust(i, j, step, size, ii, jj);
5619 
5620  if (step > 0) {
5621  typename Sequence::const_iterator sb = self->begin();
5622  typename Sequence::const_iterator se = self->begin();
5623  std::advance(sb,ii);
5624  std::advance(se,jj);
5625  if (step == 1) {
5626  return new Sequence(sb, se);
5627  } else {
5628  Sequence *sequence = new Sequence();
5629  typename Sequence::const_iterator it = sb;
5630  while (it!=se) {
5631  sequence->push_back(*it);
5632  for (Py_ssize_t c=0; c<step && it!=se; ++c)
5633  it++;
5634  }
5635  return sequence;
5636  }
5637  } else {
5638  Sequence *sequence = new Sequence();
5639  if (ii > jj) {
5640  typename Sequence::const_reverse_iterator sb = self->rbegin();
5641  typename Sequence::const_reverse_iterator se = self->rbegin();
5642  std::advance(sb,size-ii-1);
5643  std::advance(se,size-jj-1);
5644  typename Sequence::const_reverse_iterator it = sb;
5645  while (it!=se) {
5646  sequence->push_back(*it);
5647  for (Py_ssize_t c=0; c<-step && it!=se; ++c)
5648  it++;
5649  }
5650  }
5651  return sequence;
5652  }
5653  }
5654 
5655  template <class Sequence, class Difference, class InputSeq>
5656  inline void
5657  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
5658  typename Sequence::size_type size = self->size();
5659  Difference ii = 0;
5660  Difference jj = 0;
5661  swig::slice_adjust(i, j, step, size, ii, jj, true);
5662  if (step > 0) {
5663  if (jj < ii)
5664  jj = ii;
5665  if (step == 1) {
5666  size_t ssize = jj - ii;
5667  if (ssize <= is.size()) {
5668  // expanding/staying the same size
5669  typename Sequence::iterator sb = self->begin();
5670  typename InputSeq::const_iterator isit = is.begin();
5671  std::advance(sb,ii);
5672  std::advance(isit, jj - ii);
5673  self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
5674  } else {
5675  // shrinking
5676  typename Sequence::iterator sb = self->begin();
5677  typename Sequence::iterator se = self->begin();
5678  std::advance(sb,ii);
5679  std::advance(se,jj);
5680  self->erase(sb,se);
5681  sb = self->begin();
5682  std::advance(sb,ii);
5683  self->insert(sb, is.begin(), is.end());
5684  }
5685  } else {
5686  size_t replacecount = (jj - ii + step - 1) / step;
5687  if (is.size() != replacecount) {
5688  char msg[1024];
5689  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
5690  throw std::invalid_argument(msg);
5691  }
5692  typename Sequence::const_iterator isit = is.begin();
5693  typename Sequence::iterator it = self->begin();
5694  std::advance(it,ii);
5695  for (size_t rc=0; rc<replacecount; ++rc) {
5696  *it++ = *isit++;
5697  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
5698  it++;
5699  }
5700  }
5701  } else {
5702  if (jj > ii)
5703  jj = ii;
5704  size_t replacecount = (ii - jj - step - 1) / -step;
5705  if (is.size() != replacecount) {
5706  char msg[1024];
5707  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
5708  throw std::invalid_argument(msg);
5709  }
5710  typename Sequence::const_iterator isit = is.begin();
5711  typename Sequence::reverse_iterator it = self->rbegin();
5712  std::advance(it,size-ii-1);
5713  for (size_t rc=0; rc<replacecount; ++rc) {
5714  *it++ = *isit++;
5715  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
5716  it++;
5717  }
5718  }
5719  }
5720 
5721  template <class Sequence, class Difference>
5722  inline void
5723  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
5724  typename Sequence::size_type size = self->size();
5725  Difference ii = 0;
5726  Difference jj = 0;
5727  swig::slice_adjust(i, j, step, size, ii, jj, true);
5728  if (step > 0) {
5729  if (jj > ii) {
5730  typename Sequence::iterator sb = self->begin();
5731  std::advance(sb,ii);
5732  if (step == 1) {
5733  typename Sequence::iterator se = self->begin();
5734  std::advance(se,jj);
5735  self->erase(sb,se);
5736  } else {
5737  typename Sequence::iterator it = sb;
5738  size_t delcount = (jj - ii + step - 1) / step;
5739  while (delcount) {
5740  it = self->erase(it);
5741  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
5742  it++;
5743  delcount--;
5744  }
5745  }
5746  }
5747  } else {
5748  if (ii > jj) {
5749  typename Sequence::reverse_iterator sb = self->rbegin();
5750  std::advance(sb,size-ii-1);
5751  typename Sequence::reverse_iterator it = sb;
5752  size_t delcount = (ii - jj - step - 1) / -step;
5753  while (delcount) {
5754  it = typename Sequence::reverse_iterator(self->erase((++it).base()));
5755  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
5756  it++;
5757  delcount--;
5758  }
5759  }
5760  }
5761  }
5762 }
5763 
5764 
5765 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
5766 # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
5767 # define SWIG_STD_NOITERATOR_TRAITS_STL
5768 # endif
5769 #endif
5770 
5771 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
5772 #include <iterator>
5773 #else
5774 namespace std {
5775  template <class Iterator>
5776  struct iterator_traits {
5777  typedef ptrdiff_t difference_type;
5778  typedef typename Iterator::value_type value_type;
5779  };
5780 
5781  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
5782  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
5783  typedef Distance difference_type;
5784  typedef T value_type;
5785  };
5786 
5787  template <class T>
5788  struct iterator_traits<T*> {
5789  typedef T value_type;
5790  typedef ptrdiff_t difference_type;
5791  };
5792 
5793  template<typename _InputIterator>
5794  inline typename iterator_traits<_InputIterator>::difference_type
5795  distance(_InputIterator __first, _InputIterator __last)
5796  {
5797  typename iterator_traits<_InputIterator>::difference_type __n = 0;
5798  while (__first != __last) {
5799  ++__first; ++__n;
5800  }
5801  return __n;
5802  }
5803 }
5804 #endif
5805 
5806 
5807 namespace swig {
5808  template<typename OutIterator>
5810  {
5811  public:
5812  typedef OutIterator out_iterator;
5813  typedef typename std::iterator_traits<out_iterator>::value_type value_type;
5815 
5816  SwigPyIterator_T(out_iterator curr, PyObject *seq)
5817  : SwigPyIterator(seq), current(curr)
5818  {
5819  }
5820 
5821  const out_iterator& get_current() const
5822  {
5823  return current;
5824  }
5825 
5826 
5827  bool equal (const SwigPyIterator &iter) const
5828  {
5829  const self_type *iters = dynamic_cast<const self_type *>(&iter);
5830  if (iters) {
5831  return (current == iters->get_current());
5832  } else {
5833  throw std::invalid_argument("bad iterator type");
5834  }
5835  }
5836 
5837  ptrdiff_t distance(const SwigPyIterator &iter) const
5838  {
5839  const self_type *iters = dynamic_cast<const self_type *>(&iter);
5840  if (iters) {
5841  return std::distance(current, iters->get_current());
5842  } else {
5843  throw std::invalid_argument("bad iterator type");
5844  }
5845  }
5846 
5847  protected:
5848  out_iterator current;
5849  };
5850 
5851  template <class ValueType>
5852  struct from_oper
5853  {
5854  typedef const ValueType& argument_type;
5855  typedef PyObject *result_type;
5856  result_type operator()(argument_type v) const
5857  {
5858  return swig::from(v);
5859  }
5860  };
5861 
5862  template<typename OutIterator,
5863  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
5864  typename FromOper = from_oper<ValueType> >
5865  class SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
5866  {
5867  public:
5868  FromOper from;
5869  typedef OutIterator out_iterator;
5870  typedef ValueType value_type;
5873 
5874  SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
5875  : SwigPyIterator_T<OutIterator>(curr, seq)
5876  {
5877  }
5878 
5879  PyObject *value() const {
5880  return from(static_cast<const value_type&>(*(base::current)));
5881  }
5882 
5883  SwigPyIterator *copy() const
5884  {
5885  return new self_type(*this);
5886  }
5887 
5888  SwigPyIterator *incr(size_t n = 1)
5889  {
5890  while (n--) {
5891  ++base::current;
5892  }
5893  return this;
5894  }
5895 
5896  SwigPyIterator *decr(size_t n = 1)
5897  {
5898  while (n--) {
5899  --base::current;
5900  }
5901  return this;
5902  }
5903  };
5904 
5905  template<typename OutIterator,
5906  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
5907  typename FromOper = from_oper<ValueType> >
5908  class SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
5909  {
5910  public:
5911  FromOper from;
5912  typedef OutIterator out_iterator;
5913  typedef ValueType value_type;
5916 
5917  SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
5918  : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
5919  {
5920  }
5921 
5922  PyObject *value() const {
5923  if (base::current == end) {
5924  throw stop_iteration();
5925  } else {
5926  return from(static_cast<const value_type&>(*(base::current)));
5927  }
5928  }
5929 
5930  SwigPyIterator *copy() const
5931  {
5932  return new self_type(*this);
5933  }
5934 
5935  SwigPyIterator *incr(size_t n = 1)
5936  {
5937  while (n--) {
5938  if (base::current == end) {
5939  throw stop_iteration();
5940  } else {
5941  ++base::current;
5942  }
5943  }
5944  return this;
5945  }
5946 
5947  SwigPyIterator *decr(size_t n = 1)
5948  {
5949  while (n--) {
5950  if (base::current == begin) {
5951  throw stop_iteration();
5952  } else {
5953  --base::current;
5954  }
5955  }
5956  return this;
5957  }
5958 
5959  private:
5960  out_iterator begin;
5961  out_iterator end;
5962  };
5963 
5964  template<typename OutIter>
5965  inline SwigPyIterator*
5966  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
5967  {
5968  return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
5969  }
5970 
5971  template<typename OutIter>
5972  inline SwigPyIterator*
5973  make_output_iterator(const OutIter& current, PyObject *seq = 0)
5974  {
5975  return new SwigPyIteratorOpen_T<OutIter>(current, seq);
5976  }
5977 
5978 }
5979 
5980 
5981 namespace swig
5982 {
5983  template <class T>
5985  {
5986  SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
5987  : _seq(seq), _index(index)
5988  {
5989  }
5990 
5991  operator T () const
5992  {
5993  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
5994  try {
5995  return swig::as<T>(item, true);
5996  } catch (std::exception& e) {
5997  char msg[1024];
5998  sprintf(msg, "in sequence element %d ", (int)_index);
5999  if (!PyErr_Occurred()) {
6000  ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
6001  }
6002  SWIG_Python_AddErrorMsg(msg);
6003  SWIG_Python_AddErrorMsg(e.what());
6004  throw;
6005  }
6006  }
6007 
6008  SwigPySequence_Ref& operator=(const T& v)
6009  {
6010  PySequence_SetItem(_seq, _index, swig::from<T>(v));
6011  return *this;
6012  }
6013 
6014  private:
6015  PyObject* _seq;
6016  Py_ssize_t _index;
6017  };
6018 
6019  template <class T>
6021  {
6022  SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
6023  const T* operator->() const { return &m_value; }
6024  operator const T*() const { return &m_value; }
6025  T m_value;
6026  };
6027 
6028  template <class T, class Reference >
6030  {
6032 
6033  typedef std::random_access_iterator_tag iterator_category;
6034  typedef Reference reference;
6035  typedef T value_type;
6036  typedef T* pointer;
6037  typedef Py_ssize_t difference_type;
6038 
6040  {
6041  }
6042 
6043  SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
6044  : _seq(seq), _index(index)
6045  {
6046  }
6047 
6048  reference operator*() const
6049  {
6050  return reference(_seq, _index);
6051  }
6052 
6054  operator->() const {
6055  return SwigPySequence_ArrowProxy<T>(operator*());
6056  }
6057 
6058  bool operator==(const self& ri) const
6059  {
6060  return (_index == ri._index) && (_seq == ri._seq);
6061  }
6062 
6063  bool operator!=(const self& ri) const
6064  {
6065  return !(operator==(ri));
6066  }
6067 
6068  self& operator ++ ()
6069  {
6070  ++_index;
6071  return *this;
6072  }
6073 
6074  self& operator -- ()
6075  {
6076  --_index;
6077  return *this;
6078  }
6079 
6080  self& operator += (difference_type n)
6081  {
6082  _index += n;
6083  return *this;
6084  }
6085 
6086  self operator +(difference_type n) const
6087  {
6088  return self(_seq, _index + n);
6089  }
6090 
6091  self& operator -= (difference_type n)
6092  {
6093  _index -= n;
6094  return *this;
6095  }
6096 
6097  self operator -(difference_type n) const
6098  {
6099  return self(_seq, _index - n);
6100  }
6101 
6102  difference_type operator - (const self& ri) const
6103  {
6104  return _index - ri._index;
6105  }
6106 
6107  bool operator < (const self& ri) const
6108  {
6109  return _index < ri._index;
6110  }
6111 
6112  reference
6113  operator[](difference_type n) const
6114  {
6115  return reference(_seq, _index + n);
6116  }
6117 
6118  private:
6119  PyObject* _seq;
6120  difference_type _index;
6121  };
6122 
6123  // STL container wrapper around a Python sequence
6124  template <class T>
6126  {
6128  typedef const SwigPySequence_Ref<T> const_reference;
6129  typedef T value_type;
6130  typedef T* pointer;
6131  typedef Py_ssize_t difference_type;
6132  typedef size_t size_type;
6133  typedef const pointer const_pointer;
6136 
6137  SwigPySequence_Cont(PyObject* seq) : _seq(0)
6138  {
6139  if (!PySequence_Check(seq)) {
6140  throw std::invalid_argument("a sequence is expected");
6141  }
6142  _seq = seq;
6143  Py_INCREF(_seq);
6144  }
6145 
6147  {
6148  Py_XDECREF(_seq);
6149  }
6150 
6151  size_type size() const
6152  {
6153  return static_cast<size_type>(PySequence_Size(_seq));
6154  }
6155 
6156  bool empty() const
6157  {
6158  return size() == 0;
6159  }
6160 
6161  iterator begin()
6162  {
6163  return iterator(_seq, 0);
6164  }
6165 
6166  const_iterator begin() const
6167  {
6168  return const_iterator(_seq, 0);
6169  }
6170 
6171  iterator end()
6172  {
6173  return iterator(_seq, size());
6174  }
6175 
6176  const_iterator end() const
6177  {
6178  return const_iterator(_seq, size());
6179  }
6180 
6181  reference operator[](difference_type n)
6182  {
6183  return reference(_seq, n);
6184  }
6185 
6186  const_reference operator[](difference_type n) const
6187  {
6188  return const_reference(_seq, n);
6189  }
6190 
6191  bool check(bool set_err = true) const
6192  {
6193  Py_ssize_t s = size();
6194  for (Py_ssize_t i = 0; i < s; ++i) {
6195  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
6196  if (!swig::check<value_type>(item)) {
6197  if (set_err) {
6198  char msg[1024];
6199  sprintf(msg, "in sequence element %d", (int)i);
6200  SWIG_Error(SWIG_RuntimeError, msg);
6201  }
6202  return false;
6203  }
6204  }
6205  return true;
6206  }
6207 
6208  private:
6209  PyObject* _seq;
6210  };
6211 
6212 }
6213 
6214 
6215 namespace swig {
6216  template <class SwigPySeq, class Seq>
6217  inline void
6218  assign(const SwigPySeq& swigpyseq, Seq* seq) {
6219  // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
6220  typedef typename SwigPySeq::value_type value_type;
6221  typename SwigPySeq::const_iterator it = swigpyseq.begin();
6222  for (;it != swigpyseq.end(); ++it) {
6223  seq->insert(seq->end(),(value_type)(*it));
6224  }
6225  }
6226 
6227  template <class Seq, class T = typename Seq::value_type >
6229  typedef Seq sequence;
6230  typedef T value_type;
6231 
6232  static int asptr(PyObject *obj, sequence **seq) {
6233  if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
6234  sequence *p;
6235  if (::SWIG_ConvertPtr(obj,(void**)&p,
6236  swig::type_info<sequence>(),0) == SWIG_OK) {
6237  if (seq) *seq = p;
6238  return SWIG_OLDOBJ;
6239  }
6240  } else if (PySequence_Check(obj)) {
6241  try {
6242  SwigPySequence_Cont<value_type> swigpyseq(obj);
6243  if (seq) {
6244  sequence *pseq = new sequence();
6245  assign(swigpyseq, pseq);
6246  *seq = pseq;
6247  return SWIG_NEWOBJ;
6248  } else {
6249  return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
6250  }
6251  } catch (std::exception& e) {
6252  if (seq) {
6253  if (!PyErr_Occurred()) {
6254  PyErr_SetString(PyExc_TypeError, e.what());
6255  }
6256  }
6257  return SWIG_ERROR;
6258  }
6259  }
6260  return SWIG_ERROR;
6261  }
6262  };
6263 
6264  template <class Seq, class T = typename Seq::value_type >
6266  typedef Seq sequence;
6267  typedef T value_type;
6268  typedef typename Seq::size_type size_type;
6269  typedef typename sequence::const_iterator const_iterator;
6270 
6271  static PyObject *from(const sequence& seq) {
6272 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
6273  swig_type_info *desc = swig::type_info<sequence>();
6274  if (desc && desc->clientdata) {
6275  return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
6276  }
6277 #endif
6278  size_type size = seq.size();
6279  if (size <= (size_type)INT_MAX) {
6280  PyObject *obj = PyTuple_New((Py_ssize_t)size);
6281  Py_ssize_t i = 0;
6282  for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
6283  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
6284  }
6285  return obj;
6286  } else {
6287  PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
6288  return NULL;
6289  }
6290  }
6291  };
6292 }
6293 
6294 
6295  namespace swig {
6296  template <class ValueType>
6298  {
6299  typedef const ValueType& argument_type;
6300  typedef PyObject *result_type;
6301  result_type operator()(argument_type v) const
6302  {
6303  return swig::from(v.first);
6304  }
6305  };
6306 
6307  template <class ValueType>
6309  {
6310  typedef const ValueType& argument_type;
6311  typedef PyObject *result_type;
6312  result_type operator()(argument_type v) const
6313  {
6314  return swig::from(v.second);
6315  }
6316  };
6317 
6318  template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
6319  struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
6320  {
6321  SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6323  {
6324  }
6325  };
6326 
6327 
6328  template<class OutIterator,
6330  struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
6331  {
6332  SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6333  : SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
6334  {
6335  }
6336  };
6337 
6338  template<typename OutIter>
6339  inline SwigPyIterator*
6340  make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
6341  {
6342  return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
6343  }
6344 
6345  template<class OutIterator,
6346  class FromOper = from_value_oper<typename OutIterator::value_type> >
6347  struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
6348  {
6349  SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6350  : SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
6351  {
6352  }
6353  };
6354 
6355 
6356  template<typename OutIter>
6357  inline SwigPyIterator*
6358  make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
6359  {
6360  return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
6361  }
6362  }
6363 
6364 
6365  namespace swig {
6366  template <class SwigPySeq, class K, class T, class Compare, class Alloc >
6367  inline void
6368  assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
6369  typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
6370  typename SwigPySeq::const_iterator it = swigpyseq.begin();
6371  for (;it != swigpyseq.end(); ++it) {
6372  map->insert(value_type(it->first, it->second));
6373  }
6374  }
6375 
6376  template <class K, class T, class Compare, class Alloc>
6377  struct traits_asptr<std::map<K,T,Compare,Alloc > > {
6378  typedef std::map<K,T,Compare,Alloc > map_type;
6379  static int asptr(PyObject *obj, map_type **val) {
6380  int res = SWIG_ERROR;
6381  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6382  if (PyDict_Check(obj)) {
6383  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
6384 #if PY_VERSION_HEX >= 0x03000000
6385  /* In Python 3.x the ".items()" method returns a dict_items object */
6386  items = PySequence_Fast(items, ".items() didn't return a sequence!");
6387 #endif
6388  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
6389  } else {
6390  map_type *p;
6391  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
6392  if (SWIG_IsOK(res) && val) *val = p;
6393  }
6394  SWIG_PYTHON_THREAD_END_BLOCK;
6395  return res;
6396  }
6397  };
6398 
6399  template <class K, class T, class Compare, class Alloc >
6400  struct traits_from<std::map<K,T,Compare,Alloc > > {
6401  typedef std::map<K,T,Compare,Alloc > map_type;
6402  typedef typename map_type::const_iterator const_iterator;
6403  typedef typename map_type::size_type size_type;
6404 
6405  static PyObject *asdict(const map_type& map) {
6406  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6407  size_type size = map.size();
6408  Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6409  if (pysize < 0) {
6410  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6411  SWIG_PYTHON_THREAD_END_BLOCK;
6412  return NULL;
6413  }
6414  PyObject *obj = PyDict_New();
6415  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
6416  swig::SwigVar_PyObject key = swig::from(i->first);
6417  swig::SwigVar_PyObject val = swig::from(i->second);
6418  PyDict_SetItem(obj, key, val);
6419  }
6420  SWIG_PYTHON_THREAD_END_BLOCK;
6421  return obj;
6422  }
6423 
6424  static PyObject *from(const map_type& map) {
6425  swig_type_info *desc = swig::type_info<map_type>();
6426  if (desc && desc->clientdata) {
6427  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
6428  } else {
6429  return asdict(map);
6430  }
6431  }
6432  };
6433  }
6434 
6435 
6436  namespace swig {
6437  template <> struct traits<std::map< int, int, std::less< int >, std::allocator< std::pair< int const,int > > > > {
6438  typedef pointer_category category;
6439  static const char* type_name() {
6440  return "std::map<" "int" "," "int" "," "std::less< int >" "," "std::allocator< std::pair< int const,int > >" " >";
6441  }
6442  };
6443  }
6444 
6445 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6446  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6447  }
6448 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____nonzero__(std::map< int,int > const *self){
6449  return !(self->empty());
6450  }
6451 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____bool__(std::map< int,int > const *self){
6452  return !(self->empty());
6453  }
6454 SWIGINTERN std::map< int,int >::size_type std_map_Sl_int_Sc_int_Sg____len__(std::map< int,int > const *self){
6455  return self->size();
6456  }
6457 SWIGINTERN std::map< int,int >::mapped_type const &std_map_Sl_int_Sc_int_Sg____getitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6458  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
6459  if (i != self->end())
6460  return i->second;
6461  else
6462  throw std::out_of_range("key not found");
6463  }
6464 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____delitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6465  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::iterator i = self->find(key);
6466  if (i != self->end())
6467  self->erase(i);
6468  else
6469  throw std::out_of_range("key not found");
6470  }
6471 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg__has_key(std::map< int,int > const *self,std::map< int,int >::key_type const &key){
6472  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
6473  return i != self->end();
6474  }
6475 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__keys(std::map< int,int > *self){
6476  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6477  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6478  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6479  if (pysize < 0) {
6480  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6481  SWIG_PYTHON_THREAD_END_BLOCK;
6482  return NULL;
6483  }
6484  PyObject* keyList = PyList_New(pysize);
6485  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6486  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6487  PyList_SET_ITEM(keyList, j, swig::from(i->first));
6488  }
6489  SWIG_PYTHON_THREAD_END_BLOCK;
6490  return keyList;
6491  }
6492 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__values(std::map< int,int > *self){
6493  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6494  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6495  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6496  if (pysize < 0) {
6497  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6498  SWIG_PYTHON_THREAD_END_BLOCK;
6499  return NULL;
6500  }
6501  PyObject* valList = PyList_New(pysize);
6502  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6503  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6504  PyList_SET_ITEM(valList, j, swig::from(i->second));
6505  }
6506  SWIG_PYTHON_THREAD_END_BLOCK;
6507  return valList;
6508  }
6509 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__items(std::map< int,int > *self){
6510  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6511  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6512  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6513  if (pysize < 0) {
6514  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6515  SWIG_PYTHON_THREAD_END_BLOCK;
6516  return NULL;
6517  }
6518  PyObject* itemList = PyList_New(pysize);
6519  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6520  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6521  PyList_SET_ITEM(itemList, j, swig::from(*i));
6522  }
6523  SWIG_PYTHON_THREAD_END_BLOCK;
6524  return itemList;
6525  }
6526 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____contains__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6527  return self->find(key) != self->end();
6528  }
6529 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__key_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6530  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6531  }
6532 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__value_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6533  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6534  }
6535 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_0(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6536  self->erase(key);
6537  }
6538 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_1(std::map< int,int > *self,std::map< int,int >::key_type const &key,std::map< int,int >::mapped_type const &x){
6539  (*self)[key] = x;
6540  }
6541 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__asdict(std::map< int,int > *self){
6542  return swig::traits_from< std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > >::asdict(*self);
6543  }
6544 SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_1(std::map< int,int > *self,std::map< int,int >::iterator position){ self->erase(position); }
6545 SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_2(std::map< int,int > *self,std::map< int,int >::iterator first,std::map< int,int >::iterator last){ self->erase(first, last); }
6546 
6547 SWIGINTERN int
6548 SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
6549 {
6550  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
6551  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
6552  if (buf) {
6553  if (val) *val = new std::string(buf, size - 1);
6554  if (alloc == SWIG_NEWOBJ) delete[] buf;
6555  return SWIG_NEWOBJ;
6556  } else {
6557  if (val) *val = 0;
6558  return SWIG_OLDOBJ;
6559  }
6560  } else {
6561  static int init = 0;
6562  static swig_type_info* descriptor = 0;
6563  if (!init) {
6564  descriptor = SWIG_TypeQuery("std::string" " *");
6565  init = 1;
6566  }
6567  if (descriptor) {
6568  std::string *vptr;
6569  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
6570  if (SWIG_IsOK(res) && val) *val = vptr;
6571  return res;
6572  }
6573  }
6574  return SWIG_ERROR;
6575 }
6576 
6577 
6578 SWIGINTERN int
6579 SWIG_AsVal_std_string (PyObject * obj, std::string *val)
6580 {
6581  std::string* v = (std::string *) 0;
6582  int res = SWIG_AsPtr_std_string (obj, &v);
6583  if (!SWIG_IsOK(res)) return res;
6584  if (v) {
6585  if (val) *val = *v;
6586  if (SWIG_IsNewObj(res)) {
6587  delete v;
6588  res = SWIG_DelNewMask(res);
6589  }
6590  return res;
6591  }
6592  return SWIG_ERROR;
6593 }
6594 
6595 
6596 SWIGINTERNINLINE PyObject *
6597 SWIG_From_std_string (const std::string& s)
6598 {
6599  return SWIG_FromCharPtrAndSize(s.data(), s.size());
6600 }
6601 
6602 
6603 namespace swig {
6604  template <> struct traits< std::string > {
6605  typedef value_category category;
6606  static const char* type_name() { return"std::string"; }
6607  };
6608  template <> struct traits_asval< std::string > {
6609  typedef std::string value_type;
6610  static int asval(PyObject *obj, value_type *val) {
6611  return SWIG_AsVal_std_string (obj, val);
6612  }
6613  };
6614  template <> struct traits_from< std::string > {
6615  typedef std::string value_type;
6616  static PyObject *from(const value_type& val) {
6617  return SWIG_From_std_string (val);
6618  }
6619  };
6620 }
6621 
6622 
6623  namespace swig {
6624  template <> struct traits<std::pair< std::string, std::string > > {
6625  typedef pointer_category category;
6626  static const char* type_name() {
6627  return "std::pair<" "std::string" "," "std::string" " >";
6628  }
6629  };
6630  }
6631 
6632 
6633  namespace swig {
6634  template <> struct traits<std::map< std::string, std::string, std::less< std::string >, std::allocator< std::pair< std::string const,std::string > > > > {
6635  typedef pointer_category category;
6636  static const char* type_name() {
6637  return "std::map<" "std::string" "," "std::string" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,std::string > >" " >";
6638  }
6639  };
6640  }
6641 
6642 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6643  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6644  }
6645 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____nonzero__(std::map< std::string,std::string > const *self){
6646  return !(self->empty());
6647  }
6648 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____bool__(std::map< std::string,std::string > const *self){
6649  return !(self->empty());
6650  }
6651 SWIGINTERN std::map< std::string,std::string >::size_type std_map_Sl_std_string_Sc_std_string_Sg____len__(std::map< std::string,std::string > const *self){
6652  return self->size();
6653  }
6654 SWIGINTERN std::map< std::string,std::string >::mapped_type const &std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6655  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
6656  if (i != self->end())
6657  return i->second;
6658  else
6659  throw std::out_of_range("key not found");
6660  }
6661 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6662  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::iterator i = self->find(key);
6663  if (i != self->end())
6664  self->erase(i);
6665  else
6666  throw std::out_of_range("key not found");
6667  }
6668 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map< std::string,std::string > const *self,std::map< std::string,std::string >::key_type const &key){
6669  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
6670  return i != self->end();
6671  }
6672 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map< std::string,std::string > *self){
6673  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6674  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6675  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6676  if (pysize < 0) {
6677  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6678  SWIG_PYTHON_THREAD_END_BLOCK;
6679  return NULL;
6680  }
6681  PyObject* keyList = PyList_New(pysize);
6682  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6683  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6684  PyList_SET_ITEM(keyList, j, swig::from(i->first));
6685  }
6686  SWIG_PYTHON_THREAD_END_BLOCK;
6687  return keyList;
6688  }
6689 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__values(std::map< std::string,std::string > *self){
6690  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6691  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6692  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6693  if (pysize < 0) {
6694  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6695  SWIG_PYTHON_THREAD_END_BLOCK;
6696  return NULL;
6697  }
6698  PyObject* valList = PyList_New(pysize);
6699  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6700  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6701  PyList_SET_ITEM(valList, j, swig::from(i->second));
6702  }
6703  SWIG_PYTHON_THREAD_END_BLOCK;
6704  return valList;
6705  }
6706 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__items(std::map< std::string,std::string > *self){
6707  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6708  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6709  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6710  if (pysize < 0) {
6711  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6712  SWIG_PYTHON_THREAD_END_BLOCK;
6713  return NULL;
6714  }
6715  PyObject* itemList = PyList_New(pysize);
6716  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6717  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6718  PyList_SET_ITEM(itemList, j, swig::from(*i));
6719  }
6720  SWIG_PYTHON_THREAD_END_BLOCK;
6721  return itemList;
6722  }
6723 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____contains__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6724  return self->find(key) != self->end();
6725  }
6726 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6727  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6728  }
6729 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6730  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6731  }
6732 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_0(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6733  self->erase(key);
6734  }
6735 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
6736  (*self)[key] = x;
6737  }
6738 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__asdict(std::map< std::string,std::string > *self){
6739  return swig::traits_from< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > >::asdict(*self);
6740  }
6741 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator position){ self->erase(position); }
6742 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_2(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator first,std::map< std::string,std::string >::iterator last){ self->erase(first, last); }
6743 
6744  #define SWIG_From_double PyFloat_FromDouble
6745 
6746 
6747 namespace swig {
6748  template <> struct traits< double > {
6749  typedef value_category category;
6750  static const char* type_name() { return"double"; }
6751  };
6752  template <> struct traits_asval< double > {
6753  typedef double value_type;
6754  static int asval(PyObject *obj, value_type *val) {
6755  return SWIG_AsVal_double (obj, val);
6756  }
6757  };
6758  template <> struct traits_from< double > {
6759  typedef double value_type;
6760  static PyObject *from(const value_type& val) {
6761  return SWIG_From_double (val);
6762  }
6763  };
6764 }
6765 
6766 
6767  namespace swig {
6768  template <> struct traits<std::pair< double, std::pair< int,int > > > {
6769  typedef pointer_category category;
6770  static const char* type_name() {
6771  return "std::pair<" "double" "," "std::pair< int,int >" " >";
6772  }
6773  };
6774  }
6775 
6776 
6777  namespace swig {