ProSHADE  0.6.1 (JUN 2018)
Protein Shape Descriptors and Symmetry Detection
proshadePYTHON_wrap.cxx
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 4.0.0
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15 
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17 
18 
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22  struct SwigMovePointer {
23  T *ptr;
24  SwigMovePointer(T *p) : ptr(p) { }
25  ~SwigMovePointer() { delete ptr; }
26  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27  } pointer;
28  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31  SwigValueWrapper() : pointer(0) { }
32  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33  operator T&() const { return *pointer.ptr; }
34  T *operator&() { return pointer.ptr; }
35 };
36 
37 template <typename T> T SwigValueInit() {
38  return T();
39 }
40 #endif
41 
42 /* -----------------------------------------------------------------------------
43  * This section contains generic SWIG labels for method/variable
44  * declarations/attributes, and other compiler dependent labels.
45  * ----------------------------------------------------------------------------- */
46 
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59 
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68 
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83 
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89 
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97 
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102 
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107 
108 /* exporting methods */
109 #if defined(__GNUC__)
110 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
111 # ifndef GCC_HASCLASSVISIBILITY
112 # define GCC_HASCLASSVISIBILITY
113 # endif
114 # endif
115 #endif
116 
117 #ifndef SWIGEXPORT
118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
119 # if defined(STATIC_LINKED)
120 # define SWIGEXPORT
121 # else
122 # define SWIGEXPORT __declspec(dllexport)
123 # endif
124 # else
125 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
126 # define SWIGEXPORT __attribute__ ((visibility("default")))
127 # else
128 # define SWIGEXPORT
129 # endif
130 # endif
131 #endif
132 
133 /* calling conventions for Windows */
134 #ifndef SWIGSTDCALL
135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
136 # define SWIGSTDCALL __stdcall
137 # else
138 # define SWIGSTDCALL
139 # endif
140 #endif
141 
142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
144 # define _CRT_SECURE_NO_DEPRECATE
145 #endif
146 
147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
149 # define _SCL_SECURE_NO_DEPRECATE
150 #endif
151 
152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
155 #endif
156 
157 /* Intel's compiler complains if a variable which was never initialised is
158  * cast to void, which is a common idiom which we use to indicate that we
159  * are aware a variable isn't used. So we just silence that warning.
160  * See: https://github.com/swig/swig/issues/192 for more discussion.
161  */
162 #ifdef __INTEL_COMPILER
163 # pragma warning disable 592
164 #endif
165 
166 
167 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
168 /* Use debug wrappers with the Python release dll */
169 # undef _DEBUG
170 # include <Python.h>
171 # define _DEBUG 1
172 #else
173 # include <Python.h>
174 #endif
175 
176 /* -----------------------------------------------------------------------------
177  * swigrun.swg
178  *
179  * This file contains generic C API SWIG runtime support for pointer
180  * type checking.
181  * ----------------------------------------------------------------------------- */
182 
183 /* This should only be incremented when either the layout of swig_type_info changes,
184  or for whatever reason, the runtime changes incompatibly */
185 #define SWIG_RUNTIME_VERSION "4"
186 
187 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
188 #ifdef SWIG_TYPE_TABLE
189 # define SWIG_QUOTE_STRING(x) #x
190 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
191 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
192 #else
193 # define SWIG_TYPE_TABLE_NAME
194 #endif
195 
196 /*
197  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
198  creating a static or dynamic library from the SWIG runtime code.
199  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
200 
201  But only do this if strictly necessary, ie, if you have problems
202  with your compiler or suchlike.
203 */
204 
205 #ifndef SWIGRUNTIME
206 # define SWIGRUNTIME SWIGINTERN
207 #endif
208 
209 #ifndef SWIGRUNTIMEINLINE
210 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
211 #endif
212 
213 /* Generic buffer size */
214 #ifndef SWIG_BUFFER_SIZE
215 # define SWIG_BUFFER_SIZE 1024
216 #endif
217 
218 /* Flags for pointer conversions */
219 #define SWIG_POINTER_DISOWN 0x1
220 #define SWIG_CAST_NEW_MEMORY 0x2
221 
222 /* Flags for new pointer objects */
223 #define SWIG_POINTER_OWN 0x1
224 
225 
226 /*
227  Flags/methods for returning states.
228 
229  The SWIG conversion methods, as ConvertPtr, return an integer
230  that tells if the conversion was successful or not. And if not,
231  an error code can be returned (see swigerrors.swg for the codes).
232 
233  Use the following macros/flags to set or process the returning
234  states.
235 
236  In old versions of SWIG, code such as the following was usually written:
237 
238  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
239  // success code
240  } else {
241  //fail code
242  }
243 
244  Now you can be more explicit:
245 
246  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
247  if (SWIG_IsOK(res)) {
248  // success code
249  } else {
250  // fail code
251  }
252 
253  which is the same really, but now you can also do
254 
255  Type *ptr;
256  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
257  if (SWIG_IsOK(res)) {
258  // success code
259  if (SWIG_IsNewObj(res) {
260  ...
261  delete *ptr;
262  } else {
263  ...
264  }
265  } else {
266  // fail code
267  }
268 
269  I.e., now SWIG_ConvertPtr can return new objects and you can
270  identify the case and take care of the deallocation. Of course that
271  also requires SWIG_ConvertPtr to return new result values, such as
272 
273  int SWIG_ConvertPtr(obj, ptr,...) {
274  if (<obj is ok>) {
275  if (<need new object>) {
276  *ptr = <ptr to new allocated object>;
277  return SWIG_NEWOBJ;
278  } else {
279  *ptr = <ptr to old object>;
280  return SWIG_OLDOBJ;
281  }
282  } else {
283  return SWIG_BADOBJ;
284  }
285  }
286 
287  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
288  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
289  SWIG errors code.
290 
291  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
292  allows to return the 'cast rank', for example, if you have this
293 
294  int food(double)
295  int fooi(int);
296 
297  and you call
298 
299  food(1) // cast rank '1' (1 -> 1.0)
300  fooi(1) // cast rank '0'
301 
302  just use the SWIG_AddCast()/SWIG_CheckState()
303 */
304 
305 #define SWIG_OK (0)
306 #define SWIG_ERROR (-1)
307 #define SWIG_IsOK(r) (r >= 0)
308 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
309 
310 /* The CastRankLimit says how many bits are used for the cast rank */
311 #define SWIG_CASTRANKLIMIT (1 << 8)
312 /* The NewMask denotes the object was created (using new/malloc) */
313 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
314 /* The TmpMask is for in/out typemaps that use temporal objects */
315 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
316 /* Simple returning values */
317 #define SWIG_BADOBJ (SWIG_ERROR)
318 #define SWIG_OLDOBJ (SWIG_OK)
319 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
320 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
321 /* Check, add and del mask methods */
322 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
323 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
324 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
325 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
326 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
327 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
328 
329 /* Cast-Rank Mode */
330 #if defined(SWIG_CASTRANK_MODE)
331 # ifndef SWIG_TypeRank
332 # define SWIG_TypeRank unsigned long
333 # endif
334 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
335 # define SWIG_MAXCASTRANK (2)
336 # endif
337 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
338 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
339 SWIGINTERNINLINE int SWIG_AddCast(int r) {
340  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
341 }
342 SWIGINTERNINLINE int SWIG_CheckState(int r) {
343  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
344 }
345 #else /* no cast-rank mode */
346 # define SWIG_AddCast(r) (r)
347 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
348 #endif
349 
350 
351 #include <string.h>
352 
353 #ifdef __cplusplus
354 extern "C" {
355 #endif
356 
357 typedef void *(*swig_converter_func)(void *, int *);
358 typedef struct swig_type_info *(*swig_dycast_func)(void **);
359 
360 /* Structure to store information on one type */
361 typedef struct swig_type_info {
362  const char *name; /* mangled name of this type */
363  const char *str; /* human readable name of this type */
364  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
365  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
366  void *clientdata; /* language specific type data */
367  int owndata; /* flag if the structure owns the clientdata */
369 
370 /* Structure to store a type and conversion function used for casting */
371 typedef struct swig_cast_info {
372  swig_type_info *type; /* pointer to type that is equivalent to this type */
373  swig_converter_func converter; /* function to cast the void pointers */
374  struct swig_cast_info *next; /* pointer to next cast in linked list */
375  struct swig_cast_info *prev; /* pointer to the previous cast */
377 
378 /* Structure used to store module information
379  * Each module generates one structure like this, and the runtime collects
380  * all of these structures and stores them in a circularly linked list.*/
381 typedef struct swig_module_info {
382  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
383  size_t size; /* Number of types in this module */
384  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
385  swig_type_info **type_initial; /* Array of initially generated type structures */
386  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
387  void *clientdata; /* Language specific module data */
389 
390 /*
391  Compare two type names skipping the space characters, therefore
392  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
393 
394  Return 0 when the two name types are equivalent, as in
395  strncmp, but skipping ' '.
396 */
397 SWIGRUNTIME int
398 SWIG_TypeNameComp(const char *f1, const char *l1,
399  const char *f2, const char *l2) {
400  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
401  while ((*f1 == ' ') && (f1 != l1)) ++f1;
402  while ((*f2 == ' ') && (f2 != l2)) ++f2;
403  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
404  }
405  return (int)((l1 - f1) - (l2 - f2));
406 }
407 
408 /*
409  Check type equivalence in a name list like <name1>|<name2>|...
410  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
411 */
412 SWIGRUNTIME int
413 SWIG_TypeCmp(const char *nb, const char *tb) {
414  int equiv = 1;
415  const char* te = tb + strlen(tb);
416  const char* ne = nb;
417  while (equiv != 0 && *ne) {
418  for (nb = ne; *ne; ++ne) {
419  if (*ne == '|') break;
420  }
421  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
422  if (*ne) ++ne;
423  }
424  return equiv;
425 }
426 
427 /*
428  Check type equivalence in a name list like <name1>|<name2>|...
429  Return 0 if not equal, 1 if equal
430 */
431 SWIGRUNTIME int
432 SWIG_TypeEquiv(const char *nb, const char *tb) {
433  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
434 }
435 
436 /*
437  Check the typename
438 */
439 SWIGRUNTIME swig_cast_info *
440 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
441  if (ty) {
442  swig_cast_info *iter = ty->cast;
443  while (iter) {
444  if (strcmp(iter->type->name, c) == 0) {
445  if (iter == ty->cast)
446  return iter;
447  /* Move iter to the top of the linked list */
448  iter->prev->next = iter->next;
449  if (iter->next)
450  iter->next->prev = iter->prev;
451  iter->next = ty->cast;
452  iter->prev = 0;
453  if (ty->cast) ty->cast->prev = iter;
454  ty->cast = iter;
455  return iter;
456  }
457  iter = iter->next;
458  }
459  }
460  return 0;
461 }
462 
463 /*
464  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
465 */
466 SWIGRUNTIME swig_cast_info *
467 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
468  if (ty) {
469  swig_cast_info *iter = ty->cast;
470  while (iter) {
471  if (iter->type == from) {
472  if (iter == ty->cast)
473  return iter;
474  /* Move iter to the top of the linked list */
475  iter->prev->next = iter->next;
476  if (iter->next)
477  iter->next->prev = iter->prev;
478  iter->next = ty->cast;
479  iter->prev = 0;
480  if (ty->cast) ty->cast->prev = iter;
481  ty->cast = iter;
482  return iter;
483  }
484  iter = iter->next;
485  }
486  }
487  return 0;
488 }
489 
490 /*
491  Cast a pointer up an inheritance hierarchy
492 */
493 SWIGRUNTIMEINLINE void *
494 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
495  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
496 }
497 
498 /*
499  Dynamic pointer casting. Down an inheritance hierarchy
500 */
501 SWIGRUNTIME swig_type_info *
502 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
503  swig_type_info *lastty = ty;
504  if (!ty || !ty->dcast) return ty;
505  while (ty && (ty->dcast)) {
506  ty = (*ty->dcast)(ptr);
507  if (ty) lastty = ty;
508  }
509  return lastty;
510 }
511 
512 /*
513  Return the name associated with this type
514 */
515 SWIGRUNTIMEINLINE const char *
516 SWIG_TypeName(const swig_type_info *ty) {
517  return ty->name;
518 }
519 
520 /*
521  Return the pretty name associated with this type,
522  that is an unmangled type name in a form presentable to the user.
523 */
524 SWIGRUNTIME const char *
525 SWIG_TypePrettyName(const swig_type_info *type) {
526  /* The "str" field contains the equivalent pretty names of the
527  type, separated by vertical-bar characters. We choose
528  to print the last name, as it is often (?) the most
529  specific. */
530  if (!type) return NULL;
531  if (type->str != NULL) {
532  const char *last_name = type->str;
533  const char *s;
534  for (s = type->str; *s; s++)
535  if (*s == '|') last_name = s+1;
536  return last_name;
537  }
538  else
539  return type->name;
540 }
541 
542 /*
543  Set the clientdata field for a type
544 */
545 SWIGRUNTIME void
546 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
547  swig_cast_info *cast = ti->cast;
548  /* if (ti->clientdata == clientdata) return; */
549  ti->clientdata = clientdata;
550 
551  while (cast) {
552  if (!cast->converter) {
553  swig_type_info *tc = cast->type;
554  if (!tc->clientdata) {
555  SWIG_TypeClientData(tc, clientdata);
556  }
557  }
558  cast = cast->next;
559  }
560 }
561 SWIGRUNTIME void
562 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
563  SWIG_TypeClientData(ti, clientdata);
564  ti->owndata = 1;
565 }
566 
567 /*
568  Search for a swig_type_info structure only by mangled name
569  Search is a O(log #types)
570 
571  We start searching at module start, and finish searching when start == end.
572  Note: if start == end at the beginning of the function, we go all the way around
573  the circular list.
574 */
575 SWIGRUNTIME swig_type_info *
576 SWIG_MangledTypeQueryModule(swig_module_info *start,
577  swig_module_info *end,
578  const char *name) {
579  swig_module_info *iter = start;
580  do {
581  if (iter->size) {
582  size_t l = 0;
583  size_t r = iter->size - 1;
584  do {
585  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
586  size_t i = (l + r) >> 1;
587  const char *iname = iter->types[i]->name;
588  if (iname) {
589  int compare = strcmp(name, iname);
590  if (compare == 0) {
591  return iter->types[i];
592  } else if (compare < 0) {
593  if (i) {
594  r = i - 1;
595  } else {
596  break;
597  }
598  } else if (compare > 0) {
599  l = i + 1;
600  }
601  } else {
602  break; /* should never happen */
603  }
604  } while (l <= r);
605  }
606  iter = iter->next;
607  } while (iter != end);
608  return 0;
609 }
610 
611 /*
612  Search for a swig_type_info structure for either a mangled name or a human readable name.
613  It first searches the mangled names of the types, which is a O(log #types)
614  If a type is not found it then searches the human readable names, which is O(#types).
615 
616  We start searching at module start, and finish searching when start == end.
617  Note: if start == end at the beginning of the function, we go all the way around
618  the circular list.
619 */
620 SWIGRUNTIME swig_type_info *
621 SWIG_TypeQueryModule(swig_module_info *start,
622  swig_module_info *end,
623  const char *name) {
624  /* STEP 1: Search the name field using binary search */
625  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
626  if (ret) {
627  return ret;
628  } else {
629  /* STEP 2: If the type hasn't been found, do a complete search
630  of the str field (the human readable name) */
631  swig_module_info *iter = start;
632  do {
633  size_t i = 0;
634  for (; i < iter->size; ++i) {
635  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
636  return iter->types[i];
637  }
638  iter = iter->next;
639  } while (iter != end);
640  }
641 
642  /* neither found a match */
643  return 0;
644 }
645 
646 /*
647  Pack binary data into a string
648 */
649 SWIGRUNTIME char *
650 SWIG_PackData(char *c, void *ptr, size_t sz) {
651  static const char hex[17] = "0123456789abcdef";
652  const unsigned char *u = (unsigned char *) ptr;
653  const unsigned char *eu = u + sz;
654  for (; u != eu; ++u) {
655  unsigned char uu = *u;
656  *(c++) = hex[(uu & 0xf0) >> 4];
657  *(c++) = hex[uu & 0xf];
658  }
659  return c;
660 }
661 
662 /*
663  Unpack binary data from a string
664 */
665 SWIGRUNTIME const char *
666 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
667  unsigned char *u = (unsigned char *) ptr;
668  const unsigned char *eu = u + sz;
669  for (; u != eu; ++u) {
670  char d = *(c++);
671  unsigned char uu;
672  if ((d >= '0') && (d <= '9'))
673  uu = (unsigned char)((d - '0') << 4);
674  else if ((d >= 'a') && (d <= 'f'))
675  uu = (unsigned char)((d - ('a'-10)) << 4);
676  else
677  return (char *) 0;
678  d = *(c++);
679  if ((d >= '0') && (d <= '9'))
680  uu |= (unsigned char)(d - '0');
681  else if ((d >= 'a') && (d <= 'f'))
682  uu |= (unsigned char)(d - ('a'-10));
683  else
684  return (char *) 0;
685  *u = uu;
686  }
687  return c;
688 }
689 
690 /*
691  Pack 'void *' into a string buffer.
692 */
693 SWIGRUNTIME char *
694 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
695  char *r = buff;
696  if ((2*sizeof(void *) + 2) > bsz) return 0;
697  *(r++) = '_';
698  r = SWIG_PackData(r,&ptr,sizeof(void *));
699  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
700  strcpy(r,name);
701  return buff;
702 }
703 
704 SWIGRUNTIME const char *
705 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
706  if (*c != '_') {
707  if (strcmp(c,"NULL") == 0) {
708  *ptr = (void *) 0;
709  return name;
710  } else {
711  return 0;
712  }
713  }
714  return SWIG_UnpackData(++c,ptr,sizeof(void *));
715 }
716 
717 SWIGRUNTIME char *
718 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
719  char *r = buff;
720  size_t lname = (name ? strlen(name) : 0);
721  if ((2*sz + 2 + lname) > bsz) return 0;
722  *(r++) = '_';
723  r = SWIG_PackData(r,ptr,sz);
724  if (lname) {
725  strncpy(r,name,lname+1);
726  } else {
727  *r = 0;
728  }
729  return buff;
730 }
731 
732 SWIGRUNTIME const char *
733 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
734  if (*c != '_') {
735  if (strcmp(c,"NULL") == 0) {
736  memset(ptr,0,sz);
737  return name;
738  } else {
739  return 0;
740  }
741  }
742  return SWIG_UnpackData(++c,ptr,sz);
743 }
744 
745 #ifdef __cplusplus
746 }
747 #endif
748 
749 /* Errors in SWIG */
750 #define SWIG_UnknownError -1
751 #define SWIG_IOError -2
752 #define SWIG_RuntimeError -3
753 #define SWIG_IndexError -4
754 #define SWIG_TypeError -5
755 #define SWIG_DivisionByZero -6
756 #define SWIG_OverflowError -7
757 #define SWIG_SyntaxError -8
758 #define SWIG_ValueError -9
759 #define SWIG_SystemError -10
760 #define SWIG_AttributeError -11
761 #define SWIG_MemoryError -12
762 #define SWIG_NullReferenceError -13
763 
764 
765 
766 /* Compatibility macros for Python 3 */
767 #if PY_VERSION_HEX >= 0x03000000
768 
769 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
770 #define PyInt_Check(x) PyLong_Check(x)
771 #define PyInt_AsLong(x) PyLong_AsLong(x)
772 #define PyInt_FromLong(x) PyLong_FromLong(x)
773 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
774 #define PyString_Check(name) PyBytes_Check(name)
775 #define PyString_FromString(x) PyUnicode_FromString(x)
776 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
777 #define PyString_AsString(str) PyBytes_AsString(str)
778 #define PyString_Size(str) PyBytes_Size(str)
779 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
780 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
781 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
782 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
783 
784 #endif
785 
786 #ifndef Py_TYPE
787 # define Py_TYPE(op) ((op)->ob_type)
788 #endif
789 
790 /* SWIG APIs for compatibility of both Python 2 & 3 */
791 
792 #if PY_VERSION_HEX >= 0x03000000
793 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
794 #else
795 # define SWIG_Python_str_FromFormat PyString_FromFormat
796 #endif
797 
798 
799 /* Warning: This function will allocate a new string in Python 3,
800  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
801  */
802 SWIGINTERN char*
803 SWIG_Python_str_AsChar(PyObject *str)
804 {
805 #if PY_VERSION_HEX >= 0x03000000
806  char *newstr = 0;
807  str = PyUnicode_AsUTF8String(str);
808  if (str) {
809  char *cstr;
810  Py_ssize_t len;
811  PyBytes_AsStringAndSize(str, &cstr, &len);
812  newstr = (char *) malloc(len+1);
813  memcpy(newstr, cstr, len+1);
814  Py_XDECREF(str);
815  }
816  return newstr;
817 #else
818  return PyString_AsString(str);
819 #endif
820 }
821 
822 #if PY_VERSION_HEX >= 0x03000000
823 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
824 #else
825 # define SWIG_Python_str_DelForPy3(x)
826 #endif
827 
828 
829 SWIGINTERN PyObject*
830 SWIG_Python_str_FromChar(const char *c)
831 {
832 #if PY_VERSION_HEX >= 0x03000000
833  return PyUnicode_FromString(c);
834 #else
835  return PyString_FromString(c);
836 #endif
837 }
838 
839 /* Add PyOS_snprintf for old Pythons */
840 #if PY_VERSION_HEX < 0x02020000
841 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
842 # define PyOS_snprintf _snprintf
843 # else
844 # define PyOS_snprintf snprintf
845 # endif
846 #endif
847 
848 /* A crude PyString_FromFormat implementation for old Pythons */
849 #if PY_VERSION_HEX < 0x02020000
850 
851 #ifndef SWIG_PYBUFFER_SIZE
852 # define SWIG_PYBUFFER_SIZE 1024
853 #endif
854 
855 static PyObject *
856 PyString_FromFormat(const char *fmt, ...) {
857  va_list ap;
858  char buf[SWIG_PYBUFFER_SIZE * 2];
859  int res;
860  va_start(ap, fmt);
861  res = vsnprintf(buf, sizeof(buf), fmt, ap);
862  va_end(ap);
863  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
864 }
865 #endif
866 
867 #ifndef PyObject_DEL
868 # define PyObject_DEL PyObject_Del
869 #endif
870 
871 /* A crude PyExc_StopIteration exception for old Pythons */
872 #if PY_VERSION_HEX < 0x02020000
873 # ifndef PyExc_StopIteration
874 # define PyExc_StopIteration PyExc_RuntimeError
875 # endif
876 # ifndef PyObject_GenericGetAttr
877 # define PyObject_GenericGetAttr 0
878 # endif
879 #endif
880 
881 /* Py_NotImplemented is defined in 2.1 and up. */
882 #if PY_VERSION_HEX < 0x02010000
883 # ifndef Py_NotImplemented
884 # define Py_NotImplemented PyExc_RuntimeError
885 # endif
886 #endif
887 
888 /* A crude PyString_AsStringAndSize implementation for old Pythons */
889 #if PY_VERSION_HEX < 0x02010000
890 # ifndef PyString_AsStringAndSize
891 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
892 # endif
893 #endif
894 
895 /* PySequence_Size for old Pythons */
896 #if PY_VERSION_HEX < 0x02000000
897 # ifndef PySequence_Size
898 # define PySequence_Size PySequence_Length
899 # endif
900 #endif
901 
902 /* PyBool_FromLong for old Pythons */
903 #if PY_VERSION_HEX < 0x02030000
904 static
905 PyObject *PyBool_FromLong(long ok)
906 {
907  PyObject *result = ok ? Py_True : Py_False;
908  Py_INCREF(result);
909  return result;
910 }
911 #endif
912 
913 /* Py_ssize_t for old Pythons */
914 /* This code is as recommended by: */
915 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
916 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
917 typedef int Py_ssize_t;
918 # define PY_SSIZE_T_MAX INT_MAX
919 # define PY_SSIZE_T_MIN INT_MIN
920 typedef inquiry lenfunc;
921 typedef intargfunc ssizeargfunc;
922 typedef intintargfunc ssizessizeargfunc;
923 typedef intobjargproc ssizeobjargproc;
924 typedef intintobjargproc ssizessizeobjargproc;
925 typedef getreadbufferproc readbufferproc;
926 typedef getwritebufferproc writebufferproc;
927 typedef getsegcountproc segcountproc;
928 typedef getcharbufferproc charbufferproc;
929 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
930 {
931  long result = 0;
932  PyObject *i = PyNumber_Int(x);
933  if (i) {
934  result = PyInt_AsLong(i);
935  Py_DECREF(i);
936  }
937  return result;
938 }
939 #endif
940 
941 #if PY_VERSION_HEX < 0x02050000
942 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
943 #endif
944 
945 #if PY_VERSION_HEX < 0x02040000
946 #define Py_VISIT(op) \
947  do { \
948  if (op) { \
949  int vret = visit((op), arg); \
950  if (vret) \
951  return vret; \
952  } \
953  } while (0)
954 #endif
955 
956 #if PY_VERSION_HEX < 0x02030000
957 typedef struct {
958  PyTypeObject type;
959  PyNumberMethods as_number;
960  PyMappingMethods as_mapping;
961  PySequenceMethods as_sequence;
962  PyBufferProcs as_buffer;
963  PyObject *name, *slots;
965 #endif
966 
967 #if PY_VERSION_HEX < 0x02030000
968 typedef destructor freefunc;
969 #endif
970 
971 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
972  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
973  (PY_MAJOR_VERSION > 3))
974 # define SWIGPY_USE_CAPSULE
975 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
976 #endif
977 
978 #if PY_VERSION_HEX < 0x03020000
979 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
980 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
981 #define Py_hash_t long
982 #endif
983 
984 /* -----------------------------------------------------------------------------
985  * error manipulation
986  * ----------------------------------------------------------------------------- */
987 
988 SWIGRUNTIME PyObject*
989 SWIG_Python_ErrorType(int code) {
990  PyObject* type = 0;
991  switch(code) {
992  case SWIG_MemoryError:
993  type = PyExc_MemoryError;
994  break;
995  case SWIG_IOError:
996  type = PyExc_IOError;
997  break;
998  case SWIG_RuntimeError:
999  type = PyExc_RuntimeError;
1000  break;
1001  case SWIG_IndexError:
1002  type = PyExc_IndexError;
1003  break;
1004  case SWIG_TypeError:
1005  type = PyExc_TypeError;
1006  break;
1007  case SWIG_DivisionByZero:
1008  type = PyExc_ZeroDivisionError;
1009  break;
1010  case SWIG_OverflowError:
1011  type = PyExc_OverflowError;
1012  break;
1013  case SWIG_SyntaxError:
1014  type = PyExc_SyntaxError;
1015  break;
1016  case SWIG_ValueError:
1017  type = PyExc_ValueError;
1018  break;
1019  case SWIG_SystemError:
1020  type = PyExc_SystemError;
1021  break;
1022  case SWIG_AttributeError:
1023  type = PyExc_AttributeError;
1024  break;
1025  default:
1026  type = PyExc_RuntimeError;
1027  }
1028  return type;
1029 }
1030 
1031 
1032 SWIGRUNTIME void
1033 SWIG_Python_AddErrorMsg(const char* mesg)
1034 {
1035  PyObject *type = 0;
1036  PyObject *value = 0;
1037  PyObject *traceback = 0;
1038 
1039  if (PyErr_Occurred())
1040  PyErr_Fetch(&type, &value, &traceback);
1041  if (value) {
1042  PyObject *old_str = PyObject_Str(value);
1043  const char *tmp = SWIG_Python_str_AsChar(old_str);
1044  PyErr_Clear();
1045  Py_XINCREF(type);
1046  if (tmp)
1047  PyErr_Format(type, "%s %s", tmp, mesg);
1048  else
1049  PyErr_Format(type, "%s", mesg);
1050  SWIG_Python_str_DelForPy3(tmp);
1051  Py_DECREF(old_str);
1052  Py_DECREF(value);
1053  } else {
1054  PyErr_SetString(PyExc_RuntimeError, mesg);
1055  }
1056 }
1057 
1058 #if defined(SWIG_PYTHON_NO_THREADS)
1059 # if defined(SWIG_PYTHON_THREADS)
1060 # undef SWIG_PYTHON_THREADS
1061 # endif
1062 #endif
1063 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1064 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1065 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1066 # define SWIG_PYTHON_USE_GIL
1067 # endif
1068 # endif
1069 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1070 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1071 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1072 # endif
1073 # ifdef __cplusplus /* C++ code */
1074  class SWIG_Python_Thread_Block {
1075  bool status;
1076  PyGILState_STATE state;
1077  public:
1078  void end() { if (status) { PyGILState_Release(state); status = false;} }
1079  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1080  ~SWIG_Python_Thread_Block() { end(); }
1081  };
1082  class SWIG_Python_Thread_Allow {
1083  bool status;
1084  PyThreadState *save;
1085  public:
1086  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1087  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1088  ~SWIG_Python_Thread_Allow() { end(); }
1089  };
1090 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1091 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1092 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1093 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1094 # else /* C code */
1095 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1096 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1097 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1098 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1099 # endif
1100 # else /* Old thread way, not implemented, user must provide it */
1101 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1102 # define SWIG_PYTHON_INITIALIZE_THREADS
1103 # endif
1104 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1105 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1106 # endif
1107 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1108 # define SWIG_PYTHON_THREAD_END_BLOCK
1109 # endif
1110 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1111 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1112 # endif
1113 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1114 # define SWIG_PYTHON_THREAD_END_ALLOW
1115 # endif
1116 # endif
1117 #else /* No thread support */
1118 # define SWIG_PYTHON_INITIALIZE_THREADS
1119 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1120 # define SWIG_PYTHON_THREAD_END_BLOCK
1121 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1122 # define SWIG_PYTHON_THREAD_END_ALLOW
1123 #endif
1124 
1125 /* -----------------------------------------------------------------------------
1126  * Python API portion that goes into the runtime
1127  * ----------------------------------------------------------------------------- */
1128 
1129 #ifdef __cplusplus
1130 extern "C" {
1131 #endif
1132 
1133 /* -----------------------------------------------------------------------------
1134  * Constant declarations
1135  * ----------------------------------------------------------------------------- */
1136 
1137 /* Constant Types */
1138 #define SWIG_PY_POINTER 4
1139 #define SWIG_PY_BINARY 5
1140 
1141 /* Constant information structure */
1142 typedef struct swig_const_info {
1143  int type;
1144  char *name;
1145  long lvalue;
1146  double dvalue;
1147  void *pvalue;
1148  swig_type_info **ptype;
1149 } swig_const_info;
1150 
1151 
1152 /* -----------------------------------------------------------------------------
1153  * Wrapper of PyInstanceMethod_New() used in Python 3
1154  * It is exported to the generated module, used for -fastproxy
1155  * ----------------------------------------------------------------------------- */
1156 #if PY_VERSION_HEX >= 0x03000000
1157 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1158 {
1159  return PyInstanceMethod_New(func);
1160 }
1161 #else
1162 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1163 {
1164  return NULL;
1165 }
1166 #endif
1167 
1168 #ifdef __cplusplus
1169 }
1170 #endif
1171 
1172 
1173 /* -----------------------------------------------------------------------------
1174  * pyrun.swg
1175  *
1176  * This file contains the runtime support for Python modules
1177  * and includes code for managing global variables and pointer
1178  * type checking.
1179  *
1180  * ----------------------------------------------------------------------------- */
1181 
1182 /* Common SWIG API */
1183 
1184 /* for raw pointers */
1185 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1186 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1187 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1188 
1189 #ifdef SWIGPYTHON_BUILTIN
1190 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1191 #else
1192 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1193 #endif
1194 
1195 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1196 
1197 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1198 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1199 #define swig_owntype int
1200 
1201 /* for raw packed data */
1202 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1203 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1204 
1205 /* for class or struct pointers */
1206 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1207 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1208 
1209 /* for C or C++ function pointers */
1210 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1211 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1212 
1213 /* for C++ member pointers, ie, member methods */
1214 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1215 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1216 
1217 
1218 /* Runtime API */
1219 
1220 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1221 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1222 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1223 
1224 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1225 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1226 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1227 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1228 #define SWIG_fail goto fail
1229 
1230 
1231 /* Runtime API implementation */
1232 
1233 /* Error manipulation */
1234 
1235 SWIGINTERN void
1236 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1237  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1238  PyErr_SetObject(errtype, obj);
1239  Py_DECREF(obj);
1240  SWIG_PYTHON_THREAD_END_BLOCK;
1241 }
1242 
1243 SWIGINTERN void
1244 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1245  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1246  PyErr_SetString(errtype, msg);
1247  SWIG_PYTHON_THREAD_END_BLOCK;
1248 }
1249 
1250 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1251 
1252 /* Set a constant value */
1253 
1254 #if defined(SWIGPYTHON_BUILTIN)
1255 
1256 SWIGINTERN void
1257 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1258  PyObject *s = PyString_InternFromString(key);
1259  PyList_Append(seq, s);
1260  Py_DECREF(s);
1261 }
1262 
1263 SWIGINTERN void
1264 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1265 #if PY_VERSION_HEX < 0x02030000
1266  PyDict_SetItemString(d, (char *)name, obj);
1267 #else
1268  PyDict_SetItemString(d, name, obj);
1269 #endif
1270  Py_DECREF(obj);
1271  if (public_interface)
1272  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1273 }
1274 
1275 #else
1276 
1277 SWIGINTERN void
1278 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1279 #if PY_VERSION_HEX < 0x02030000
1280  PyDict_SetItemString(d, (char *)name, obj);
1281 #else
1282  PyDict_SetItemString(d, name, obj);
1283 #endif
1284  Py_DECREF(obj);
1285 }
1286 
1287 #endif
1288 
1289 /* Append a value to the result obj */
1290 
1291 SWIGINTERN PyObject*
1292 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1293 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1294  if (!result) {
1295  result = obj;
1296  } else if (result == Py_None) {
1297  Py_DECREF(result);
1298  result = obj;
1299  } else {
1300  if (!PyList_Check(result)) {
1301  PyObject *o2 = result;
1302  result = PyList_New(1);
1303  PyList_SetItem(result, 0, o2);
1304  }
1305  PyList_Append(result,obj);
1306  Py_DECREF(obj);
1307  }
1308  return result;
1309 #else
1310  PyObject* o2;
1311  PyObject* o3;
1312  if (!result) {
1313  result = obj;
1314  } else if (result == Py_None) {
1315  Py_DECREF(result);
1316  result = obj;
1317  } else {
1318  if (!PyTuple_Check(result)) {
1319  o2 = result;
1320  result = PyTuple_New(1);
1321  PyTuple_SET_ITEM(result, 0, o2);
1322  }
1323  o3 = PyTuple_New(1);
1324  PyTuple_SET_ITEM(o3, 0, obj);
1325  o2 = result;
1326  result = PySequence_Concat(o2, o3);
1327  Py_DECREF(o2);
1328  Py_DECREF(o3);
1329  }
1330  return result;
1331 #endif
1332 }
1333 
1334 /* Unpack the argument tuple */
1335 
1336 SWIGINTERN Py_ssize_t
1337 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1338 {
1339  if (!args) {
1340  if (!min && !max) {
1341  return 1;
1342  } else {
1343  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1344  name, (min == max ? "" : "at least "), (int)min);
1345  return 0;
1346  }
1347  }
1348  if (!PyTuple_Check(args)) {
1349  if (min <= 1 && max >= 1) {
1350  Py_ssize_t i;
1351  objs[0] = args;
1352  for (i = 1; i < max; ++i) {
1353  objs[i] = 0;
1354  }
1355  return 2;
1356  }
1357  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1358  return 0;
1359  } else {
1360  Py_ssize_t l = PyTuple_GET_SIZE(args);
1361  if (l < min) {
1362  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1363  name, (min == max ? "" : "at least "), (int)min, (int)l);
1364  return 0;
1365  } else if (l > max) {
1366  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1367  name, (min == max ? "" : "at most "), (int)max, (int)l);
1368  return 0;
1369  } else {
1370  Py_ssize_t i;
1371  for (i = 0; i < l; ++i) {
1372  objs[i] = PyTuple_GET_ITEM(args, i);
1373  }
1374  for (; l < max; ++l) {
1375  objs[l] = 0;
1376  }
1377  return i + 1;
1378  }
1379  }
1380 }
1381 
1382 /* A functor is a function object with one single object argument */
1383 #if PY_VERSION_HEX >= 0x02020000
1384 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1385 #else
1386 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1387 #endif
1388 
1389 /*
1390  Helper for static pointer initialization for both C and C++ code, for example
1391  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1392 */
1393 #ifdef __cplusplus
1394 #define SWIG_STATIC_POINTER(var) var
1395 #else
1396 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1397 #endif
1398 
1399 /* -----------------------------------------------------------------------------
1400  * Pointer declarations
1401  * ----------------------------------------------------------------------------- */
1402 
1403 /* Flags for new pointer objects */
1404 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1405 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1406 
1407 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1408 
1409 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1410 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1411 
1412 #ifdef __cplusplus
1413 extern "C" {
1414 #endif
1415 
1416 /* How to access Py_None */
1417 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1418 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1419 # ifndef SWIG_PYTHON_BUILD_NONE
1420 # define SWIG_PYTHON_BUILD_NONE
1421 # endif
1422 # endif
1423 #endif
1424 
1425 #ifdef SWIG_PYTHON_BUILD_NONE
1426 # ifdef Py_None
1427 # undef Py_None
1428 # define Py_None SWIG_Py_None()
1429 # endif
1430 SWIGRUNTIMEINLINE PyObject *
1431 _SWIG_Py_None(void)
1432 {
1433  PyObject *none = Py_BuildValue((char*)"");
1434  Py_DECREF(none);
1435  return none;
1436 }
1437 SWIGRUNTIME PyObject *
1438 SWIG_Py_None(void)
1439 {
1440  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1441  return none;
1442 }
1443 #endif
1444 
1445 /* The python void return value */
1446 
1447 SWIGRUNTIMEINLINE PyObject *
1448 SWIG_Py_Void(void)
1449 {
1450  PyObject *none = Py_None;
1451  Py_INCREF(none);
1452  return none;
1453 }
1454 
1455 /* SwigPyClientData */
1456 
1457 typedef struct {
1458  PyObject *klass;
1459  PyObject *newraw;
1460  PyObject *newargs;
1461  PyObject *destroy;
1462  int delargs;
1463  int implicitconv;
1464  PyTypeObject *pytype;
1466 
1467 SWIGRUNTIMEINLINE int
1468 SWIG_Python_CheckImplicit(swig_type_info *ty)
1469 {
1470  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1471  return data ? data->implicitconv : 0;
1472 }
1473 
1474 SWIGRUNTIMEINLINE PyObject *
1475 SWIG_Python_ExceptionType(swig_type_info *desc) {
1476  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1477  PyObject *klass = data ? data->klass : 0;
1478  return (klass ? klass : PyExc_RuntimeError);
1479 }
1480 
1481 
1482 SWIGRUNTIME SwigPyClientData *
1483 SwigPyClientData_New(PyObject* obj)
1484 {
1485  if (!obj) {
1486  return 0;
1487  } else {
1488  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1489  /* the klass element */
1490  data->klass = obj;
1491  Py_INCREF(data->klass);
1492  /* the newraw method and newargs arguments used to create a new raw instance */
1493  if (PyClass_Check(obj)) {
1494  data->newraw = 0;
1495  data->newargs = obj;
1496  Py_INCREF(obj);
1497  } else {
1498 #if (PY_VERSION_HEX < 0x02020000)
1499  data->newraw = 0;
1500 #else
1501  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1502 #endif
1503  if (data->newraw) {
1504  Py_INCREF(data->newraw);
1505  data->newargs = PyTuple_New(1);
1506  PyTuple_SetItem(data->newargs, 0, obj);
1507  } else {
1508  data->newargs = obj;
1509  }
1510  Py_INCREF(data->newargs);
1511  }
1512  /* the destroy method, aka as the C++ delete method */
1513  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1514  if (PyErr_Occurred()) {
1515  PyErr_Clear();
1516  data->destroy = 0;
1517  }
1518  if (data->destroy) {
1519  int flags;
1520  Py_INCREF(data->destroy);
1521  flags = PyCFunction_GET_FLAGS(data->destroy);
1522 #ifdef METH_O
1523  data->delargs = !(flags & (METH_O));
1524 #else
1525  data->delargs = 0;
1526 #endif
1527  } else {
1528  data->delargs = 0;
1529  }
1530  data->implicitconv = 0;
1531  data->pytype = 0;
1532  return data;
1533  }
1534 }
1535 
1536 SWIGRUNTIME void
1537 SwigPyClientData_Del(SwigPyClientData *data) {
1538  Py_XDECREF(data->newraw);
1539  Py_XDECREF(data->newargs);
1540  Py_XDECREF(data->destroy);
1541 }
1542 
1543 /* =============== SwigPyObject =====================*/
1544 
1545 typedef struct {
1546  PyObject_HEAD
1547  void *ptr;
1548  swig_type_info *ty;
1549  int own;
1550  PyObject *next;
1551 #ifdef SWIGPYTHON_BUILTIN
1552  PyObject *dict;
1553 #endif
1554 } SwigPyObject;
1555 
1556 
1557 #ifdef SWIGPYTHON_BUILTIN
1558 
1559 SWIGRUNTIME PyObject *
1560 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1561 {
1562  SwigPyObject *sobj = (SwigPyObject *)v;
1563 
1564  if (!sobj->dict)
1565  sobj->dict = PyDict_New();
1566 
1567  Py_INCREF(sobj->dict);
1568  return sobj->dict;
1569 }
1570 
1571 #endif
1572 
1573 SWIGRUNTIME PyObject *
1574 SwigPyObject_long(SwigPyObject *v)
1575 {
1576  return PyLong_FromVoidPtr(v->ptr);
1577 }
1578 
1579 SWIGRUNTIME PyObject *
1580 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1581 {
1582  PyObject *res = NULL;
1583  PyObject *args = PyTuple_New(1);
1584  if (args) {
1585  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1586  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1587  if (ofmt) {
1588 #if PY_VERSION_HEX >= 0x03000000
1589  res = PyUnicode_Format(ofmt,args);
1590 #else
1591  res = PyString_Format(ofmt,args);
1592 #endif
1593  Py_DECREF(ofmt);
1594  }
1595  Py_DECREF(args);
1596  }
1597  }
1598  return res;
1599 }
1600 
1601 SWIGRUNTIME PyObject *
1602 SwigPyObject_oct(SwigPyObject *v)
1603 {
1604  return SwigPyObject_format("%o",v);
1605 }
1606 
1607 SWIGRUNTIME PyObject *
1608 SwigPyObject_hex(SwigPyObject *v)
1609 {
1610  return SwigPyObject_format("%x",v);
1611 }
1612 
1613 SWIGRUNTIME PyObject *
1614 #ifdef METH_NOARGS
1615 SwigPyObject_repr(SwigPyObject *v)
1616 #else
1617 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1618 #endif
1619 {
1620  const char *name = SWIG_TypePrettyName(v->ty);
1621  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1622  if (v->next) {
1623 # ifdef METH_NOARGS
1624  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1625 # else
1626  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1627 # endif
1628 # if PY_VERSION_HEX >= 0x03000000
1629  PyObject *joined = PyUnicode_Concat(repr, nrep);
1630  Py_DecRef(repr);
1631  Py_DecRef(nrep);
1632  repr = joined;
1633 # else
1634  PyString_ConcatAndDel(&repr,nrep);
1635 # endif
1636  }
1637  return repr;
1638 }
1639 
1640 SWIGRUNTIME int
1641 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1642 {
1643  void *i = v->ptr;
1644  void *j = w->ptr;
1645  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1646 }
1647 
1648 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1649 SWIGRUNTIME PyObject*
1650 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1651 {
1652  PyObject* res;
1653  if( op != Py_EQ && op != Py_NE ) {
1654  Py_INCREF(Py_NotImplemented);
1655  return Py_NotImplemented;
1656  }
1657  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1658  return res;
1659 }
1660 
1661 
1662 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1663 
1664 #ifdef SWIGPYTHON_BUILTIN
1665 static swig_type_info *SwigPyObject_stype = 0;
1666 SWIGRUNTIME PyTypeObject*
1667 SwigPyObject_type(void) {
1668  SwigPyClientData *cd;
1669  assert(SwigPyObject_stype);
1670  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1671  assert(cd);
1672  assert(cd->pytype);
1673  return cd->pytype;
1674 }
1675 #else
1676 SWIGRUNTIME PyTypeObject*
1677 SwigPyObject_type(void) {
1678  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1679  return type;
1680 }
1681 #endif
1682 
1683 SWIGRUNTIMEINLINE int
1684 SwigPyObject_Check(PyObject *op) {
1685 #ifdef SWIGPYTHON_BUILTIN
1686  PyTypeObject *target_tp = SwigPyObject_type();
1687  if (PyType_IsSubtype(op->ob_type, target_tp))
1688  return 1;
1689  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1690 #else
1691  return (Py_TYPE(op) == SwigPyObject_type())
1692  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1693 #endif
1694 }
1695 
1696 SWIGRUNTIME PyObject *
1697 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1698 
1699 SWIGRUNTIME void
1700 SwigPyObject_dealloc(PyObject *v)
1701 {
1702  SwigPyObject *sobj = (SwigPyObject *) v;
1703  PyObject *next = sobj->next;
1704  if (sobj->own == SWIG_POINTER_OWN) {
1705  swig_type_info *ty = sobj->ty;
1706  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1707  PyObject *destroy = data ? data->destroy : 0;
1708  if (destroy) {
1709  /* destroy is always a VARARGS method */
1710  PyObject *res;
1711 
1712  /* PyObject_CallFunction() has the potential to silently drop
1713  the active exception. In cases of unnamed temporary
1714  variable or where we just finished iterating over a generator
1715  StopIteration will be active right now, and this needs to
1716  remain true upon return from SwigPyObject_dealloc. So save
1717  and restore. */
1718 
1719  PyObject *val = NULL, *type = NULL, *tb = NULL;
1720  PyErr_Fetch(&val, &type, &tb);
1721 
1722  if (data->delargs) {
1723  /* we need to create a temporary object to carry the destroy operation */
1724  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1725  res = SWIG_Python_CallFunctor(destroy, tmp);
1726  Py_DECREF(tmp);
1727  } else {
1728  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1729  PyObject *mself = PyCFunction_GET_SELF(destroy);
1730  res = ((*meth)(mself, v));
1731  }
1732  if (!res)
1733  PyErr_WriteUnraisable(destroy);
1734 
1735  PyErr_Restore(val, type, tb);
1736 
1737  Py_XDECREF(res);
1738  }
1739 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1740  else {
1741  const char *name = SWIG_TypePrettyName(ty);
1742  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1743  }
1744 #endif
1745  }
1746  Py_XDECREF(next);
1747  PyObject_DEL(v);
1748 }
1749 
1750 SWIGRUNTIME PyObject*
1751 SwigPyObject_append(PyObject* v, PyObject* next)
1752 {
1753  SwigPyObject *sobj = (SwigPyObject *) v;
1754 #ifndef METH_O
1755  PyObject *tmp = 0;
1756  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1757  next = tmp;
1758 #endif
1759  if (!SwigPyObject_Check(next)) {
1760  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1761  return NULL;
1762  }
1763  sobj->next = next;
1764  Py_INCREF(next);
1765  return SWIG_Py_Void();
1766 }
1767 
1768 SWIGRUNTIME PyObject*
1769 #ifdef METH_NOARGS
1770 SwigPyObject_next(PyObject* v)
1771 #else
1772 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1773 #endif
1774 {
1775  SwigPyObject *sobj = (SwigPyObject *) v;
1776  if (sobj->next) {
1777  Py_INCREF(sobj->next);
1778  return sobj->next;
1779  } else {
1780  return SWIG_Py_Void();
1781  }
1782 }
1783 
1784 SWIGINTERN PyObject*
1785 #ifdef METH_NOARGS
1786 SwigPyObject_disown(PyObject *v)
1787 #else
1788 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1789 #endif
1790 {
1791  SwigPyObject *sobj = (SwigPyObject *)v;
1792  sobj->own = 0;
1793  return SWIG_Py_Void();
1794 }
1795 
1796 SWIGINTERN PyObject*
1797 #ifdef METH_NOARGS
1798 SwigPyObject_acquire(PyObject *v)
1799 #else
1800 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1801 #endif
1802 {
1803  SwigPyObject *sobj = (SwigPyObject *)v;
1804  sobj->own = SWIG_POINTER_OWN;
1805  return SWIG_Py_Void();
1806 }
1807 
1808 SWIGINTERN PyObject*
1809 SwigPyObject_own(PyObject *v, PyObject *args)
1810 {
1811  PyObject *val = 0;
1812 #if (PY_VERSION_HEX < 0x02020000)
1813  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1814 #elif (PY_VERSION_HEX < 0x02050000)
1815  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1816 #else
1817  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1818 #endif
1819  {
1820  return NULL;
1821  }
1822  else
1823  {
1824  SwigPyObject *sobj = (SwigPyObject *)v;
1825  PyObject *obj = PyBool_FromLong(sobj->own);
1826  if (val) {
1827 #ifdef METH_NOARGS
1828  if (PyObject_IsTrue(val)) {
1829  SwigPyObject_acquire(v);
1830  } else {
1831  SwigPyObject_disown(v);
1832  }
1833 #else
1834  if (PyObject_IsTrue(val)) {
1835  SwigPyObject_acquire(v,args);
1836  } else {
1837  SwigPyObject_disown(v,args);
1838  }
1839 #endif
1840  }
1841  return obj;
1842  }
1843 }
1844 
1845 #ifdef METH_O
1846 static PyMethodDef
1847 swigobject_methods[] = {
1848  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1849  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1850  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1851  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1852  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1853  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1854  {0, 0, 0, 0}
1855 };
1856 #else
1857 static PyMethodDef
1858 swigobject_methods[] = {
1859  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1860  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1861  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1862  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1863  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1864  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1865  {0, 0, 0, 0}
1866 };
1867 #endif
1868 
1869 #if PY_VERSION_HEX < 0x02020000
1870 SWIGINTERN PyObject *
1871 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1872 {
1873  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1874 }
1875 #endif
1876 
1877 SWIGRUNTIME PyTypeObject*
1878 SwigPyObject_TypeOnce(void) {
1879  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1880 
1881  static PyNumberMethods SwigPyObject_as_number = {
1882  (binaryfunc)0, /*nb_add*/
1883  (binaryfunc)0, /*nb_subtract*/
1884  (binaryfunc)0, /*nb_multiply*/
1885  /* nb_divide removed in Python 3 */
1886 #if PY_VERSION_HEX < 0x03000000
1887  (binaryfunc)0, /*nb_divide*/
1888 #endif
1889  (binaryfunc)0, /*nb_remainder*/
1890  (binaryfunc)0, /*nb_divmod*/
1891  (ternaryfunc)0,/*nb_power*/
1892  (unaryfunc)0, /*nb_negative*/
1893  (unaryfunc)0, /*nb_positive*/
1894  (unaryfunc)0, /*nb_absolute*/
1895  (inquiry)0, /*nb_nonzero*/
1896  0, /*nb_invert*/
1897  0, /*nb_lshift*/
1898  0, /*nb_rshift*/
1899  0, /*nb_and*/
1900  0, /*nb_xor*/
1901  0, /*nb_or*/
1902 #if PY_VERSION_HEX < 0x03000000
1903  0, /*nb_coerce*/
1904 #endif
1905  (unaryfunc)SwigPyObject_long, /*nb_int*/
1906 #if PY_VERSION_HEX < 0x03000000
1907  (unaryfunc)SwigPyObject_long, /*nb_long*/
1908 #else
1909  0, /*nb_reserved*/
1910 #endif
1911  (unaryfunc)0, /*nb_float*/
1912 #if PY_VERSION_HEX < 0x03000000
1913  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1914  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1915 #endif
1916 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1917  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1918 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1919  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1920 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1921  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1922 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1923  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1924 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1925  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1926 #endif
1927  };
1928 
1929  static PyTypeObject swigpyobject_type;
1930  static int type_init = 0;
1931  if (!type_init) {
1932  const PyTypeObject tmp = {
1933 #if PY_VERSION_HEX >= 0x03000000
1934  PyVarObject_HEAD_INIT(NULL, 0)
1935 #else
1936  PyObject_HEAD_INIT(NULL)
1937  0, /* ob_size */
1938 #endif
1939  (char *)"SwigPyObject", /* tp_name */
1940  sizeof(SwigPyObject), /* tp_basicsize */
1941  0, /* tp_itemsize */
1942  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1943  0, /* tp_print */
1944 #if PY_VERSION_HEX < 0x02020000
1945  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1946 #else
1947  (getattrfunc)0, /* tp_getattr */
1948 #endif
1949  (setattrfunc)0, /* tp_setattr */
1950 #if PY_VERSION_HEX >= 0x03000000
1951  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1952 #else
1953  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1954 #endif
1955  (reprfunc)SwigPyObject_repr, /* tp_repr */
1956  &SwigPyObject_as_number, /* tp_as_number */
1957  0, /* tp_as_sequence */
1958  0, /* tp_as_mapping */
1959  (hashfunc)0, /* tp_hash */
1960  (ternaryfunc)0, /* tp_call */
1961  0, /* tp_str */
1962  PyObject_GenericGetAttr, /* tp_getattro */
1963  0, /* tp_setattro */
1964  0, /* tp_as_buffer */
1965  Py_TPFLAGS_DEFAULT, /* tp_flags */
1966  swigobject_doc, /* tp_doc */
1967  0, /* tp_traverse */
1968  0, /* tp_clear */
1969  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1970  0, /* tp_weaklistoffset */
1971 #if PY_VERSION_HEX >= 0x02020000
1972  0, /* tp_iter */
1973  0, /* tp_iternext */
1974  swigobject_methods, /* tp_methods */
1975  0, /* tp_members */
1976  0, /* tp_getset */
1977  0, /* tp_base */
1978  0, /* tp_dict */
1979  0, /* tp_descr_get */
1980  0, /* tp_descr_set */
1981  0, /* tp_dictoffset */
1982  0, /* tp_init */
1983  0, /* tp_alloc */
1984  0, /* tp_new */
1985  0, /* tp_free */
1986  0, /* tp_is_gc */
1987  0, /* tp_bases */
1988  0, /* tp_mro */
1989  0, /* tp_cache */
1990  0, /* tp_subclasses */
1991  0, /* tp_weaklist */
1992 #endif
1993 #if PY_VERSION_HEX >= 0x02030000
1994  0, /* tp_del */
1995 #endif
1996 #if PY_VERSION_HEX >= 0x02060000
1997  0, /* tp_version_tag */
1998 #endif
1999 #if PY_VERSION_HEX >= 0x03040000
2000  0, /* tp_finalize */
2001 #endif
2002 #ifdef COUNT_ALLOCS
2003  0, /* tp_allocs */
2004  0, /* tp_frees */
2005  0, /* tp_maxalloc */
2006 #if PY_VERSION_HEX >= 0x02050000
2007  0, /* tp_prev */
2008 #endif
2009  0 /* tp_next */
2010 #endif
2011  };
2012  swigpyobject_type = tmp;
2013  type_init = 1;
2014 #if PY_VERSION_HEX < 0x02020000
2015  swigpyobject_type.ob_type = &PyType_Type;
2016 #else
2017  if (PyType_Ready(&swigpyobject_type) < 0)
2018  return NULL;
2019 #endif
2020  }
2021  return &swigpyobject_type;
2022 }
2023 
2024 SWIGRUNTIME PyObject *
2025 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2026 {
2027  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2028  if (sobj) {
2029  sobj->ptr = ptr;
2030  sobj->ty = ty;
2031  sobj->own = own;
2032  sobj->next = 0;
2033  }
2034  return (PyObject *)sobj;
2035 }
2036 
2037 /* -----------------------------------------------------------------------------
2038  * Implements a simple Swig Packed type, and use it instead of string
2039  * ----------------------------------------------------------------------------- */
2040 
2041 typedef struct {
2042  PyObject_HEAD
2043  void *pack;
2044  swig_type_info *ty;
2045  size_t size;
2046 } SwigPyPacked;
2047 
2048 SWIGRUNTIME int
2049 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2050 {
2051  char result[SWIG_BUFFER_SIZE];
2052  fputs("<Swig Packed ", fp);
2053  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2054  fputs("at ", fp);
2055  fputs(result, fp);
2056  }
2057  fputs(v->ty->name,fp);
2058  fputs(">", fp);
2059  return 0;
2060 }
2061 
2062 SWIGRUNTIME PyObject *
2063 SwigPyPacked_repr(SwigPyPacked *v)
2064 {
2065  char result[SWIG_BUFFER_SIZE];
2066  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2067  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2068  } else {
2069  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2070  }
2071 }
2072 
2073 SWIGRUNTIME PyObject *
2074 SwigPyPacked_str(SwigPyPacked *v)
2075 {
2076  char result[SWIG_BUFFER_SIZE];
2077  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2078  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2079  } else {
2080  return SWIG_Python_str_FromChar(v->ty->name);
2081  }
2082 }
2083 
2084 SWIGRUNTIME int
2085 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2086 {
2087  size_t i = v->size;
2088  size_t j = w->size;
2089  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2090  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2091 }
2092 
2093 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2094 
2095 SWIGRUNTIME PyTypeObject*
2096 SwigPyPacked_type(void) {
2097  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2098  return type;
2099 }
2100 
2101 SWIGRUNTIMEINLINE int
2102 SwigPyPacked_Check(PyObject *op) {
2103  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2104  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2105 }
2106 
2107 SWIGRUNTIME void
2108 SwigPyPacked_dealloc(PyObject *v)
2109 {
2110  if (SwigPyPacked_Check(v)) {
2111  SwigPyPacked *sobj = (SwigPyPacked *) v;
2112  free(sobj->pack);
2113  }
2114  PyObject_DEL(v);
2115 }
2116 
2117 SWIGRUNTIME PyTypeObject*
2118 SwigPyPacked_TypeOnce(void) {
2119  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2120  static PyTypeObject swigpypacked_type;
2121  static int type_init = 0;
2122  if (!type_init) {
2123  const PyTypeObject tmp = {
2124 #if PY_VERSION_HEX>=0x03000000
2125  PyVarObject_HEAD_INIT(NULL, 0)
2126 #else
2127  PyObject_HEAD_INIT(NULL)
2128  0, /* ob_size */
2129 #endif
2130  (char *)"SwigPyPacked", /* tp_name */
2131  sizeof(SwigPyPacked), /* tp_basicsize */
2132  0, /* tp_itemsize */
2133  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2134  (printfunc)SwigPyPacked_print, /* tp_print */
2135  (getattrfunc)0, /* tp_getattr */
2136  (setattrfunc)0, /* tp_setattr */
2137 #if PY_VERSION_HEX>=0x03000000
2138  0, /* tp_reserved in 3.0.1 */
2139 #else
2140  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2141 #endif
2142  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2143  0, /* tp_as_number */
2144  0, /* tp_as_sequence */
2145  0, /* tp_as_mapping */
2146  (hashfunc)0, /* tp_hash */
2147  (ternaryfunc)0, /* tp_call */
2148  (reprfunc)SwigPyPacked_str, /* tp_str */
2149  PyObject_GenericGetAttr, /* tp_getattro */
2150  0, /* tp_setattro */
2151  0, /* tp_as_buffer */
2152  Py_TPFLAGS_DEFAULT, /* tp_flags */
2153  swigpacked_doc, /* tp_doc */
2154  0, /* tp_traverse */
2155  0, /* tp_clear */
2156  0, /* tp_richcompare */
2157  0, /* tp_weaklistoffset */
2158 #if PY_VERSION_HEX >= 0x02020000
2159  0, /* tp_iter */
2160  0, /* tp_iternext */
2161  0, /* tp_methods */
2162  0, /* tp_members */
2163  0, /* tp_getset */
2164  0, /* tp_base */
2165  0, /* tp_dict */
2166  0, /* tp_descr_get */
2167  0, /* tp_descr_set */
2168  0, /* tp_dictoffset */
2169  0, /* tp_init */
2170  0, /* tp_alloc */
2171  0, /* tp_new */
2172  0, /* tp_free */
2173  0, /* tp_is_gc */
2174  0, /* tp_bases */
2175  0, /* tp_mro */
2176  0, /* tp_cache */
2177  0, /* tp_subclasses */
2178  0, /* tp_weaklist */
2179 #endif
2180 #if PY_VERSION_HEX >= 0x02030000
2181  0, /* tp_del */
2182 #endif
2183 #if PY_VERSION_HEX >= 0x02060000
2184  0, /* tp_version_tag */
2185 #endif
2186 #if PY_VERSION_HEX >= 0x03040000
2187  0, /* tp_finalize */
2188 #endif
2189 #ifdef COUNT_ALLOCS
2190  0, /* tp_allocs */
2191  0, /* tp_frees */
2192  0, /* tp_maxalloc */
2193 #if PY_VERSION_HEX >= 0x02050000
2194  0, /* tp_prev */
2195 #endif
2196  0 /* tp_next */
2197 #endif
2198  };
2199  swigpypacked_type = tmp;
2200  type_init = 1;
2201 #if PY_VERSION_HEX < 0x02020000
2202  swigpypacked_type.ob_type = &PyType_Type;
2203 #else
2204  if (PyType_Ready(&swigpypacked_type) < 0)
2205  return NULL;
2206 #endif
2207  }
2208  return &swigpypacked_type;
2209 }
2210 
2211 SWIGRUNTIME PyObject *
2212 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2213 {
2214  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2215  if (sobj) {
2216  void *pack = malloc(size);
2217  if (pack) {
2218  memcpy(pack, ptr, size);
2219  sobj->pack = pack;
2220  sobj->ty = ty;
2221  sobj->size = size;
2222  } else {
2223  PyObject_DEL((PyObject *) sobj);
2224  sobj = 0;
2225  }
2226  }
2227  return (PyObject *) sobj;
2228 }
2229 
2230 SWIGRUNTIME swig_type_info *
2231 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2232 {
2233  if (SwigPyPacked_Check(obj)) {
2234  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2235  if (sobj->size != size) return 0;
2236  memcpy(ptr, sobj->pack, size);
2237  return sobj->ty;
2238  } else {
2239  return 0;
2240  }
2241 }
2242 
2243 /* -----------------------------------------------------------------------------
2244  * pointers/data manipulation
2245  * ----------------------------------------------------------------------------- */
2246 
2247 SWIGRUNTIMEINLINE PyObject *
2248 _SWIG_This(void)
2249 {
2250  return SWIG_Python_str_FromChar("this");
2251 }
2252 
2253 static PyObject *swig_this = NULL;
2254 
2255 SWIGRUNTIME PyObject *
2256 SWIG_This(void)
2257 {
2258  if (swig_this == NULL)
2259  swig_this = _SWIG_This();
2260  return swig_this;
2261 }
2262 
2263 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2264 
2265 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2266 #if PY_VERSION_HEX>=0x03000000
2267 #define SWIG_PYTHON_SLOW_GETSET_THIS
2268 #endif
2269 
2270 SWIGRUNTIME SwigPyObject *
2271 SWIG_Python_GetSwigThis(PyObject *pyobj)
2272 {
2273  PyObject *obj;
2274 
2275  if (SwigPyObject_Check(pyobj))
2276  return (SwigPyObject *) pyobj;
2277 
2278 #ifdef SWIGPYTHON_BUILTIN
2279  (void)obj;
2280 # ifdef PyWeakref_CheckProxy
2281  if (PyWeakref_CheckProxy(pyobj)) {
2282  pyobj = PyWeakref_GET_OBJECT(pyobj);
2283  if (pyobj && SwigPyObject_Check(pyobj))
2284  return (SwigPyObject*) pyobj;
2285  }
2286 # endif
2287  return NULL;
2288 #else
2289 
2290  obj = 0;
2291 
2292 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2293  if (PyInstance_Check(pyobj)) {
2294  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2295  } else {
2296  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2297  if (dictptr != NULL) {
2298  PyObject *dict = *dictptr;
2299  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2300  } else {
2301 #ifdef PyWeakref_CheckProxy
2302  if (PyWeakref_CheckProxy(pyobj)) {
2303  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2304  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2305  }
2306 #endif
2307  obj = PyObject_GetAttr(pyobj,SWIG_This());
2308  if (obj) {
2309  Py_DECREF(obj);
2310  } else {
2311  if (PyErr_Occurred()) PyErr_Clear();
2312  return 0;
2313  }
2314  }
2315  }
2316 #else
2317  obj = PyObject_GetAttr(pyobj,SWIG_This());
2318  if (obj) {
2319  Py_DECREF(obj);
2320  } else {
2321  if (PyErr_Occurred()) PyErr_Clear();
2322  return 0;
2323  }
2324 #endif
2325  if (obj && !SwigPyObject_Check(obj)) {
2326  /* a PyObject is called 'this', try to get the 'real this'
2327  SwigPyObject from it */
2328  return SWIG_Python_GetSwigThis(obj);
2329  }
2330  return (SwigPyObject *)obj;
2331 #endif
2332 }
2333 
2334 /* Acquire a pointer value */
2335 
2336 SWIGRUNTIME int
2337 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2338  if (own == SWIG_POINTER_OWN) {
2339  SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2340  if (sobj) {
2341  int oldown = sobj->own;
2342  sobj->own = own;
2343  return oldown;
2344  }
2345  }
2346  return 0;
2347 }
2348 
2349 /* Convert a pointer value */
2350 
2351 SWIGRUNTIME int
2352 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2353  int res;
2354  SwigPyObject *sobj;
2355  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2356 
2357  if (!obj)
2358  return SWIG_ERROR;
2359  if (obj == Py_None && !implicit_conv) {
2360  if (ptr)
2361  *ptr = 0;
2362  return SWIG_OK;
2363  }
2364 
2365  res = SWIG_ERROR;
2366 
2367  sobj = SWIG_Python_GetSwigThis(obj);
2368  if (own)
2369  *own = 0;
2370  while (sobj) {
2371  void *vptr = sobj->ptr;
2372  if (ty) {
2373  swig_type_info *to = sobj->ty;
2374  if (to == ty) {
2375  /* no type cast needed */
2376  if (ptr) *ptr = vptr;
2377  break;
2378  } else {
2379  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2380  if (!tc) {
2381  sobj = (SwigPyObject *)sobj->next;
2382  } else {
2383  if (ptr) {
2384  int newmemory = 0;
2385  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2386  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2387  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2388  if (own)
2389  *own = *own | SWIG_CAST_NEW_MEMORY;
2390  }
2391  }
2392  break;
2393  }
2394  }
2395  } else {
2396  if (ptr) *ptr = vptr;
2397  break;
2398  }
2399  }
2400  if (sobj) {
2401  if (own)
2402  *own = *own | sobj->own;
2403  if (flags & SWIG_POINTER_DISOWN) {
2404  sobj->own = 0;
2405  }
2406  res = SWIG_OK;
2407  } else {
2408  if (implicit_conv) {
2409  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2410  if (data && !data->implicitconv) {
2411  PyObject *klass = data->klass;
2412  if (klass) {
2413  PyObject *impconv;
2414  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2415  impconv = SWIG_Python_CallFunctor(klass, obj);
2416  data->implicitconv = 0;
2417  if (PyErr_Occurred()) {
2418  PyErr_Clear();
2419  impconv = 0;
2420  }
2421  if (impconv) {
2422  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2423  if (iobj) {
2424  void *vptr;
2425  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2426  if (SWIG_IsOK(res)) {
2427  if (ptr) {
2428  *ptr = vptr;
2429  /* transfer the ownership to 'ptr' */
2430  iobj->own = 0;
2431  res = SWIG_AddCast(res);
2432  res = SWIG_AddNewMask(res);
2433  } else {
2434  res = SWIG_AddCast(res);
2435  }
2436  }
2437  }
2438  Py_DECREF(impconv);
2439  }
2440  }
2441  }
2442  }
2443  if (!SWIG_IsOK(res) && obj == Py_None) {
2444  if (ptr)
2445  *ptr = 0;
2446  if (PyErr_Occurred())
2447  PyErr_Clear();
2448  res = SWIG_OK;
2449  }
2450  }
2451  return res;
2452 }
2453 
2454 /* Convert a function ptr value */
2455 
2456 SWIGRUNTIME int
2457 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2458  if (!PyCFunction_Check(obj)) {
2459  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2460  } else {
2461  void *vptr = 0;
2462  swig_cast_info *tc;
2463 
2464  /* here we get the method pointer for callbacks */
2465  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2466  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2467  if (desc)
2468  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2469  if (!desc)
2470  return SWIG_ERROR;
2471  tc = SWIG_TypeCheck(desc,ty);
2472  if (tc) {
2473  int newmemory = 0;
2474  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2475  assert(!newmemory); /* newmemory handling not yet implemented */
2476  } else {
2477  return SWIG_ERROR;
2478  }
2479  return SWIG_OK;
2480  }
2481 }
2482 
2483 /* Convert a packed pointer value */
2484 
2485 SWIGRUNTIME int
2486 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2487  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2488  if (!to) return SWIG_ERROR;
2489  if (ty) {
2490  if (to != ty) {
2491  /* check type cast? */
2492  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2493  if (!tc) return SWIG_ERROR;
2494  }
2495  }
2496  return SWIG_OK;
2497 }
2498 
2499 /* -----------------------------------------------------------------------------
2500  * Create a new pointer object
2501  * ----------------------------------------------------------------------------- */
2502 
2503 /*
2504  Create a new instance object, without calling __init__, and set the
2505  'this' attribute.
2506 */
2507 
2508 SWIGRUNTIME PyObject*
2509 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2510 {
2511 #if (PY_VERSION_HEX >= 0x02020000)
2512  PyObject *inst = 0;
2513  PyObject *newraw = data->newraw;
2514  if (newraw) {
2515  inst = PyObject_Call(newraw, data->newargs, NULL);
2516  if (inst) {
2517 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2518  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2519  if (dictptr != NULL) {
2520  PyObject *dict = *dictptr;
2521  if (dict == NULL) {
2522  dict = PyDict_New();
2523  *dictptr = dict;
2524  PyDict_SetItem(dict, SWIG_This(), swig_this);
2525  }
2526  }
2527 #else
2528  PyObject *key = SWIG_This();
2529  PyObject_SetAttr(inst, key, swig_this);
2530 #endif
2531  }
2532  } else {
2533 #if PY_VERSION_HEX >= 0x03000000
2534  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2535  if (inst) {
2536  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2537  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2538  }
2539 #else
2540  PyObject *dict = PyDict_New();
2541  if (dict) {
2542  PyDict_SetItem(dict, SWIG_This(), swig_this);
2543  inst = PyInstance_NewRaw(data->newargs, dict);
2544  Py_DECREF(dict);
2545  }
2546 #endif
2547  }
2548  return inst;
2549 #else
2550 #if (PY_VERSION_HEX >= 0x02010000)
2551  PyObject *inst = 0;
2552  PyObject *dict = PyDict_New();
2553  if (dict) {
2554  PyDict_SetItem(dict, SWIG_This(), swig_this);
2555  inst = PyInstance_NewRaw(data->newargs, dict);
2556  Py_DECREF(dict);
2557  }
2558  return (PyObject *) inst;
2559 #else
2560  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2561  if (inst == NULL) {
2562  return NULL;
2563  }
2564  inst->in_class = (PyClassObject *)data->newargs;
2565  Py_INCREF(inst->in_class);
2566  inst->in_dict = PyDict_New();
2567  if (inst->in_dict == NULL) {
2568  Py_DECREF(inst);
2569  return NULL;
2570  }
2571 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2572  inst->in_weakreflist = NULL;
2573 #endif
2574 #ifdef Py_TPFLAGS_GC
2575  PyObject_GC_Init(inst);
2576 #endif
2577  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2578  return (PyObject *) inst;
2579 #endif
2580 #endif
2581 }
2582 
2583 SWIGRUNTIME void
2584 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2585 {
2586  PyObject *dict;
2587 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2588  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2589  if (dictptr != NULL) {
2590  dict = *dictptr;
2591  if (dict == NULL) {
2592  dict = PyDict_New();
2593  *dictptr = dict;
2594  }
2595  PyDict_SetItem(dict, SWIG_This(), swig_this);
2596  return;
2597  }
2598 #endif
2599  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2600  PyDict_SetItem(dict, SWIG_This(), swig_this);
2601  Py_DECREF(dict);
2602 }
2603 
2604 
2605 SWIGINTERN PyObject *
2606 SWIG_Python_InitShadowInstance(PyObject *args) {
2607  PyObject *obj[2];
2608  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2609  return NULL;
2610  } else {
2611  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2612  if (sthis) {
2613  SwigPyObject_append((PyObject*) sthis, obj[1]);
2614  } else {
2615  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2616  }
2617  return SWIG_Py_Void();
2618  }
2619 }
2620 
2621 /* Create a new pointer object */
2622 
2623 SWIGRUNTIME PyObject *
2624 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2625  SwigPyClientData *clientdata;
2626  PyObject * robj;
2627  int own;
2628 
2629  if (!ptr)
2630  return SWIG_Py_Void();
2631 
2632  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2633  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2634  if (clientdata && clientdata->pytype) {
2635  SwigPyObject *newobj;
2636  if (flags & SWIG_BUILTIN_TP_INIT) {
2637  newobj = (SwigPyObject*) self;
2638  if (newobj->ptr) {
2639  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2640  while (newobj->next)
2641  newobj = (SwigPyObject *) newobj->next;
2642  newobj->next = next_self;
2643  newobj = (SwigPyObject *)next_self;
2644 #ifdef SWIGPYTHON_BUILTIN
2645  newobj->dict = 0;
2646 #endif
2647  }
2648  } else {
2649  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2650 #ifdef SWIGPYTHON_BUILTIN
2651  newobj->dict = 0;
2652 #endif
2653  }
2654  if (newobj) {
2655  newobj->ptr = ptr;
2656  newobj->ty = type;
2657  newobj->own = own;
2658  newobj->next = 0;
2659  return (PyObject*) newobj;
2660  }
2661  return SWIG_Py_Void();
2662  }
2663 
2664  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2665 
2666  robj = SwigPyObject_New(ptr, type, own);
2667  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2668  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2669  Py_DECREF(robj);
2670  robj = inst;
2671  }
2672  return robj;
2673 }
2674 
2675 /* Create a new packed object */
2676 
2677 SWIGRUNTIMEINLINE PyObject *
2678 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2679  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2680 }
2681 
2682 /* -----------------------------------------------------------------------------*
2683  * Get type list
2684  * -----------------------------------------------------------------------------*/
2685 
2686 #ifdef SWIG_LINK_RUNTIME
2687 void *SWIG_ReturnGlobalTypeList(void *);
2688 #endif
2689 
2690 SWIGRUNTIME swig_module_info *
2691 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2692  static void *type_pointer = (void *)0;
2693  /* first check if module already created */
2694  if (!type_pointer) {
2695 #ifdef SWIG_LINK_RUNTIME
2696  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2697 #else
2698 # ifdef SWIGPY_USE_CAPSULE
2699  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2700 # else
2701  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2702  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2703 # endif
2704  if (PyErr_Occurred()) {
2705  PyErr_Clear();
2706  type_pointer = (void *)0;
2707  }
2708 #endif
2709  }
2710  return (swig_module_info *) type_pointer;
2711 }
2712 
2713 #if PY_MAJOR_VERSION < 2
2714 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2715  is copied out of Python/modsupport.c in python version 2.3.4 */
2716 SWIGINTERN int
2717 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2718 {
2719  PyObject *dict;
2720  if (!PyModule_Check(m)) {
2721  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2722  return SWIG_ERROR;
2723  }
2724  if (!o) {
2725  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2726  return SWIG_ERROR;
2727  }
2728 
2729  dict = PyModule_GetDict(m);
2730  if (dict == NULL) {
2731  /* Internal error -- modules must have a dict! */
2732  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2733  PyModule_GetName(m));
2734  return SWIG_ERROR;
2735  }
2736  if (PyDict_SetItemString(dict, name, o))
2737  return SWIG_ERROR;
2738  Py_DECREF(o);
2739  return SWIG_OK;
2740 }
2741 #endif
2742 
2743 SWIGRUNTIME void
2744 #ifdef SWIGPY_USE_CAPSULE
2745 SWIG_Python_DestroyModule(PyObject *obj)
2746 #else
2747 SWIG_Python_DestroyModule(void *vptr)
2748 #endif
2749 {
2750 #ifdef SWIGPY_USE_CAPSULE
2751  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2752 #else
2753  swig_module_info *swig_module = (swig_module_info *) vptr;
2754 #endif
2755  swig_type_info **types = swig_module->types;
2756  size_t i;
2757  for (i =0; i < swig_module->size; ++i) {
2758  swig_type_info *ty = types[i];
2759  if (ty->owndata) {
2760  SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2761  if (data) SwigPyClientData_Del(data);
2762  }
2763  }
2764  Py_DECREF(SWIG_This());
2765  swig_this = NULL;
2766 }
2767 
2768 SWIGRUNTIME void
2769 SWIG_Python_SetModule(swig_module_info *swig_module) {
2770 #if PY_VERSION_HEX >= 0x03000000
2771  /* Add a dummy module object into sys.modules */
2772  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2773 #else
2774  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2775  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2776 #endif
2777 #ifdef SWIGPY_USE_CAPSULE
2778  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2779  if (pointer && module) {
2780  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2781  } else {
2782  Py_XDECREF(pointer);
2783  }
2784 #else
2785  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2786  if (pointer && module) {
2787  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2788  } else {
2789  Py_XDECREF(pointer);
2790  }
2791 #endif
2792 }
2793 
2794 /* The python cached type query */
2795 SWIGRUNTIME PyObject *
2796 SWIG_Python_TypeCache(void) {
2797  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2798  return cache;
2799 }
2800 
2801 SWIGRUNTIME swig_type_info *
2802 SWIG_Python_TypeQuery(const char *type)
2803 {
2804  PyObject *cache = SWIG_Python_TypeCache();
2805  PyObject *key = SWIG_Python_str_FromChar(type);
2806  PyObject *obj = PyDict_GetItem(cache, key);
2807  swig_type_info *descriptor;
2808  if (obj) {
2809 #ifdef SWIGPY_USE_CAPSULE
2810  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2811 #else
2812  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2813 #endif
2814  } else {
2815  swig_module_info *swig_module = SWIG_GetModule(0);
2816  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2817  if (descriptor) {
2818 #ifdef SWIGPY_USE_CAPSULE
2819  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2820 #else
2821  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2822 #endif
2823  PyDict_SetItem(cache, key, obj);
2824  Py_DECREF(obj);
2825  }
2826  }
2827  Py_DECREF(key);
2828  return descriptor;
2829 }
2830 
2831 /*
2832  For backward compatibility only
2833 */
2834 #define SWIG_POINTER_EXCEPTION 0
2835 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2836 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2837 
2838 SWIGRUNTIME int
2839 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2840 {
2841  if (PyErr_Occurred()) {
2842  PyObject *type = 0;
2843  PyObject *value = 0;
2844  PyObject *traceback = 0;
2845  PyErr_Fetch(&type, &value, &traceback);
2846  if (value) {
2847  PyObject *old_str = PyObject_Str(value);
2848  const char *tmp = SWIG_Python_str_AsChar(old_str);
2849  if (!tmp)
2850  tmp = "Invalid error message";
2851  Py_XINCREF(type);
2852  PyErr_Clear();
2853  if (infront) {
2854  PyErr_Format(type, "%s %s", mesg, tmp);
2855  } else {
2856  PyErr_Format(type, "%s %s", tmp, mesg);
2857  }
2858  SWIG_Python_str_DelForPy3(tmp);
2859  Py_DECREF(old_str);
2860  }
2861  return 1;
2862  } else {
2863  return 0;
2864  }
2865 }
2866 
2867 SWIGRUNTIME int
2868 SWIG_Python_ArgFail(int argnum)
2869 {
2870  if (PyErr_Occurred()) {
2871  /* add information about failing argument */
2872  char mesg[256];
2873  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2874  return SWIG_Python_AddErrMesg(mesg, 1);
2875  } else {
2876  return 0;
2877  }
2878 }
2879 
2880 SWIGRUNTIMEINLINE const char *
2881 SwigPyObject_GetDesc(PyObject *self)
2882 {
2883  SwigPyObject *v = (SwigPyObject *)self;
2884  swig_type_info *ty = v ? v->ty : 0;
2885  return ty ? ty->str : "";
2886 }
2887 
2888 SWIGRUNTIME void
2889 SWIG_Python_TypeError(const char *type, PyObject *obj)
2890 {
2891  if (type) {
2892 #if defined(SWIG_COBJECT_TYPES)
2893  if (obj && SwigPyObject_Check(obj)) {
2894  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2895  if (otype) {
2896  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2897  type, otype);
2898  return;
2899  }
2900  } else
2901 #endif
2902  {
2903  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2904  if (otype) {
2905  PyObject *str = PyObject_Str(obj);
2906  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2907  if (cstr) {
2908  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2909  type, otype, cstr);
2910  SWIG_Python_str_DelForPy3(cstr);
2911  } else {
2912  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2913  type, otype);
2914  }
2915  Py_XDECREF(str);
2916  return;
2917  }
2918  }
2919  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2920  } else {
2921  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2922  }
2923 }
2924 
2925 
2926 /* Convert a pointer value, signal an exception on a type mismatch */
2927 SWIGRUNTIME void *
2928 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2929  void *result;
2930  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2931  PyErr_Clear();
2932 #if SWIG_POINTER_EXCEPTION
2933  if (flags) {
2934  SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2935  SWIG_Python_ArgFail(argnum);
2936  }
2937 #endif
2938  }
2939  return result;
2940 }
2941 
2942 #ifdef SWIGPYTHON_BUILTIN
2943 SWIGRUNTIME int
2944 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2945  PyTypeObject *tp = obj->ob_type;
2946  PyObject *descr;
2947  PyObject *encoded_name;
2948  descrsetfunc f;
2949  int res = -1;
2950 
2951 # ifdef Py_USING_UNICODE
2952  if (PyString_Check(name)) {
2953  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2954  if (!name)
2955  return -1;
2956  } else if (!PyUnicode_Check(name))
2957 # else
2958  if (!PyString_Check(name))
2959 # endif
2960  {
2961  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2962  return -1;
2963  } else {
2964  Py_INCREF(name);
2965  }
2966 
2967  if (!tp->tp_dict) {
2968  if (PyType_Ready(tp) < 0)
2969  goto done;
2970  }
2971 
2972  descr = _PyType_Lookup(tp, name);
2973  f = NULL;
2974  if (descr != NULL)
2975  f = descr->ob_type->tp_descr_set;
2976  if (!f) {
2977  if (PyString_Check(name)) {
2978  encoded_name = name;
2979  Py_INCREF(name);
2980  } else {
2981  encoded_name = PyUnicode_AsUTF8String(name);
2982  if (!encoded_name)
2983  return -1;
2984  }
2985  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2986  Py_DECREF(encoded_name);
2987  } else {
2988  res = f(descr, obj, value);
2989  }
2990 
2991  done:
2992  Py_DECREF(name);
2993  return res;
2994 }
2995 #endif
2996 
2997 
2998 #ifdef __cplusplus
2999 }
3000 #endif
3001 
3002 
3003 
3004 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3005 
3006 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3007 
3008 
3009 
3010  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3011 
3012 
3013 /* -------- TYPES TABLE (BEGIN) -------- */
3014 
3015 #define SWIGTYPE_p_ProSHADE__ProSHADE swig_types[0]
3016 #define SWIGTYPE_p_ProSHADE__ProSHADE_settings swig_types[1]
3017 #define SWIGTYPE_p_a_2__double swig_types[2]
3018 #define SWIGTYPE_p_allocator_type swig_types[3]
3019 #define SWIGTYPE_p_char swig_types[4]
3020 #define SWIGTYPE_p_difference_type swig_types[5]
3021 #define SWIGTYPE_p_p_PyObject swig_types[6]
3022 #define SWIGTYPE_p_p_char swig_types[7]
3023 #define SWIGTYPE_p_size_type swig_types[8]
3024 #define SWIGTYPE_p_std__allocatorT_double_t swig_types[9]
3025 #define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[10]
3026 #define SWIGTYPE_p_std__invalid_argument swig_types[11]
3027 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[12]
3028 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[13]
3029 #define SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t swig_types[14]
3030 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[15]
3031 #define SWIGTYPE_p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t swig_types[16]
3032 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[17]
3033 #define SWIGTYPE_p_value_type swig_types[18]
3034 static swig_type_info *swig_types[20];
3035 static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0};
3036 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3037 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3038 
3039 /* -------- TYPES TABLE (END) -------- */
3040 
3041 #if (PY_VERSION_HEX <= 0x02000000)
3042 # if !defined(SWIG_PYTHON_CLASSIC)
3043 # error "This python version requires swig to be run with the '-classic' option"
3044 # endif
3045 #endif
3046 
3047 /*-----------------------------------------------
3048  @(target):= _proshade.so
3049  ------------------------------------------------*/
3050 #if PY_VERSION_HEX >= 0x03000000
3051 # define SWIG_init PyInit__proshade
3052 
3053 #else
3054 # define SWIG_init init_proshade
3055 
3056 #endif
3057 #define SWIG_name "_proshade"
3058 
3059 #define SWIGVERSION 0x040000
3060 #define SWIG_VERSION SWIGVERSION
3061 
3062 
3063 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3064 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3065 
3066 
3067 #include <stdexcept>
3068 
3069 
3070 namespace swig {
3072  protected:
3073  PyObject *_obj;
3074 
3075  public:
3076  SwigPtr_PyObject() :_obj(0)
3077  {
3078  }
3079 
3080  SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
3081  {
3082  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3083  Py_XINCREF(_obj);
3084  SWIG_PYTHON_THREAD_END_BLOCK;
3085  }
3086 
3087  SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
3088  {
3089  if (initial_ref) {
3090  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3091  Py_XINCREF(_obj);
3092  SWIG_PYTHON_THREAD_END_BLOCK;
3093  }
3094  }
3095 
3096  SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
3097  {
3098  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3099  Py_XINCREF(item._obj);
3100  Py_XDECREF(_obj);
3101  _obj = item._obj;
3102  SWIG_PYTHON_THREAD_END_BLOCK;
3103  return *this;
3104  }
3105 
3106  ~SwigPtr_PyObject()
3107  {
3108  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3109  Py_XDECREF(_obj);
3110  SWIG_PYTHON_THREAD_END_BLOCK;
3111  }
3112 
3113  operator PyObject *() const
3114  {
3115  return _obj;
3116  }
3117 
3118  PyObject *operator->() const
3119  {
3120  return _obj;
3121  }
3122  };
3123 }
3124 
3125 
3126 namespace swig {
3128  SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
3129 
3130  SwigVar_PyObject & operator = (PyObject* obj)
3131  {
3132  Py_XDECREF(_obj);
3133  _obj = obj;
3134  return *this;
3135  }
3136  };
3137 }
3138 
3139 
3140 #include <vector>
3141 #include <string>
3142 #include <memory>
3143 #include "Python.h"
3144 #include "ProSHADE.h"
3145 
3146 
3147 #include <string>
3148 
3149 
3150 #include <iostream>
3151 
3152 #if PY_VERSION_HEX >= 0x03020000
3153 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
3154 #else
3155 # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
3156 #endif
3157 
3158 
3159 #include <typeinfo>
3160 #include <stdexcept>
3161 
3162 
3163 #if defined(__GNUC__)
3164 # if __GNUC__ == 2 && __GNUC_MINOR <= 96
3165 # define SWIG_STD_NOMODERN_STL
3166 # endif
3167 #endif
3168 
3169 
3170 #include <stddef.h>
3171 
3172 
3173 namespace swig {
3175  };
3176 
3178  private:
3179  SwigPtr_PyObject _seq;
3180 
3181  protected:
3182  SwigPyIterator(PyObject *seq) : _seq(seq)
3183  {
3184  }
3185 
3186  public:
3187  virtual ~SwigPyIterator() {}
3188 
3189  // Access iterator method, required by Python
3190  virtual PyObject *value() const = 0;
3191 
3192  // Forward iterator method, required by Python
3193  virtual SwigPyIterator *incr(size_t n = 1) = 0;
3194 
3195  // Backward iterator method, very common in C++, but not required in Python
3196  virtual SwigPyIterator *decr(size_t /*n*/ = 1)
3197  {
3198  throw stop_iteration();
3199  }
3200 
3201  // Random access iterator methods, but not required in Python
3202  virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
3203  {
3204  throw std::invalid_argument("operation not supported");
3205  }
3206 
3207  virtual bool equal (const SwigPyIterator &/*x*/) const
3208  {
3209  throw std::invalid_argument("operation not supported");
3210  }
3211 
3212  // C++ common/needed methods
3213  virtual SwigPyIterator *copy() const = 0;
3214 
3215  PyObject *next()
3216  {
3217  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3218  PyObject *obj = value();
3219  incr();
3220  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3221  return obj;
3222  }
3223 
3224  /* Make an alias for Python 3.x */
3225  PyObject *__next__()
3226  {
3227  return next();
3228  }
3229 
3230  PyObject *previous()
3231  {
3232  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3233  decr();
3234  PyObject *obj = value();
3235  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3236  return obj;
3237  }
3238 
3239  SwigPyIterator *advance(ptrdiff_t n)
3240  {
3241  return (n > 0) ? incr(n) : decr(-n);
3242  }
3243 
3244  bool operator == (const SwigPyIterator& x) const
3245  {
3246  return equal(x);
3247  }
3248 
3249  bool operator != (const SwigPyIterator& x) const
3250  {
3251  return ! operator==(x);
3252  }
3253 
3254  SwigPyIterator& operator += (ptrdiff_t n)
3255  {
3256  return *advance(n);
3257  }
3258 
3259  SwigPyIterator& operator -= (ptrdiff_t n)
3260  {
3261  return *advance(-n);
3262  }
3263 
3264  SwigPyIterator* operator + (ptrdiff_t n) const
3265  {
3266  return copy()->advance(n);
3267  }
3268 
3269  SwigPyIterator* operator - (ptrdiff_t n) const
3270  {
3271  return copy()->advance(-n);
3272  }
3273 
3274  ptrdiff_t operator - (const SwigPyIterator& x) const
3275  {
3276  return x.distance(*this);
3277  }
3278 
3279  static swig_type_info* descriptor() {
3280  static int init = 0;
3281  static swig_type_info* desc = 0;
3282  if (!init) {
3283  desc = SWIG_TypeQuery("swig::SwigPyIterator *");
3284  init = 1;
3285  }
3286  return desc;
3287  }
3288  };
3289 
3290 #if defined(SWIGPYTHON_BUILTIN)
3291  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
3292  {
3293  Py_INCREF(pyself);
3294  return pyself;
3295  }
3296 #endif
3297 }
3298 
3299 
3300 SWIGINTERN int
3301 SWIG_AsVal_double (PyObject *obj, double *val)
3302 {
3303  int res = SWIG_TypeError;
3304  if (PyFloat_Check(obj)) {
3305  if (val) *val = PyFloat_AsDouble(obj);
3306  return SWIG_OK;
3307 #if PY_VERSION_HEX < 0x03000000
3308  } else if (PyInt_Check(obj)) {
3309  if (val) *val = (double) PyInt_AsLong(obj);
3310  return SWIG_OK;
3311 #endif
3312  } else if (PyLong_Check(obj)) {
3313  double v = PyLong_AsDouble(obj);
3314  if (!PyErr_Occurred()) {
3315  if (val) *val = v;
3316  return SWIG_OK;
3317  } else {
3318  PyErr_Clear();
3319  }
3320  }
3321 #ifdef SWIG_PYTHON_CAST_MODE
3322  {
3323  int dispatch = 0;
3324  double d = PyFloat_AsDouble(obj);
3325  if (!PyErr_Occurred()) {
3326  if (val) *val = d;
3327  return SWIG_AddCast(SWIG_OK);
3328  } else {
3329  PyErr_Clear();
3330  }
3331  if (!dispatch) {
3332  long v = PyLong_AsLong(obj);
3333  if (!PyErr_Occurred()) {
3334  if (val) *val = v;
3335  return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3336  } else {
3337  PyErr_Clear();
3338  }
3339  }
3340  }
3341 #endif
3342  return res;
3343 }
3344 
3345 
3346 #include <float.h>
3347 
3348 
3349 #include <math.h>
3350 
3351 
3352 SWIGINTERNINLINE int
3353 SWIG_CanCastAsInteger(double *d, double min, double max) {
3354  double x = *d;
3355  if ((min <= x && x <= max)) {
3356  double fx = floor(x);
3357  double cx = ceil(x);
3358  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3359  if ((errno == EDOM) || (errno == ERANGE)) {
3360  errno = 0;
3361  } else {
3362  double summ, reps, diff;
3363  if (rd < x) {
3364  diff = x - rd;
3365  } else if (rd > x) {
3366  diff = rd - x;
3367  } else {
3368  return 1;
3369  }
3370  summ = rd + x;
3371  reps = diff/summ;
3372  if (reps < 8*DBL_EPSILON) {
3373  *d = rd;
3374  return 1;
3375  }
3376  }
3377  }
3378  return 0;
3379 }
3380 
3381 
3382 SWIGINTERN int
3383 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3384 {
3385 #if PY_VERSION_HEX < 0x03000000
3386  if (PyInt_Check(obj)) {
3387  long v = PyInt_AsLong(obj);
3388  if (v >= 0) {
3389  if (val) *val = v;
3390  return SWIG_OK;
3391  } else {
3392  return SWIG_OverflowError;
3393  }
3394  } else
3395 #endif
3396  if (PyLong_Check(obj)) {
3397  unsigned long v = PyLong_AsUnsignedLong(obj);
3398  if (!PyErr_Occurred()) {
3399  if (val) *val = v;
3400  return SWIG_OK;
3401  } else {
3402  PyErr_Clear();
3403  return SWIG_OverflowError;
3404  }
3405  }
3406 #ifdef SWIG_PYTHON_CAST_MODE
3407  {
3408  int dispatch = 0;
3409  unsigned long v = PyLong_AsUnsignedLong(obj);
3410  if (!PyErr_Occurred()) {
3411  if (val) *val = v;
3412  return SWIG_AddCast(SWIG_OK);
3413  } else {
3414  PyErr_Clear();
3415  }
3416  if (!dispatch) {
3417  double d;
3418  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3419  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3420  if (val) *val = (unsigned long)(d);
3421  return res;
3422  }
3423  }
3424  }
3425 #endif
3426  return SWIG_TypeError;
3427 }
3428 
3429 
3430 #include <limits.h>
3431 #if !defined(SWIG_NO_LLONG_MAX)
3432 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3433 # define LLONG_MAX __LONG_LONG_MAX__
3434 # define LLONG_MIN (-LLONG_MAX - 1LL)
3435 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3436 # endif
3437 #endif
3438 
3439 
3440 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3441 # define SWIG_LONG_LONG_AVAILABLE
3442 #endif
3443 
3444 
3445 #ifdef SWIG_LONG_LONG_AVAILABLE
3446 SWIGINTERN int
3447 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3448 {
3449  int res = SWIG_TypeError;
3450  if (PyLong_Check(obj)) {
3451  unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3452  if (!PyErr_Occurred()) {
3453  if (val) *val = v;
3454  return SWIG_OK;
3455  } else {
3456  PyErr_Clear();
3457  res = SWIG_OverflowError;
3458  }
3459  } else {
3460  unsigned long v;
3461  res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3462  if (SWIG_IsOK(res)) {
3463  if (val) *val = v;
3464  return res;
3465  }
3466  }
3467 #ifdef SWIG_PYTHON_CAST_MODE
3468  {
3469  const double mant_max = 1LL << DBL_MANT_DIG;
3470  double d;
3471  res = SWIG_AsVal_double (obj,&d);
3472  if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
3473  return SWIG_OverflowError;
3474  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3475  if (val) *val = (unsigned long long)(d);
3476  return SWIG_AddCast(res);
3477  }
3478  res = SWIG_TypeError;
3479  }
3480 #endif
3481  return res;
3482 }
3483 #endif
3484 
3485 
3486 SWIGINTERNINLINE int
3487 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3488 {
3489  int res = SWIG_TypeError;
3490 #ifdef SWIG_LONG_LONG_AVAILABLE
3491  if (sizeof(size_t) <= sizeof(unsigned long)) {
3492 #endif
3493  unsigned long v;
3494  res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3495  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3496 #ifdef SWIG_LONG_LONG_AVAILABLE
3497  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3498  unsigned long long v;
3499  res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3500  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3501  }
3502 #endif
3503  return res;
3504 }
3505 
3506 
3507  #define SWIG_From_long PyInt_FromLong
3508 
3509 
3510 #ifdef SWIG_LONG_LONG_AVAILABLE
3511 SWIGINTERNINLINE PyObject*
3512 SWIG_From_long_SS_long (long long value)
3513 {
3514  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
3515  PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
3516 }
3517 #endif
3518 
3519 
3520 SWIGINTERNINLINE PyObject *
3521 SWIG_From_ptrdiff_t (ptrdiff_t value)
3522 {
3523 #ifdef SWIG_LONG_LONG_AVAILABLE
3524  if (sizeof(ptrdiff_t) <= sizeof(long)) {
3525 #endif
3526  return SWIG_From_long (static_cast< long >(value));
3527 #ifdef SWIG_LONG_LONG_AVAILABLE
3528  } else {
3529  /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
3530  return SWIG_From_long_SS_long (static_cast< long long >(value));
3531  }
3532 #endif
3533 }
3534 
3535 
3536 SWIGINTERNINLINE PyObject*
3537  SWIG_From_bool (bool value)
3538 {
3539  return PyBool_FromLong(value ? 1 : 0);
3540 }
3541 
3542 
3543 SWIGINTERN int
3544 SWIG_AsVal_long (PyObject *obj, long* val)
3545 {
3546 #if PY_VERSION_HEX < 0x03000000
3547  if (PyInt_Check(obj)) {
3548  if (val) *val = PyInt_AsLong(obj);
3549  return SWIG_OK;
3550  } else
3551 #endif
3552  if (PyLong_Check(obj)) {
3553  long v = PyLong_AsLong(obj);
3554  if (!PyErr_Occurred()) {
3555  if (val) *val = v;
3556  return SWIG_OK;
3557  } else {
3558  PyErr_Clear();
3559  return SWIG_OverflowError;
3560  }
3561  }
3562 #ifdef SWIG_PYTHON_CAST_MODE
3563  {
3564  int dispatch = 0;
3565  long v = PyInt_AsLong(obj);
3566  if (!PyErr_Occurred()) {
3567  if (val) *val = v;
3568  return SWIG_AddCast(SWIG_OK);
3569  } else {
3570  PyErr_Clear();
3571  }
3572  if (!dispatch) {
3573  double d;
3574  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3575  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3576  if (val) *val = (long)(d);
3577  return res;
3578  }
3579  }
3580  }
3581 #endif
3582  return SWIG_TypeError;
3583 }
3584 
3585 
3586 #ifdef SWIG_LONG_LONG_AVAILABLE
3587 SWIGINTERN int
3588 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
3589 {
3590  int res = SWIG_TypeError;
3591  if (PyLong_Check(obj)) {
3592  long long v = PyLong_AsLongLong(obj);
3593  if (!PyErr_Occurred()) {
3594  if (val) *val = v;
3595  return SWIG_OK;
3596  } else {
3597  PyErr_Clear();
3598  res = SWIG_OverflowError;
3599  }
3600  } else {
3601  long v;
3602  res = SWIG_AsVal_long (obj,&v);
3603  if (SWIG_IsOK(res)) {
3604  if (val) *val = v;
3605  return res;
3606  }
3607  }
3608 #ifdef SWIG_PYTHON_CAST_MODE
3609  {
3610  const double mant_max = 1LL << DBL_MANT_DIG;
3611  const double mant_min = -mant_max;
3612  double d;
3613  res = SWIG_AsVal_double (obj,&d);
3614  if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
3615  return SWIG_OverflowError;
3616  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
3617  if (val) *val = (long long)(d);
3618  return SWIG_AddCast(res);
3619  }
3620  res = SWIG_TypeError;
3621  }
3622 #endif
3623  return res;
3624 }
3625 #endif
3626 
3627 
3628 SWIGINTERNINLINE int
3629 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3630 {
3631  int res = SWIG_TypeError;
3632 #ifdef SWIG_LONG_LONG_AVAILABLE
3633  if (sizeof(ptrdiff_t) <= sizeof(long)) {
3634 #endif
3635  long v;
3636  res = SWIG_AsVal_long (obj, val ? &v : 0);
3637  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3638 #ifdef SWIG_LONG_LONG_AVAILABLE
3639  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
3640  long long v;
3641  res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
3642  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3643  }
3644 #endif
3645  return res;
3646 }
3647 
3648 
3649 #include <algorithm>
3650 
3651 
3652 #include <vector>
3653 
3654 
3655 SWIGINTERNINLINE PyObject*
3656  SWIG_From_int (int value)
3657 {
3658  return PyInt_FromLong((long) value);
3659 }
3660 
3661 
3662 #include <utility>
3663 
3664 
3665 #include <map>
3666 
3667 
3668 #include <algorithm>
3669 
3670 
3671 namespace swig {
3672  template <class Type>
3674  typedef Type noconst_type;
3675  };
3676 
3677  template <class Type>
3678  struct noconst_traits<const Type> {
3679  typedef Type noconst_type;
3680  };
3681 
3682  /*
3683  type categories
3684  */
3685  struct pointer_category { };
3686  struct value_category { };
3687 
3688  /*
3689  General traits that provides type_name and type_info
3690  */
3691  template <class Type> struct traits { };
3692 
3693  template <class Type>
3694  inline const char* type_name() {
3696  }
3697 
3698  template <class Type> struct traits_info {
3699  static swig_type_info *type_query(std::string name) {
3700  name += " *";
3701  return SWIG_TypeQuery(name.c_str());
3702  }
3703  static swig_type_info *type_info() {
3704  static swig_type_info *info = type_query(type_name<Type>());
3705  return info;
3706  }
3707  };
3708 
3709  /*
3710  Partial specialization for pointers (traits_info)
3711  */
3712  template <class Type> struct traits_info<Type *> {
3713  static swig_type_info *type_query(std::string name) {
3714  name += " *";
3715  return SWIG_TypeQuery(name.c_str());
3716  }
3717  static swig_type_info *type_info() {
3718  static swig_type_info *info = type_query(type_name<Type>());
3719  return info;
3720  }
3721  };
3722 
3723  template <class Type>
3724  inline swig_type_info *type_info() {
3726  }
3727 
3728  /*
3729  Partial specialization for pointers (traits)
3730  */
3731  template <class Type> struct traits <Type *> {
3732  typedef pointer_category category;
3733  static std::string make_ptr_name(const char* name) {
3734  std::string ptrname = name;
3735  ptrname += " *";
3736  return ptrname;
3737  }
3738  static const char* type_name() {
3739  static std::string name = make_ptr_name(swig::type_name<Type>());
3740  return name.c_str();
3741  }
3742  };
3743 
3744  template <class Type, class Category>
3745  struct traits_as { };
3746 
3747  template <class Type, class Category>
3748  struct traits_check { };
3749 
3750 }
3751 
3752 
3753 namespace swig {
3754  /*
3755  Traits that provides the from method
3756  */
3757  template <class Type> struct traits_from_ptr {
3758  static PyObject *from(Type *val, int owner = 0) {
3759  return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
3760  }
3761  };
3762 
3763  template <class Type> struct traits_from {
3764  static PyObject *from(const Type& val) {
3765  return traits_from_ptr<Type>::from(new Type(val), 1);
3766  }
3767  };
3768 
3769  template <class Type> struct traits_from<Type *> {
3770  static PyObject *from(Type* val) {
3771  return traits_from_ptr<Type>::from(val, 0);
3772  }
3773  };
3774 
3775  template <class Type> struct traits_from<const Type *> {
3776  static PyObject *from(const Type* val) {
3777  return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3778  }
3779  };
3780 
3781 
3782  template <class Type>
3783  inline PyObject *from(const Type& val) {
3784  return traits_from<Type>::from(val);
3785  }
3786 
3787  template <class Type>
3788  inline PyObject *from_ptr(Type* val, int owner) {
3789  return traits_from_ptr<Type>::from(val, owner);
3790  }
3791 
3792  /*
3793  Traits that provides the asval/as/check method
3794  */
3795  template <class Type>
3796  struct traits_asptr {
3797  static int asptr(PyObject *obj, Type **val) {
3798  Type *p = 0;
3799  swig_type_info *descriptor = type_info<Type>();
3800  int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
3801  if (SWIG_IsOK(res)) {
3802  if (val) *val = p;
3803  }
3804  return res;
3805  }
3806  };
3807 
3808  template <class Type>
3809  inline int asptr(PyObject *obj, Type **vptr) {
3810  return traits_asptr<Type>::asptr(obj, vptr);
3811  }
3812 
3813  template <class Type>
3814  struct traits_asval {
3815  static int asval(PyObject *obj, Type *val) {
3816  if (val) {
3817  Type *p = 0;
3818  int res = traits_asptr<Type>::asptr(obj, &p);
3819  if (!SWIG_IsOK(res)) return res;
3820  if (p) {
3821  typedef typename noconst_traits<Type>::noconst_type noconst_type;
3822  *(const_cast<noconst_type*>(val)) = *p;
3823  if (SWIG_IsNewObj(res)){
3824  delete p;
3825  res = SWIG_DelNewMask(res);
3826  }
3827  return res;
3828  } else {
3829  return SWIG_ERROR;
3830  }
3831  } else {
3832  return traits_asptr<Type>::asptr(obj, (Type **)(0));
3833  }
3834  }
3835  };
3836 
3837  template <class Type> struct traits_asval<Type*> {
3838  static int asval(PyObject *obj, Type **val) {
3839  if (val) {
3840  typedef typename noconst_traits<Type>::noconst_type noconst_type;
3841  noconst_type *p = 0;
3842  int res = traits_asptr<noconst_type>::asptr(obj, &p);
3843  if (SWIG_IsOK(res)) {
3844  *(const_cast<noconst_type**>(val)) = p;
3845  }
3846  return res;
3847  } else {
3848  return traits_asptr<Type>::asptr(obj, (Type **)(0));
3849  }
3850  }
3851  };
3852 
3853  template <class Type>
3854  inline int asval(PyObject *obj, Type *val) {
3855  return traits_asval<Type>::asval(obj, val);
3856  }
3857 
3858  template <class Type>
3859  struct traits_as<Type, value_category> {
3860  static Type as(PyObject *obj) {
3861  Type v;
3862  int res = asval(obj, &v);
3863  if (!obj || !SWIG_IsOK(res)) {
3864  if (!PyErr_Occurred()) {
3865  ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3866  }
3867  throw std::invalid_argument("bad type");
3868  }
3869  return v;
3870  }
3871  };
3872 
3873  template <class Type>
3874  struct traits_as<Type, pointer_category> {
3875  static Type as(PyObject *obj) {
3876  Type *v = 0;
3877  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3878  if (SWIG_IsOK(res) && v) {
3879  if (SWIG_IsNewObj(res)) {
3880  Type r(*v);
3881  delete v;
3882  return r;
3883  } else {
3884  return *v;
3885  }
3886  } else {
3887  if (!PyErr_Occurred()) {
3888  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3889  }
3890  throw std::invalid_argument("bad type");
3891  }
3892  }
3893  };
3894 
3895  template <class Type>
3896  struct traits_as<Type*, pointer_category> {
3897  static Type* as(PyObject *obj) {
3898  Type *v = 0;
3899  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3900  if (SWIG_IsOK(res)) {
3901  return v;
3902  } else {
3903  if (!PyErr_Occurred()) {
3904  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3905  }
3906  throw std::invalid_argument("bad type");
3907  }
3908  }
3909  };
3910 
3911  template <class Type>
3912  inline Type as(PyObject *obj) {
3914  }
3915 
3916  template <class Type>
3918  static bool check(PyObject *obj) {
3919  int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3920  return SWIG_IsOK(res) ? true : false;
3921  }
3922  };
3923 
3924  template <class Type>
3926  static bool check(PyObject *obj) {
3927  int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3928  return SWIG_IsOK(res) ? true : false;
3929  }
3930  };
3931 
3932  template <class Type>
3933  inline bool check(PyObject *obj) {
3935  }
3936 }
3937 
3938 
3939 #include <functional>
3940 
3941 namespace std {
3942  template <>
3943  struct less <PyObject *>
3944  {
3945  bool
3946  operator()(PyObject * v, PyObject *w) const
3947  {
3948  bool res;
3949  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3950  res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
3951  /* This may fall into a case of inconsistent
3952  eg. ObjA > ObjX > ObjB
3953  but ObjA < ObjB
3954  */
3955  if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
3956  {
3957  /* Objects can't be compared, this mostly occurred in Python 3.0 */
3958  /* Compare their ptr directly for a workaround */
3959  res = (v < w);
3960  PyErr_Clear();
3961  }
3962  SWIG_PYTHON_THREAD_END_BLOCK;
3963  return res;
3964  }
3965  };
3966 
3967  template <>
3968  struct less <swig::SwigPtr_PyObject>
3969  {
3970  bool
3971  operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
3972  {
3973  return std::less<PyObject *>()(v, w);
3974  }
3975  };
3976 
3977  template <>
3978  struct less <swig::SwigVar_PyObject>
3979  {
3980  bool
3981  operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
3982  {
3983  return std::less<PyObject *>()(v, w);
3984  }
3985  };
3986 
3987 }
3988 
3989 namespace swig {
3990  template <> struct traits<PyObject *> {
3991  typedef value_category category;
3992  static const char* type_name() { return "PyObject *"; }
3993  };
3994 
3995  template <> struct traits_asval<PyObject * > {
3996  typedef PyObject * value_type;
3997  static int asval(PyObject *obj, value_type *val) {
3998  if (val) *val = obj;
3999  return SWIG_OK;
4000  }
4001  };
4002 
4003  template <>
4004  struct traits_check<PyObject *, value_category> {
4005  static bool check(PyObject *) {
4006  return true;
4007  }
4008  };
4009 
4010  template <> struct traits_from<PyObject *> {
4011  typedef PyObject * value_type;
4012  static PyObject *from(const value_type& val) {
4013  Py_XINCREF(val);
4014  return val;
4015  }
4016  };
4017 
4018 }
4019 
4020 namespace swig {
4021  template <class Difference>
4022  inline size_t
4023  check_index(Difference i, size_t size, bool insert = false) {
4024  if ( i < 0 ) {
4025  if ((size_t) (-i) <= size)
4026  return (size_t) (i + size);
4027  } else if ( (size_t) i < size ) {
4028  return (size_t) i;
4029  } else if (insert && ((size_t) i == size)) {
4030  return size;
4031  }
4032  throw std::out_of_range("index out of range");
4033  }
4034 
4035  template <class Difference>
4036  void
4037  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
4038  if (step == 0) {
4039  throw std::invalid_argument("slice step cannot be zero");
4040  } else if (step > 0) {
4041  // Required range: 0 <= i < size, 0 <= j < size, i <= j
4042  if (i < 0) {
4043  ii = 0;
4044  } else if (i < (Difference)size) {
4045  ii = i;
4046  } else if (insert && (i >= (Difference)size)) {
4047  ii = (Difference)size;
4048  }
4049  if (j < 0) {
4050  jj = 0;
4051  } else {
4052  jj = (j < (Difference)size) ? j : (Difference)size;
4053  }
4054  if (jj < ii)
4055  jj = ii;
4056  } else {
4057  // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
4058  if (i < -1) {
4059  ii = -1;
4060  } else if (i < (Difference) size) {
4061  ii = i;
4062  } else if (i >= (Difference)(size-1)) {
4063  ii = (Difference)(size-1);
4064  }
4065  if (j < -1) {
4066  jj = -1;
4067  } else {
4068  jj = (j < (Difference)size ) ? j : (Difference)(size-1);
4069  }
4070  if (ii < jj)
4071  ii = jj;
4072  }
4073  }
4074 
4075  template <class Sequence, class Difference>
4076  inline typename Sequence::iterator
4077  getpos(Sequence* self, Difference i) {
4078  typename Sequence::iterator pos = self->begin();
4079  std::advance(pos, check_index(i,self->size()));
4080  return pos;
4081  }
4082 
4083  template <class Sequence, class Difference>
4084  inline typename Sequence::const_iterator
4085  cgetpos(const Sequence* self, Difference i) {
4086  typename Sequence::const_iterator pos = self->begin();
4087  std::advance(pos, check_index(i,self->size()));
4088  return pos;
4089  }
4090 
4091  template <class Sequence>
4092  inline void
4093  erase(Sequence* seq, const typename Sequence::iterator& position) {
4094  seq->erase(position);
4095  }
4096 
4097  template <class Sequence>
4099  static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
4100  // This should be specialized for types that support reserve
4101  }
4102  };
4103 
4104  template <class Sequence, class Difference>
4105  inline Sequence*
4106  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4107  typename Sequence::size_type size = self->size();
4108  Difference ii = 0;
4109  Difference jj = 0;
4110  swig::slice_adjust(i, j, step, size, ii, jj);
4111 
4112  if (step > 0) {
4113  typename Sequence::const_iterator sb = self->begin();
4114  typename Sequence::const_iterator se = self->begin();
4115  std::advance(sb,ii);
4116  std::advance(se,jj);
4117  if (step == 1) {
4118  return new Sequence(sb, se);
4119  } else {
4120  Sequence *sequence = new Sequence();
4121  swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
4122  typename Sequence::const_iterator it = sb;
4123  while (it!=se) {
4124  sequence->push_back(*it);
4125  for (Py_ssize_t c=0; c<step && it!=se; ++c)
4126  it++;
4127  }
4128  return sequence;
4129  }
4130  } else {
4131  Sequence *sequence = new Sequence();
4132  swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
4133  typename Sequence::const_reverse_iterator sb = self->rbegin();
4134  typename Sequence::const_reverse_iterator se = self->rbegin();
4135  std::advance(sb,size-ii-1);
4136  std::advance(se,size-jj-1);
4137  typename Sequence::const_reverse_iterator it = sb;
4138  while (it!=se) {
4139  sequence->push_back(*it);
4140  for (Py_ssize_t c=0; c<-step && it!=se; ++c)
4141  it++;
4142  }
4143  return sequence;
4144  }
4145  }
4146 
4147  template <class Sequence, class Difference, class InputSeq>
4148  inline void
4149  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
4150  typename Sequence::size_type size = self->size();
4151  Difference ii = 0;
4152  Difference jj = 0;
4153  swig::slice_adjust(i, j, step, size, ii, jj, true);
4154  if (step > 0) {
4155  if (step == 1) {
4156  size_t ssize = jj - ii;
4157  if (ssize <= is.size()) {
4158  // expanding/staying the same size
4159  swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
4160  typename Sequence::iterator sb = self->begin();
4161  typename InputSeq::const_iterator isit = is.begin();
4162  std::advance(sb,ii);
4163  std::advance(isit, jj - ii);
4164  self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
4165  } else {
4166  // shrinking
4167  typename Sequence::iterator sb = self->begin();
4168  typename Sequence::iterator se = self->begin();
4169  std::advance(sb,ii);
4170  std::advance(se,jj);
4171  self->erase(sb,se);
4172  sb = self->begin();
4173  std::advance(sb,ii);
4174  self->insert(sb, is.begin(), is.end());
4175  }
4176  } else {
4177  size_t replacecount = (jj - ii + step - 1) / step;
4178  if (is.size() != replacecount) {
4179  char msg[1024];
4180  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4181  throw std::invalid_argument(msg);
4182  }
4183  typename Sequence::const_iterator isit = is.begin();
4184  typename Sequence::iterator it = self->begin();
4185  std::advance(it,ii);
4186  for (size_t rc=0; rc<replacecount && it != self->end(); ++rc) {
4187  *it++ = *isit++;
4188  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4189  it++;
4190  }
4191  }
4192  } else {
4193  size_t replacecount = (ii - jj - step - 1) / -step;
4194  if (is.size() != replacecount) {
4195  char msg[1024];
4196  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4197  throw std::invalid_argument(msg);
4198  }
4199  typename Sequence::const_iterator isit = is.begin();
4200  typename Sequence::reverse_iterator it = self->rbegin();
4201  std::advance(it,size-ii-1);
4202  for (size_t rc=0; rc<replacecount && it != self->rend(); ++rc) {
4203  *it++ = *isit++;
4204  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4205  it++;
4206  }
4207  }
4208  }
4209 
4210  template <class Sequence, class Difference>
4211  inline void
4212  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4213  typename Sequence::size_type size = self->size();
4214  Difference ii = 0;
4215  Difference jj = 0;
4216  swig::slice_adjust(i, j, step, size, ii, jj, true);
4217  if (step > 0) {
4218  typename Sequence::iterator sb = self->begin();
4219  std::advance(sb,ii);
4220  if (step == 1) {
4221  typename Sequence::iterator se = self->begin();
4222  std::advance(se,jj);
4223  self->erase(sb,se);
4224  } else {
4225  typename Sequence::iterator it = sb;
4226  size_t delcount = (jj - ii + step - 1) / step;
4227  while (delcount) {
4228  it = self->erase(it);
4229  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4230  it++;
4231  delcount--;
4232  }
4233  }
4234  } else {
4235  typename Sequence::reverse_iterator sb = self->rbegin();
4236  std::advance(sb,size-ii-1);
4237  typename Sequence::reverse_iterator it = sb;
4238  size_t delcount = (ii - jj - step - 1) / -step;
4239  while (delcount) {
4240  it = typename Sequence::reverse_iterator(self->erase((++it).base()));
4241  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4242  it++;
4243  delcount--;
4244  }
4245  }
4246  }
4247 }
4248 
4249 
4250 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
4251 # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
4252 # define SWIG_STD_NOITERATOR_TRAITS_STL
4253 # endif
4254 #endif
4255 
4256 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
4257 #include <iterator>
4258 #else
4259 namespace std {
4260  template <class Iterator>
4261  struct iterator_traits {
4262  typedef ptrdiff_t difference_type;
4263  typedef typename Iterator::value_type value_type;
4264  };
4265 
4266  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
4267  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
4268  typedef Distance difference_type;
4269  typedef T value_type;
4270  };
4271 
4272  template <class T>
4273  struct iterator_traits<T*> {
4274  typedef T value_type;
4275  typedef ptrdiff_t difference_type;
4276  };
4277 
4278  template<typename _InputIterator>
4279  inline typename iterator_traits<_InputIterator>::difference_type
4280  distance(_InputIterator __first, _InputIterator __last)
4281  {
4282  typename iterator_traits<_InputIterator>::difference_type __n = 0;
4283  while (__first != __last) {
4284  ++__first; ++__n;
4285  }
4286  return __n;
4287  }
4288 }
4289 #endif
4290 
4291 
4292 namespace swig {
4293  template<typename OutIterator>
4295  {
4296  public:
4297  typedef OutIterator out_iterator;
4298  typedef typename std::iterator_traits<out_iterator>::value_type value_type;
4300 
4301  SwigPyIterator_T(out_iterator curr, PyObject *seq)
4302  : SwigPyIterator(seq), current(curr)
4303  {
4304  }
4305 
4306  const out_iterator& get_current() const
4307  {
4308  return current;
4309  }
4310 
4311 
4312  bool equal (const SwigPyIterator &iter) const
4313  {
4314  const self_type *iters = dynamic_cast<const self_type *>(&iter);
4315  if (iters) {
4316  return (current == iters->get_current());
4317  } else {
4318  throw std::invalid_argument("bad iterator type");
4319  }
4320  }
4321 
4322  ptrdiff_t distance(const SwigPyIterator &iter) const
4323  {
4324  const self_type *iters = dynamic_cast<const self_type *>(&iter);
4325  if (iters) {
4326  return std::distance(current, iters->get_current());
4327  } else {
4328  throw std::invalid_argument("bad iterator type");
4329  }
4330  }
4331 
4332  protected:
4333  out_iterator current;
4334  };
4335 
4336  template <class ValueType>
4337  struct from_oper
4338  {
4339  typedef const ValueType& argument_type;
4340  typedef PyObject *result_type;
4341  result_type operator()(argument_type v) const
4342  {
4343  return swig::from(v);
4344  }
4345  };
4346 
4347  template<typename OutIterator,
4348  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4349  typename FromOper = from_oper<ValueType> >
4350  class SwigPyForwardIteratorOpen_T : public SwigPyIterator_T<OutIterator>
4351  {
4352  public:
4353  FromOper from;
4354  typedef OutIterator out_iterator;
4355  typedef ValueType value_type;
4358 
4359  SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq)
4360  : SwigPyIterator_T<OutIterator>(curr, seq)
4361  {
4362  }
4363 
4364  PyObject *value() const {
4365  return from(static_cast<const value_type&>(*(base::current)));
4366  }
4367 
4368  SwigPyIterator *copy() const
4369  {
4370  return new self_type(*this);
4371  }
4372 
4373  SwigPyIterator *incr(size_t n = 1)
4374  {
4375  while (n--) {
4376  ++base::current;
4377  }
4378  return this;
4379  }
4380 
4381  };
4382 
4383  template<typename OutIterator,
4384  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4385  typename FromOper = from_oper<ValueType> >
4386  class SwigPyIteratorOpen_T : public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
4387  {
4388  public:
4389  FromOper from;
4390  typedef OutIterator out_iterator;
4391  typedef ValueType value_type;
4394 
4395  SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
4397  {
4398  }
4399 
4400  SwigPyIterator *decr(size_t n = 1)
4401  {
4402  while (n--) {
4403  --base::current;
4404  }
4405  return this;
4406  }
4407  };
4408 
4409  template<typename OutIterator,
4410  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4411  typename FromOper = from_oper<ValueType> >
4413  {
4414  public:
4415  FromOper from;
4416  typedef OutIterator out_iterator;
4417  typedef ValueType value_type;
4420 
4421  SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4422  : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
4423  {
4424  }
4425 
4426  PyObject *value() const {
4427  if (base::current == end) {
4428  throw stop_iteration();
4429  } else {
4430  return from(static_cast<const value_type&>(*(base::current)));
4431  }
4432  }
4433 
4434  SwigPyIterator *copy() const
4435  {
4436  return new self_type(*this);
4437  }
4438 
4439  SwigPyIterator *incr(size_t n = 1)
4440  {
4441  while (n--) {
4442  if (base::current == end) {
4443  throw stop_iteration();
4444  } else {
4445  ++base::current;
4446  }
4447  }
4448  return this;
4449  }
4450 
4451  protected:
4452  out_iterator begin;
4453  out_iterator end;
4454  };
4455 
4456  template<typename OutIterator,
4457  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4458  typename FromOper = from_oper<ValueType> >
4459  class SwigPyIteratorClosed_T : public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
4460  {
4461  public:
4462  FromOper from;
4463  typedef OutIterator out_iterator;
4464  typedef ValueType value_type;
4468 
4469  SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4471  {
4472  }
4473 
4474  SwigPyIterator *decr(size_t n = 1)
4475  {
4476  while (n--) {
4477  if (base::current == base0::begin) {
4478  throw stop_iteration();
4479  } else {
4480  --base::current;
4481  }
4482  }
4483  return this;
4484  }
4485  };
4486 
4487 
4488  template<typename OutIter>
4489  inline SwigPyIterator*
4490  make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4491  {
4492  return new SwigPyForwardIteratorClosed_T<OutIter>(current, begin, end, seq);
4493  }
4494 
4495  template<typename OutIter>
4496  inline SwigPyIterator*
4497  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4498  {
4499  return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
4500  }
4501 
4502  template<typename OutIter>
4503  inline SwigPyIterator*
4504  make_output_forward_iterator(const OutIter& current, PyObject *seq = 0)
4505  {
4506  return new SwigPyForwardIteratorOpen_T<OutIter>(current, seq);
4507  }
4508 
4509  template<typename OutIter>
4510  inline SwigPyIterator*
4511  make_output_iterator(const OutIter& current, PyObject *seq = 0)
4512  {
4513  return new SwigPyIteratorOpen_T<OutIter>(current, seq);
4514  }
4515 
4516 }
4517 
4518 
4519 namespace swig
4520 {
4521  template <class T>
4523  {
4524  SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
4525  : _seq(seq), _index(index)
4526  {
4527  }
4528 
4529  operator T () const
4530  {
4531  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
4532  try {
4533  return swig::as<T>(item);
4534  } catch (const std::invalid_argument& e) {
4535  char msg[1024];
4536  sprintf(msg, "in sequence element %d ", (int)_index);
4537  if (!PyErr_Occurred()) {
4538  ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
4539  }
4540  SWIG_Python_AddErrorMsg(msg);
4541  SWIG_Python_AddErrorMsg(e.what());
4542  throw;
4543  }
4544  }
4545 
4546  SwigPySequence_Ref& operator=(const T& v)
4547  {
4548  PySequence_SetItem(_seq, _index, swig::from<T>(v));
4549  return *this;
4550  }
4551 
4552  private:
4553  PyObject* _seq;
4554  Py_ssize_t _index;
4555  };
4556 
4557  template <class T>
4559  {
4560  SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
4561  const T* operator->() const { return &m_value; }
4562  operator const T*() const { return &m_value; }
4563  T m_value;
4564  };
4565 
4566  template <class T, class Reference >
4568  {
4570 
4571  typedef std::random_access_iterator_tag iterator_category;
4572  typedef Reference reference;
4573  typedef T value_type;
4574  typedef T* pointer;
4575  typedef Py_ssize_t difference_type;
4576 
4578  {
4579  }
4580 
4581  SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
4582  : _seq(seq), _index(index)
4583  {
4584  }
4585 
4586  reference operator*() const
4587  {
4588  return reference(_seq, _index);
4589  }
4590 
4592  operator->() const {
4593  return SwigPySequence_ArrowProxy<T>(operator*());
4594  }
4595 
4596  bool operator==(const self& ri) const
4597  {
4598  return (_index == ri._index) && (_seq == ri._seq);
4599  }
4600 
4601  bool operator!=(const self& ri) const
4602  {
4603  return !(operator==(ri));
4604  }
4605 
4606  self& operator ++ ()
4607  {
4608  ++_index;
4609  return *this;
4610  }
4611 
4612  self& operator -- ()
4613  {
4614  --_index;
4615  return *this;
4616  }
4617 
4618  self& operator += (difference_type n)
4619  {
4620  _index += n;
4621  return *this;
4622  }
4623 
4624  self operator +(difference_type n) const
4625  {
4626  return self(_seq, _index + n);
4627  }
4628 
4629  self& operator -= (difference_type n)
4630  {
4631  _index -= n;
4632  return *this;
4633  }
4634 
4635  self operator -(difference_type n) const
4636  {
4637  return self(_seq, _index - n);
4638  }
4639 
4640  difference_type operator - (const self& ri) const
4641  {
4642  return _index - ri._index;
4643  }
4644 
4645  bool operator < (const self& ri) const
4646  {
4647  return _index < ri._index;
4648  }
4649 
4650  reference
4651  operator[](difference_type n) const
4652  {
4653  return reference(_seq, _index + n);
4654  }
4655 
4656  private:
4657  PyObject* _seq;
4658  difference_type _index;
4659  };
4660 
4661  // STL container wrapper around a Python sequence
4662  template <class T>
4664  {
4666  typedef const SwigPySequence_Ref<T> const_reference;
4667  typedef T value_type;
4668  typedef T* pointer;
4669  typedef Py_ssize_t difference_type;
4670  typedef size_t size_type;
4671  typedef const pointer const_pointer;
4674 
4675  SwigPySequence_Cont(PyObject* seq) : _seq(0)
4676  {
4677  if (!PySequence_Check(seq)) {
4678  throw std::invalid_argument("a sequence is expected");
4679  }
4680  _seq = seq;
4681  Py_INCREF(_seq);
4682  }
4683 
4685  {
4686  Py_XDECREF(_seq);
4687  }
4688 
4689  size_type size() const
4690  {
4691  return static_cast<size_type>(PySequence_Size(_seq));
4692  }
4693 
4694  bool empty() const
4695  {
4696  return size() == 0;
4697  }
4698 
4699  iterator begin()
4700  {
4701  return iterator(_seq, 0);
4702  }
4703 
4704  const_iterator begin() const
4705  {
4706  return const_iterator(_seq, 0);
4707  }
4708 
4709  iterator end()
4710  {
4711  return iterator(_seq, size());
4712  }
4713 
4714  const_iterator end() const
4715  {
4716  return const_iterator(_seq, size());
4717  }
4718 
4719  reference operator[](difference_type n)
4720  {
4721  return reference(_seq, n);
4722  }
4723 
4724  const_reference operator[](difference_type n) const
4725  {
4726  return const_reference(_seq, n);
4727  }
4728 
4729  bool check(bool set_err = true) const
4730  {
4731  Py_ssize_t s = size();
4732  for (Py_ssize_t i = 0; i < s; ++i) {
4733  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
4734  if (!swig::check<value_type>(item)) {
4735  if (set_err) {
4736  char msg[1024];
4737  sprintf(msg, "in sequence element %d", (int)i);
4738  SWIG_Error(SWIG_RuntimeError, msg);
4739  }
4740  return false;
4741  }
4742  }
4743  return true;
4744  }
4745 
4746  private:
4747  PyObject* _seq;
4748  };
4749 
4750 }
4751 
4752 
4753 SWIGINTERN swig_type_info*
4754 SWIG_pchar_descriptor(void)
4755 {
4756  static int init = 0;
4757  static swig_type_info* info = 0;
4758  if (!init) {
4759  info = SWIG_TypeQuery("_p_char");
4760  init = 1;
4761  }
4762  return info;
4763 }
4764 
4765 
4766 SWIGINTERN int
4767 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4768 {
4769 #if PY_VERSION_HEX>=0x03000000
4770 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4771  if (PyBytes_Check(obj))
4772 #else
4773  if (PyUnicode_Check(obj))
4774 #endif
4775 #else
4776  if (PyString_Check(obj))
4777 #endif
4778  {
4779  char *cstr; Py_ssize_t len;
4780  int ret = SWIG_OK;
4781 #if PY_VERSION_HEX>=0x03000000
4782 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4783  if (!alloc && cptr) {
4784  /* We can't allow converting without allocation, since the internal
4785  representation of string in Python 3 is UCS-2/UCS-4 but we require
4786  a UTF-8 representation.
4787  TODO(bhy) More detailed explanation */
4788  return SWIG_RuntimeError;
4789  }
4790  obj = PyUnicode_AsUTF8String(obj);
4791  if (!obj)
4792  return SWIG_TypeError;
4793  if (alloc)
4794  *alloc = SWIG_NEWOBJ;
4795 #endif
4796  PyBytes_AsStringAndSize(obj, &cstr, &len);
4797 #else
4798  PyString_AsStringAndSize(obj, &cstr, &len);
4799 #endif
4800  if (cptr) {
4801  if (alloc) {
4802  /*
4803  In python the user should not be able to modify the inner
4804  string representation. To warranty that, if you define
4805  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4806  buffer is always returned.
4807 
4808  The default behavior is just to return the pointer value,
4809  so, be careful.
4810  */
4811 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4812  if (*alloc != SWIG_OLDOBJ)
4813 #else
4814  if (*alloc == SWIG_NEWOBJ)
4815 #endif
4816  {
4817  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
4818  *alloc = SWIG_NEWOBJ;
4819  } else {
4820  *cptr = cstr;
4821  *alloc = SWIG_OLDOBJ;
4822  }
4823  } else {
4824 #if PY_VERSION_HEX>=0x03000000
4825 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4826  *cptr = PyBytes_AsString(obj);
4827 #else
4828  assert(0); /* Should never reach here with Unicode strings in Python 3 */
4829 #endif
4830 #else
4831  *cptr = SWIG_Python_str_AsChar(obj);
4832  if (!*cptr)
4833  ret = SWIG_TypeError;
4834 #endif
4835  }
4836  }
4837  if (psize) *psize = len + 1;
4838 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4839  Py_XDECREF(obj);
4840 #endif
4841  return ret;
4842  } else {
4843 #if defined(SWIG_PYTHON_2_UNICODE)
4844 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4845 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
4846 #endif
4847 #if PY_VERSION_HEX<0x03000000
4848  if (PyUnicode_Check(obj)) {
4849  char *cstr; Py_ssize_t len;
4850  if (!alloc && cptr) {
4851  return SWIG_RuntimeError;
4852  }
4853  obj = PyUnicode_AsUTF8String(obj);
4854  if (!obj)
4855  return SWIG_TypeError;
4856  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
4857  if (cptr) {
4858  if (alloc) *alloc = SWIG_NEWOBJ;
4859  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
4860  }
4861  if (psize) *psize = len + 1;
4862 
4863  Py_XDECREF(obj);
4864  return SWIG_OK;
4865  } else {
4866  Py_XDECREF(obj);
4867  }
4868  }
4869 #endif
4870 #endif
4871 
4872  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4873  if (pchar_descriptor) {
4874  void* vptr = 0;
4875  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4876  if (cptr) *cptr = (char *) vptr;
4877  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4878  if (alloc) *alloc = SWIG_OLDOBJ;
4879  return SWIG_OK;
4880  }
4881  }
4882  }
4883  return SWIG_TypeError;
4884 }
4885 
4886 
4887 SWIGINTERN int
4888 SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
4889 {
4890  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
4891  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
4892  if (buf) {
4893  if (val) *val = new std::string(buf, size - 1);
4894  if (alloc == SWIG_NEWOBJ) delete[] buf;
4895  return SWIG_NEWOBJ;
4896  } else {
4897  if (val) *val = 0;
4898  return SWIG_OLDOBJ;
4899  }
4900  } else {
4901  static int init = 0;
4902  static swig_type_info* descriptor = 0;
4903  if (!init) {
4904  descriptor = SWIG_TypeQuery("std::string" " *");
4905  init = 1;
4906  }
4907  if (descriptor) {
4908  std::string *vptr;
4909  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
4910  if (SWIG_IsOK(res) && val) *val = vptr;
4911  return res;
4912  }
4913  }
4914  return SWIG_ERROR;
4915 }
4916 
4917 
4918 SWIGINTERN int
4919 SWIG_AsVal_std_string (PyObject * obj, std::string *val)
4920 {
4921  std::string* v = (std::string *) 0;
4922  int res = SWIG_AsPtr_std_string (obj, &v);
4923  if (!SWIG_IsOK(res)) return res;
4924  if (v) {
4925  if (val) *val = *v;
4926  if (SWIG_IsNewObj(res)) {
4927  delete v;
4928  res = SWIG_DelNewMask(res);
4929  }
4930  return res;
4931  }
4932  return SWIG_ERROR;
4933 }
4934 
4935 
4936 SWIGINTERNINLINE PyObject *
4937 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4938 {
4939  if (carray) {
4940  if (size > INT_MAX) {
4941  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4942  return pchar_descriptor ?
4943  SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4944  } else {
4945 #if PY_VERSION_HEX >= 0x03000000
4946 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
4947  return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4948 #else
4949 #if PY_VERSION_HEX >= 0x03010000
4950  return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
4951 #else
4952  return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4953 #endif
4954 #endif
4955 #else
4956  return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4957 #endif
4958  }
4959  } else {
4960  return SWIG_Py_Void();
4961  }
4962 }
4963 
4964 
4965 SWIGINTERNINLINE PyObject *
4966 SWIG_From_std_string (const std::string& s)
4967 {
4968  return SWIG_FromCharPtrAndSize(s.data(), s.size());
4969 }
4970 
4971 
4972 namespace swig {
4973  template <> struct traits< std::string > {
4974  typedef value_category category;
4975  static const char* type_name() { return"std::string"; }
4976  };
4977  template <> struct traits_asval< std::string > {
4978  typedef std::string value_type;
4979  static int asval(PyObject *obj, value_type *val) {
4980  return SWIG_AsVal_std_string (obj, val);
4981  }
4982  };
4983  template <> struct traits_from< std::string > {
4984  typedef std::string value_type;
4985  static PyObject *from(const value_type& val) {
4986  return SWIG_From_std_string (val);
4987  }
4988  };
4989 }
4990 
4991 
4992 namespace swig {
4993  template <class SwigPySeq, class Seq>
4994  inline void
4995  assign(const SwigPySeq& swigpyseq, Seq* seq) {
4996  // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
4997  typedef typename SwigPySeq::value_type value_type;
4998  typename SwigPySeq::const_iterator it = swigpyseq.begin();
4999  for (;it != swigpyseq.end(); ++it) {
5000  seq->insert(seq->end(),(value_type)(*it));
5001  }
5002  }
5003 
5004  template <class Seq, class T = typename Seq::value_type >
5006  typedef Seq sequence;
5007  typedef T value_type;
5008 
5009  static int asptr(PyObject *obj, sequence **seq) {
5010  if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
5011  sequence *p;
5012  swig_type_info *descriptor = swig::type_info<sequence>();
5013  if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
5014  if (seq) *seq = p;
5015  return SWIG_OLDOBJ;
5016  }
5017  } else if (PySequence_Check(obj)) {
5018  try {
5019  SwigPySequence_Cont<value_type> swigpyseq(obj);
5020  if (seq) {
5021  sequence *pseq = new sequence();
5022  assign(swigpyseq, pseq);
5023  *seq = pseq;
5024  return SWIG_NEWOBJ;
5025  } else {
5026  return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
5027  }
5028  } catch (std::exception& e) {
5029  if (seq) {
5030  if (!PyErr_Occurred()) {
5031  PyErr_SetString(PyExc_TypeError, e.what());
5032  }
5033  }
5034  return SWIG_ERROR;
5035  }
5036  }
5037  return SWIG_ERROR;
5038  }
5039  };
5040 
5041  template <class Seq, class T = typename Seq::value_type >
5043  typedef Seq sequence;
5044  typedef T value_type;
5045  typedef typename Seq::size_type size_type;
5046  typedef typename sequence::const_iterator const_iterator;
5047 
5048  static PyObject *from(const sequence& seq) {
5049 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
5050  swig_type_info *desc = swig::type_info<sequence>();
5051  if (desc && desc->clientdata) {
5052  return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
5053  }
5054 #endif
5055  size_type size = seq.size();
5056  if (size <= (size_type)INT_MAX) {
5057  PyObject *obj = PyTuple_New((Py_ssize_t)size);
5058  Py_ssize_t i = 0;
5059  for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
5060  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
5061  }
5062  return obj;
5063  } else {
5064  PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
5065  return NULL;
5066  }
5067  }
5068  };
5069 }
5070 
5071 
5072  namespace swig {
5073  template <class T>
5074  struct traits_reserve<std::vector<T> > {
5075  static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
5076  seq.reserve(n);
5077  }
5078  };
5079 
5080  template <class T>
5081  struct traits_asptr<std::vector<T> > {
5082  static int asptr(PyObject *obj, std::vector<T> **vec) {
5083  return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
5084  }
5085  };
5086 
5087  template <class T>
5088  struct traits_from<std::vector<T> > {
5089  static PyObject *from(const std::vector<T>& vec) {
5090  return traits_from_stdseq<std::vector<T> >::from(vec);
5091  }
5092  };
5093  }
5094 
5095 
5096  namespace swig {
5097  template <> struct traits<std::vector< std::string, std::allocator< std::string > > > {
5098  typedef pointer_category category;
5099  static const char* type_name() {
5100  return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
5101  }
5102  };
5103  }
5104 
5105 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
5106  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5107  }
5108 SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
5109  return !(self->empty());
5110  }
5111 SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
5112  return !(self->empty());
5113  }
5114 SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
5115  return self->size();
5116  }
5117 
5118 SWIGINTERNINLINE PyObject*
5119 SWIG_From_unsigned_SS_long (unsigned long value)
5120 {
5121  return (value > LONG_MAX) ?
5122  PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
5123 }
5124 
5125 
5126 #ifdef SWIG_LONG_LONG_AVAILABLE
5127 SWIGINTERNINLINE PyObject*
5128 SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
5129 {
5130  return (value > LONG_MAX) ?
5131  PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
5132 }
5133 #endif
5134 
5135 
5136 SWIGINTERNINLINE PyObject *
5137 SWIG_From_size_t (size_t value)
5138 {
5139 #ifdef SWIG_LONG_LONG_AVAILABLE
5140  if (sizeof(size_t) <= sizeof(unsigned long)) {
5141 #endif
5142  return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
5143 #ifdef SWIG_LONG_LONG_AVAILABLE
5144  } else {
5145  /* assume sizeof(size_t) <= sizeof(unsigned long long) */
5146  return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
5147  }
5148 #endif
5149 }
5150 
5151 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
5152  return swig::getslice(self, i, j, 1);
5153  }
5154 SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
5155  swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
5156  }
5157 SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
5158  swig::setslice(self, i, j, 1, v);
5159  }
5160 SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
5161  swig::delslice(self, i, j, 1);
5162  }
5163 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
5164  swig::erase(self, swig::getpos(self, i));
5165  }
5166 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
5167  Py_ssize_t i, j, step;
5168  if( !PySlice_Check(slice) ) {
5169  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5170  return NULL;
5171  }
5172  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5173  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
5174  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
5175  return swig::getslice(self, id, jd, step);
5176  }
5177 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
5178  Py_ssize_t i, j, step;
5179  if( !PySlice_Check(slice) ) {
5180  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5181  return;
5182  }
5183  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5184  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
5185  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
5186  swig::setslice(self, id, jd, step, v);
5187  }
5188 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
5189  Py_ssize_t i, j, step;
5190  if( !PySlice_Check(slice) ) {
5191  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5192  return;
5193  }
5194  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5195  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
5196  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
5197  swig::delslice(self, id, jd, step);
5198  }
5199 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
5200  Py_ssize_t i, j, step;
5201  if( !PySlice_Check(slice) ) {
5202  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5203  return;
5204  }
5205  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5206  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
5207  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
5208  swig::delslice(self, id, jd, step);
5209  }
5210 SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
5211  return *(swig::cgetpos(self, i));
5212  }
5213 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
5214  *(swig::getpos(self,i)) = x;
5215  }
5216 SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
5217  if (self->size() == 0)
5218  throw std::out_of_range("pop from empty container");
5219  std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
5220  self->pop_back();
5221  return x;
5222  }
5223 SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
5224  self->push_back(x);
5225  }
5226 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
5227 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
5228 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
5229 SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }
5230 
5231  #define SWIG_From_double PyFloat_FromDouble
5232 
5233 
5234 namespace swig {
5235  template <> struct traits< double > {
5236  typedef value_category category;
5237  static const char* type_name() { return"double"; }
5238  };
5239  template <> struct traits_asval< double > {
5240  typedef double value_type;
5241  static int asval(PyObject *obj, value_type *val) {
5242  return SWIG_AsVal_double (obj, val);
5243  }
5244  };
5245  template <> struct traits_from< double > {
5246  typedef double value_type;
5247  static PyObject *from(const value_type& val) {
5248  return SWIG_From_double (val);
5249  }
5250  };
5251 }
5252 
5253 
5254  namespace swig {
5255  template <> struct traits<std::vector< double, std::allocator< double > > > {
5256  typedef pointer_category category;
5257  static const char* type_name() {
5258  return "std::vector<" "double" "," "std::allocator< double >" " >";
5259  }
5260  };
5261  }
5262 
5263 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
5264  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5265  }
5266 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
5267  return !(self->empty());
5268  }
5269 SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
5270  return !(self->empty());
5271  }
5272 SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
5273  return self->size();
5274  }
5275 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5276  return swig::getslice(self, i, j, 1);
5277  }
5278 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5279  swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
5280  }
5281 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
5282  swig::setslice(self, i, j, 1, v);
5283  }
5284 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5285  swig::delslice(self, i, j, 1);
5286  }
5287 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
5288  swig::erase(self, swig::getpos(self, i));
5289  }
5290 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
5291  Py_ssize_t i, j, step;
5292  if( !PySlice_Check(slice) ) {
5293  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5294  return NULL;
5295  }
5296  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5297  std::vector< double,std::allocator< double > >::difference_type id = i;
5298  std::vector< double,std::allocator< double > >::difference_type jd = j;
5299  return swig::getslice(self, id, jd, step);
5300  }
5301 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
5302  Py_ssize_t i, j, step;
5303  if( !PySlice_Check(slice) ) {
5304  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5305  return;
5306  }
5307  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5308  std::vector< double,std::allocator< double > >::difference_type id = i;
5309  std::vector< double,std::allocator< double > >::difference_type jd = j;
5310  swig::setslice(self, id, jd, step, v);
5311  }
5312 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5313  Py_ssize_t i, j, step;
5314  if( !PySlice_Check(slice) ) {
5315  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5316  return;
5317  }
5318  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5319  std::vector< double,std::allocator< double > >::difference_type id = i;
5320  std::vector< double,std::allocator< double > >::difference_type jd = j;
5321  swig::delslice(self, id, jd, step);
5322  }
5323 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5324  Py_ssize_t i, j, step;
5325  if( !PySlice_Check(slice) ) {
5326  SWIG_Error(SWIG_TypeError, "Slice object expected.");
5327  return;
5328  }
5329  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5330  std::vector< double,std::allocator< double > >::difference_type id = i;
5331  std::vector< double,std::allocator< double > >::difference_type jd = j;
5332  swig::delslice(self, id, jd, step);
5333  }
5334 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
5335  return *(swig::cgetpos(self, i));
5336  }
5337 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
5338  *(swig::getpos(self,i)) = x;
5339  }
5340 SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
5341  if (self->size() == 0)
5342  throw std::out_of_range("pop from empty container");
5343  std::vector< double,std::allocator< double > >::value_type x = self->back();
5344  self->pop_back();
5345  return x;
5346  }
5347 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
5348  self->push_back(x);
5349  }
5350 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
5351 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
5352 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
5353 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
5354 
5355 SWIGINTERN int
5356 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
5357 {
5358  unsigned long v;
5359  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
5360  if (SWIG_IsOK(res)) {
5361  if ((v > UINT_MAX)) {
5362  return SWIG_OverflowError;
5363  } else {
5364  if (val) *val = static_cast< unsigned int >(v);
5365  }
5366  }
5367  return res;
5368 }
5369 
5370 
5371 SWIGINTERNINLINE PyObject*
5372  SWIG_From_unsigned_SS_int (unsigned int value)
5373 {
5374  return PyInt_FromSize_t((size_t) value);
5375 }
5376 
5377 
5378 SWIGINTERN int
5379 SWIG_AsVal_bool (PyObject *obj, bool *val)
5380 {
5381  int r;
5382  if (!PyBool_Check(obj))
5383  return SWIG_ERROR;
5384  r = PyObject_IsTrue(obj);
5385  if (r == -1)
5386  return SWIG_ERROR;
5387  if (val) *val = r ? true : false;
5388  return SWIG_OK;
5389 }
5390 
5391 
5392 SWIGINTERN int
5393 SWIG_AsVal_int (PyObject * obj, int *val)
5394 {
5395  long v;
5396  int res = SWIG_AsVal_long (obj, &v);
5397  if (SWIG_IsOK(res)) {
5398  if ((v < INT_MIN || v > INT_MAX)) {
5399  return SWIG_OverflowError;
5400  } else {
5401  if (val) *val = static_cast< int >(v);
5402  }
5403  }
5404  return res;
5405 }
5406 
5407 #ifdef __cplusplus
5408 extern "C" {
5409 #endif
5410 SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411  PyObject *resultobj = 0;
5413  void *argp1 = 0 ;
5414  int res1 = 0 ;
5415  PyObject * obj0 = 0 ;
5416 
5417  if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
5418  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
5419  if (!SWIG_IsOK(res1)) {
5420  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5421  }
5422  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5423  delete arg1;
5424  resultobj = SWIG_Py_Void();
5425  return resultobj;
5426 fail:
5427  return NULL;
5428 }
5429 
5430 
5431 SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432  PyObject *resultobj = 0;
5434  void *argp1 = 0 ;
5435  int res1 = 0 ;
5436  PyObject * obj0 = 0 ;
5437  PyObject *result = 0 ;
5438 
5439  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
5440  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5441  if (!SWIG_IsOK(res1)) {
5442  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5443  }
5444  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5445  try {
5446  result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
5447  } catch(swig::stop_iteration &_e) {
5448  {
5449  (void)_e;
5450  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5451  SWIG_fail;
5452  }
5453  }
5454  resultobj = result;
5455  return resultobj;
5456 fail:
5457  return NULL;
5458 }
5459 
5460 
5461 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5462  PyObject *resultobj = 0;
5464  size_t arg2 ;
5465  void *argp1 = 0 ;
5466  int res1 = 0 ;
5467  size_t val2 ;
5468  int ecode2 = 0 ;
5469  PyObject * obj0 = 0 ;
5470  PyObject * obj1 = 0 ;
5471  swig::SwigPyIterator *result = 0 ;
5472 
5473  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
5474  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5475  if (!SWIG_IsOK(res1)) {
5476  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5477  }
5478  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5479  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5480  if (!SWIG_IsOK(ecode2)) {
5481  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
5482  }
5483  arg2 = static_cast< size_t >(val2);
5484  try {
5485  result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
5486  } catch(swig::stop_iteration &_e) {
5487  {
5488  (void)_e;
5489  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5490  SWIG_fail;
5491  }
5492  }
5493  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5494  return resultobj;
5495 fail:
5496  return NULL;
5497 }
5498 
5499 
5500 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501  PyObject *resultobj = 0;
5503  void *argp1 = 0 ;
5504  int res1 = 0 ;
5505  PyObject * obj0 = 0 ;
5506  swig::SwigPyIterator *result = 0 ;
5507 
5508  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
5509  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5510  if (!SWIG_IsOK(res1)) {
5511  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5512  }
5513  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5514  try {
5515  result = (swig::SwigPyIterator *)(arg1)->incr();
5516  } catch(swig::stop_iteration &_e) {
5517  {
5518  (void)_e;
5519  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5520  SWIG_fail;
5521  }
5522  }
5523  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5524  return resultobj;
5525 fail:
5526  return NULL;
5527 }
5528 
5529 
5530 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
5531  Py_ssize_t argc;
5532  PyObject *argv[3] = {
5533  0
5534  };
5535  Py_ssize_t ii;
5536 
5537  if (!PyTuple_Check(args)) SWIG_fail;
5538  argc = PyObject_Length(args);
5539  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
5540  argv[ii] = PyTuple_GET_ITEM(args,ii);
5541  }
5542  if (argc == 1) {
5543  int _v;
5544  void *vptr = 0;
5545  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5546  _v = SWIG_CheckState(res);
5547  if (_v) {
5548  return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
5549  }
5550  }
5551  if (argc == 2) {
5552  int _v;
5553  void *vptr = 0;
5554  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5555  _v = SWIG_CheckState(res);
5556  if (_v) {
5557  {
5558  int res = SWIG_AsVal_size_t(argv[1], NULL);
5559  _v = SWIG_CheckState(res);
5560  }
5561  if (_v) {
5562  return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
5563  }
5564  }
5565  }
5566 
5567 fail:
5568  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
5569  " Possible C/C++ prototypes are:\n"
5570  " swig::SwigPyIterator::incr(size_t)\n"
5571  " swig::SwigPyIterator::incr()\n");
5572  return 0;
5573 }
5574 
5575 
5576 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5577  PyObject *resultobj = 0;
5579  size_t arg2 ;
5580  void *argp1 = 0 ;
5581  int res1 = 0 ;
5582  size_t val2 ;
5583  int ecode2 = 0 ;
5584  PyObject * obj0 = 0 ;
5585  PyObject * obj1 = 0 ;
5586  swig::SwigPyIterator *result = 0 ;
5587 
5588  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
5589  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5590  if (!SWIG_IsOK(res1)) {
5591  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5592  }
5593  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5594  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5595  if (!SWIG_IsOK(ecode2)) {
5596  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
5597  }
5598  arg2 = static_cast< size_t >(val2);
5599  try {
5600  result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
5601  } catch(swig::stop_iteration &_e) {
5602  {
5603  (void)_e;
5604  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5605  SWIG_fail;
5606  }
5607  }
5608  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5609  return resultobj;
5610 fail:
5611  return NULL;
5612 }
5613 
5614 
5615 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616  PyObject *resultobj = 0;
5618  void *argp1 = 0 ;
5619  int res1 = 0 ;
5620  PyObject * obj0 = 0 ;
5621  swig::SwigPyIterator *result = 0 ;
5622 
5623  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
5624  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5625  if (!SWIG_IsOK(res1)) {
5626  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5627  }
5628  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5629  try {
5630  result = (swig::SwigPyIterator *)(arg1)->decr();
5631  } catch(swig::stop_iteration &_e) {
5632  {
5633  (void)_e;
5634  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5635  SWIG_fail;
5636  }
5637  }
5638  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5639  return resultobj;
5640 fail:
5641  return NULL;
5642 }
5643 
5644 
5645 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
5646  Py_ssize_t argc;
5647  PyObject *argv[3] = {
5648  0
5649  };
5650  Py_ssize_t ii;
5651 
5652  if (!PyTuple_Check(args)) SWIG_fail;
5653  argc = PyObject_Length(args);
5654  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
5655  argv[ii] = PyTuple_GET_ITEM(args,ii);
5656  }
5657  if (argc == 1) {
5658  int _v;
5659  void *vptr = 0;
5660  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5661  _v = SWIG_CheckState(res);
5662  if (_v) {
5663  return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
5664  }
5665  }
5666  if (argc == 2) {
5667  int _v;
5668  void *vptr = 0;
5669  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5670  _v = SWIG_CheckState(res);
5671  if (_v) {
5672  {
5673  int res = SWIG_AsVal_size_t(argv[1], NULL);
5674  _v = SWIG_CheckState(res);
5675  }
5676  if (_v) {
5677  return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
5678  }
5679  }
5680  }
5681 
5682 fail:
5683  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
5684  " Possible C/C++ prototypes are:\n"
5685  " swig::SwigPyIterator::decr(size_t)\n"
5686  " swig::SwigPyIterator::decr()\n");
5687  return 0;
5688 }
5689 
5690 
5691 SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5692  PyObject *resultobj = 0;
5694  swig::SwigPyIterator *arg2 = 0 ;
5695  void *argp1 = 0 ;
5696  int res1 = 0 ;
5697  void *argp2 = 0 ;
5698  int res2 = 0 ;
5699  PyObject * obj0 = 0 ;
5700  PyObject * obj1 = 0 ;
5701  ptrdiff_t result;
5702 
5703  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
5704  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5705  if (!SWIG_IsOK(res1)) {
5706  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5707  }
5708  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5709  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5710  if (!SWIG_IsOK(res2)) {
5711  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5712  }
5713  if (!argp2) {
5714  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5715  }
5716  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5717  try {
5718  result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
5719  } catch(std::invalid_argument &_e) {
5720  SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5721  }
5722  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5723  return resultobj;
5724 fail:
5725  return NULL;
5726 }
5727 
5728 
5729 SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730  PyObject *resultobj = 0;
5732  swig::SwigPyIterator *arg2 = 0 ;
5733  void *argp1 = 0 ;
5734  int res1 = 0 ;
5735  void *argp2 = 0 ;
5736  int res2 = 0 ;
5737  PyObject * obj0 = 0 ;
5738  PyObject * obj1 = 0 ;
5739  bool result;
5740 
5741  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
5742  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5743  if (!SWIG_IsOK(res1)) {
5744  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5745  }
5746  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5747  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5748  if (!SWIG_IsOK(res2)) {
5749  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5750  }
5751  if (!argp2) {
5752  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5753  }
5754  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5755  try {
5756  result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
5757  } catch(std::invalid_argument &_e) {
5758  SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5759  }
5760  resultobj = SWIG_From_bool(static_cast< bool >(result));
5761  return resultobj;
5762 fail:
5763  return NULL;
5764 }
5765 
5766 
5767 SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5768  PyObject *resultobj = 0;
5770  void *argp1 = 0 ;
5771  int res1 = 0 ;
5772  PyObject * obj0 = 0 ;
5773  swig::SwigPyIterator *result = 0 ;
5774 
5775  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
5776  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5777  if (!SWIG_IsOK(res1)) {
5778  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5779  }
5780  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5781  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
5782  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
5783  return resultobj;
5784 fail:
5785  return NULL;
5786 }
5787 
5788 
5789 SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5790  PyObject *resultobj = 0;
5792  void *argp1 = 0 ;
5793  int res1 = 0 ;
5794  PyObject * obj0 = 0 ;
5795  PyObject *result = 0 ;
5796 
5797  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
5798  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5799  if (!SWIG_IsOK(res1)) {
5800  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5801  }
5802  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5803  try {
5804  result = (PyObject *)(arg1)->next();
5805  } catch(swig::stop_iteration &_e) {
5806  {
5807  (void)_e;
5808  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5809  SWIG_fail;
5810  }
5811  }
5812  resultobj = result;
5813  return resultobj;
5814 fail:
5815  return NULL;
5816 }
5817 
5818 
5819 SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5820  PyObject *resultobj = 0;
5822  void *argp1 = 0 ;
5823  int res1 = 0 ;
5824  PyObject * obj0 = 0 ;
5825  PyObject *result = 0 ;
5826 
5827  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
5828  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5829  if (!SWIG_IsOK(res1)) {
5830  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5831  }
5832  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5833  try {
5834  result = (PyObject *)(arg1)->__next__();
5835  } catch(swig::stop_iteration &_e) {
5836  {
5837  (void)_e;
5838  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5839  SWIG_fail;
5840  }
5841  }
5842  resultobj = result;
5843  return resultobj;
5844 fail:
5845  return NULL;
5846 }
5847 
5848 
5849 SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5850  PyObject *resultobj = 0;
5852  void *argp1 = 0 ;
5853  int res1 = 0 ;
5854  PyObject * obj0 = 0 ;
5855  PyObject *result = 0 ;
5856 
5857  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
5858  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5859  if (!SWIG_IsOK(res1)) {
5860  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5861  }
5862  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5863  try {
5864  result = (PyObject *)(arg1)->previous();
5865  } catch(swig::stop_iteration &_e) {
5866  {
5867  (void)_e;
5868  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5869  SWIG_fail;
5870  }
5871  }
5872  resultobj = result;
5873  return resultobj;
5874 fail:
5875  return NULL;
5876 }
5877 
5878 
5879 SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880  PyObject *resultobj = 0;
5882  ptrdiff_t arg2 ;
5883  void *argp1 = 0 ;
5884  int res1 = 0 ;
5885  ptrdiff_t val2 ;
5886  int ecode2 = 0 ;
5887  PyObject * obj0 = 0 ;
5888  PyObject * obj1 = 0 ;
5889  swig::SwigPyIterator *result = 0 ;
5890 
5891  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
5892  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5893  if (!SWIG_IsOK(res1)) {
5894  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5895  }
5896  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5897  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5898  if (!SWIG_IsOK(ecode2)) {
5899  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5900  }
5901  arg2 = static_cast< ptrdiff_t >(val2);
5902  try {
5903  result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
5904  } catch(swig::stop_iteration &_e) {
5905  {
5906  (void)_e;
5907  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5908  SWIG_fail;
5909  }
5910  }
5911  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5912  return resultobj;
5913 fail:
5914  return NULL;
5915 }
5916 
5917 
5918 SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5919  PyObject *resultobj = 0;
5921  swig::SwigPyIterator *arg2 = 0 ;
5922  void *argp1 = 0 ;
5923  int res1 = 0 ;
5924  void *argp2 = 0 ;
5925  int res2 = 0 ;
5926  PyObject * obj0 = 0 ;
5927  PyObject * obj1 = 0 ;
5928  bool result;
5929 
5930  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
5931  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5932  if (!SWIG_IsOK(res1)) {
5933  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5934  }
5935  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5936  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5937  if (!SWIG_IsOK(res2)) {
5938  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5939  }
5940  if (!argp2) {
5941  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5942  }
5943  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5944  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
5945  resultobj = SWIG_From_bool(static_cast< bool >(result));
5946  return resultobj;
5947 fail:
5948  PyErr_Clear();
5949  Py_INCREF(Py_NotImplemented);
5950  return Py_NotImplemented;
5951 }
5952 
5953 
5954 SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5955  PyObject *resultobj = 0;
5957  swig::SwigPyIterator *arg2 = 0 ;
5958  void *argp1 = 0 ;
5959  int res1 = 0 ;
5960  void *argp2 = 0 ;
5961  int res2 = 0 ;
5962  PyObject * obj0 = 0 ;
5963  PyObject * obj1 = 0 ;
5964  bool result;
5965 
5966  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
5967  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5968  if (!SWIG_IsOK(res1)) {
5969  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5970  }
5971  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5972  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5973  if (!SWIG_IsOK(res2)) {
5974  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5975  }
5976  if (!argp2) {
5977  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5978  }
5979  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5980  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
5981  resultobj = SWIG_From_bool(static_cast< bool >(result));
5982  return resultobj;
5983 fail:
5984  PyErr_Clear();
5985  Py_INCREF(Py_NotImplemented);
5986  return Py_NotImplemented;
5987 }
5988 
5989 
5990 SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5991  PyObject *resultobj = 0;
5993  ptrdiff_t arg2 ;
5994  void *argp1 = 0 ;
5995  int res1 = 0 ;
5996  ptrdiff_t val2 ;
5997  int ecode2 = 0 ;
5998  PyObject * obj0 = 0 ;
5999  PyObject * obj1 = 0 ;
6000  swig::SwigPyIterator *result = 0 ;
6001 
6002  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
6003  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
6004  if (!SWIG_IsOK(res1)) {
6005  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6006  }
6007  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6008  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6009  if (!SWIG_IsOK(ecode2)) {
6010  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
6011  }
6012  arg2 = static_cast< ptrdiff_t >(val2);
6013  try {
6014  result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
6015  } catch(swig::stop_iteration &_e) {
6016  {
6017  (void)_e;
6018  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6019  SWIG_fail;
6020  }
6021  }
6022  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6023  return resultobj;
6024 fail:
6025  return NULL;
6026 }
6027 
6028 
6029 SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6030  PyObject *resultobj = 0;
6032  ptrdiff_t arg2 ;
6033  void *argp1 = 0 ;
6034  int res1 = 0 ;
6035  ptrdiff_t val2 ;
6036  int ecode2 = 0 ;
6037  PyObject * obj0 = 0 ;
6038  PyObject * obj1 = 0 ;
6039  swig::SwigPyIterator *result = 0 ;
6040 
6041  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
6042  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
6043  if (!SWIG_IsOK(res1)) {
6044  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6045  }
6046  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6047  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6048  if (!SWIG_IsOK(ecode2)) {
6049  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6050  }
6051  arg2 = static_cast< ptrdiff_t >(val2);
6052  try {
6053  result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
6054  } catch(swig::stop_iteration &_e) {
6055  {
6056  (void)_e;
6057  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6058  SWIG_fail;
6059  }
6060  }
6061  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6062  return resultobj;
6063 fail:
6064  return NULL;
6065 }
6066 
6067 
6068 SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6069  PyObject *resultobj = 0;
6071  ptrdiff_t arg2 ;
6072  void *argp1 = 0 ;
6073  int res1 = 0 ;
6074  ptrdiff_t val2 ;
6075  int ecode2 = 0 ;
6076  PyObject * obj0 = 0 ;
6077  PyObject * obj1 = 0 ;
6078  swig::SwigPyIterator *result = 0 ;
6079 
6080  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
6081  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6082  if (!SWIG_IsOK(res1)) {
6083  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6084  }
6085  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6086  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6087  if (!SWIG_IsOK(ecode2)) {
6088  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
6089  }
6090  arg2 = static_cast< ptrdiff_t >(val2);
6091  try {
6092  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
6093  } catch(swig::stop_iteration &_e) {
6094  {
6095  (void)_e;
6096  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6097  SWIG_fail;
6098  }
6099  }
6100  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6101  return resultobj;
6102 fail:
6103  PyErr_Clear();
6104  Py_INCREF(Py_NotImplemented);
6105  return Py_NotImplemented;
6106 }
6107 
6108 
6109 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6110  PyObject *resultobj = 0;
6112  ptrdiff_t arg2 ;
6113  void *argp1 = 0 ;
6114  int res1 = 0 ;
6115  ptrdiff_t val2 ;
6116  int ecode2 = 0 ;
6117  PyObject * obj0 = 0 ;
6118  PyObject * obj1 = 0 ;
6119  swig::SwigPyIterator *result = 0 ;
6120 
6121  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6122  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6123  if (!SWIG_IsOK(res1)) {
6124  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6125  }
6126  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6127  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6128  if (!SWIG_IsOK(ecode2)) {
6129  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6130  }
6131  arg2 = static_cast< ptrdiff_t >(val2);
6132  try {
6133  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
6134  } catch(swig::stop_iteration &_e) {
6135  {
6136  (void)_e;
6137  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6138  SWIG_fail;
6139  }
6140  }
6141  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6142  return resultobj;
6143 fail:
6144  PyErr_Clear();
6145  Py_INCREF(Py_NotImplemented);
6146  return Py_NotImplemented;
6147 }
6148 
6149 
6150 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6151  PyObject *resultobj = 0;
6153  swig::SwigPyIterator *arg2 = 0 ;
6154  void *argp1 = 0 ;
6155  int res1 = 0 ;
6156  void *argp2 = 0 ;
6157  int res2 = 0 ;
6158  PyObject * obj0 = 0 ;
6159  PyObject * obj1 = 0 ;
6160  ptrdiff_t result;
6161 
6162  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6163  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6164  if (!SWIG_IsOK(res1)) {
6165  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6166  }
6167  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6168  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6169  if (!SWIG_IsOK(res2)) {
6170  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6171  }
6172  if (!argp2) {
6173  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6174  }
6175  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6176  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
6177  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
6178  return resultobj;
6179 fail:
6180  PyErr_Clear();
6181  Py_INCREF(Py_NotImplemented);
6182  return Py_NotImplemented;
6183 }
6184 
6185 
6186 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
6187  Py_ssize_t argc;
6188  PyObject *argv[3] = {
6189  0
6190  };
6191  Py_ssize_t ii;
6192 
6193  if (!PyTuple_Check(args)) SWIG_fail;
6194  argc = PyObject_Length(args);
6195  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6196  argv[ii] = PyTuple_GET_ITEM(args,ii);
6197  }
6198  if (argc == 2) {
6199  int _v;
6200  void *vptr = 0;
6201  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6202  _v = SWIG_CheckState(res);
6203  if (_v) {
6204  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
6205  _v = SWIG_CheckState(res);
6206  if (_v) {
6207  return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
6208  }
6209  }
6210  }
6211  if (argc == 2) {
6212  int _v;
6213  void *vptr = 0;
6214  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6215  _v = SWIG_CheckState(res);
6216  if (_v) {
6217  {
6218  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6219  _v = SWIG_CheckState(res);
6220  }
6221  if (_v) {
6222  return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
6223  }
6224  }
6225  }
6226 
6227 fail:
6228  Py_INCREF(Py_NotImplemented);
6229  return Py_NotImplemented;
6230 }
6231 
6232 
6233 SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6234  PyObject *obj;
6235  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
6236  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
6237  return SWIG_Py_Void();
6238 }
6239 
6240 SWIGINTERN PyObject *_wrap_StringList_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6241  PyObject *resultobj = 0;
6242  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6243  PyObject **arg2 = (PyObject **) 0 ;
6244  void *argp1 = 0 ;
6245  int res1 = 0 ;
6246  PyObject * obj0 = 0 ;
6247  swig::SwigPyIterator *result = 0 ;
6248 
6249  arg2 = &obj0;
6250  if (!PyArg_ParseTuple(args,(char *)"O:StringList_iterator",&obj0)) SWIG_fail;
6251  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6252  if (!SWIG_IsOK(res1)) {
6253  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6254  }
6255  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6256  result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
6257  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6258  return resultobj;
6259 fail:
6260  return NULL;
6261 }
6262 
6263 
6264 SWIGINTERN PyObject *_wrap_StringList___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6265  PyObject *resultobj = 0;
6266  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6267  void *argp1 = 0 ;
6268  int res1 = 0 ;
6269  PyObject * obj0 = 0 ;
6270  bool result;
6271 
6272  if (!PyArg_ParseTuple(args,(char *)"O:StringList___nonzero__",&obj0)) SWIG_fail;
6273  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6274  if (!SWIG_IsOK(res1)) {
6275  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
6276  }
6277  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6278  result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
6279  resultobj = SWIG_From_bool(static_cast< bool >(result));
6280  return resultobj;
6281 fail:
6282  return NULL;
6283 }
6284 
6285 
6286 SWIGINTERN PyObject *_wrap_StringList___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6287  PyObject *resultobj = 0;
6288  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6289  void *argp1 = 0 ;
6290  int res1 = 0 ;
6291  PyObject * obj0 = 0 ;
6292  bool result;
6293 
6294  if (!PyArg_ParseTuple(args,(char *)"O:StringList___bool__",&obj0)) SWIG_fail;
6295  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6296  if (!SWIG_IsOK(res1)) {
6297  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
6298  }
6299  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6300  result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
6301  resultobj = SWIG_From_bool(static_cast< bool >(result));
6302  return resultobj;
6303 fail:
6304  return NULL;
6305 }
6306 
6307 
6308 SWIGINTERN PyObject *_wrap_StringList___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6309  PyObject *resultobj = 0;
6310  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6311  void *argp1 = 0 ;
6312  int res1 = 0 ;
6313  PyObject * obj0 = 0 ;
6314  std::vector< std::string >::size_type result;
6315 
6316  if (!PyArg_ParseTuple(args,(char *)"O:StringList___len__",&obj0)) SWIG_fail;
6317  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6318  if (!SWIG_IsOK(res1)) {
6319  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
6320  }
6321  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6322  result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
6323  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6324  return resultobj;
6325 fail:
6326  return NULL;
6327 }
6328 
6329 
6330 SWIGINTERN PyObject *_wrap_StringList___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6331  PyObject *resultobj = 0;
6332  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6333  std::vector< std::string >::difference_type arg2 ;
6334  std::vector< std::string >::difference_type arg3 ;
6335  void *argp1 = 0 ;
6336  int res1 = 0 ;
6337  ptrdiff_t val2 ;
6338  int ecode2 = 0 ;
6339  ptrdiff_t val3 ;
6340  int ecode3 = 0 ;
6341  PyObject * obj0 = 0 ;
6342  PyObject * obj1 = 0 ;
6343  PyObject * obj2 = 0 ;
6344  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
6345 
6346  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6347  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6348  if (!SWIG_IsOK(res1)) {
6349  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6350  }
6351  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6352  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6353  if (!SWIG_IsOK(ecode2)) {
6354  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6355  }
6356  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6357  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6358  if (!SWIG_IsOK(ecode3)) {
6359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
6360  }
6361  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
6362  try {
6363  result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,arg2,arg3);
6364  } catch(std::out_of_range &_e) {
6365  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6366  } catch(std::invalid_argument &_e) {
6367  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6368  }
6369  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 );
6370  return resultobj;
6371 fail:
6372  return NULL;
6373 }
6374 
6375 
6376 SWIGINTERN PyObject *_wrap_StringList___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6377  PyObject *resultobj = 0;
6378  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6379  std::vector< std::string >::difference_type arg2 ;
6380  std::vector< std::string >::difference_type arg3 ;
6381  void *argp1 = 0 ;
6382  int res1 = 0 ;
6383  ptrdiff_t val2 ;
6384  int ecode2 = 0 ;
6385  ptrdiff_t val3 ;
6386  int ecode3 = 0 ;
6387  PyObject * obj0 = 0 ;
6388  PyObject * obj1 = 0 ;
6389  PyObject * obj2 = 0 ;
6390 
6391  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6392  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6393  if (!SWIG_IsOK(res1)) {
6394  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6395  }
6396  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6397  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6398  if (!SWIG_IsOK(ecode2)) {
6399  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6400  }
6401  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6402  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6403  if (!SWIG_IsOK(ecode3)) {
6404  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
6405  }
6406  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
6407  try {
6408  std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3);
6409  } catch(std::out_of_range &_e) {
6410  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6411  } catch(std::invalid_argument &_e) {
6412  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6413  }
6414  resultobj = SWIG_Py_Void();
6415  return resultobj;
6416 fail:
6417  return NULL;
6418 }
6419 
6420 
6421 SWIGINTERN PyObject *_wrap_StringList___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6422  PyObject *resultobj = 0;
6423  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6424  std::vector< std::string >::difference_type arg2 ;
6425  std::vector< std::string >::difference_type arg3 ;
6426  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
6427  void *argp1 = 0 ;
6428  int res1 = 0 ;
6429  ptrdiff_t val2 ;
6430  int ecode2 = 0 ;
6431  ptrdiff_t val3 ;
6432  int ecode3 = 0 ;
6433  int res4 = SWIG_OLDOBJ ;
6434  PyObject * obj0 = 0 ;
6435  PyObject * obj1 = 0 ;
6436  PyObject * obj2 = 0 ;
6437  PyObject * obj3 = 0 ;
6438 
6439  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringList___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6440  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6441  if (!SWIG_IsOK(res1)) {
6442  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6443  }
6444  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6445  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6446  if (!SWIG_IsOK(ecode2)) {
6447  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6448  }
6449  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6450  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6451  if (!SWIG_IsOK(ecode3)) {
6452  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
6453  }
6454  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
6455  {
6456  std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
6457  res4 = swig::asptr(obj3, &ptr);
6458  if (!SWIG_IsOK(res4)) {
6459  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringList___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'");
6460  }
6461  if (!ptr) {
6462  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'");
6463  }
6464  arg4 = ptr;
6465  }
6466  try {
6467  std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
6468  } catch(std::out_of_range &_e) {
6469  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6470  } catch(std::invalid_argument &_e) {
6471  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6472  }
6473  resultobj = SWIG_Py_Void();
6474  if (SWIG_IsNewObj(res4)) delete arg4;
6475  return resultobj;
6476 fail:
6477  if (SWIG_IsNewObj(res4)) delete arg4;
6478  return NULL;
6479 }
6480 
6481 
6482 SWIGINTERN PyObject *_wrap_StringList___setslice__(PyObject *self, PyObject *args) {
6483  Py_ssize_t argc;
6484  PyObject *argv[5] = {
6485  0
6486  };
6487  Py_ssize_t ii;
6488 
6489  if (!PyTuple_Check(args)) SWIG_fail;
6490  argc = PyObject_Length(args);
6491  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
6492  argv[ii] = PyTuple_GET_ITEM(args,ii);
6493  }
6494  if (argc == 3) {
6495  int _v;
6496  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6497  _v = SWIG_CheckState(res);
6498  if (_v) {
6499  {
6500  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6501  _v = SWIG_CheckState(res);
6502  }
6503  if (_v) {
6504  {
6505  int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
6506  _v = SWIG_CheckState(res);
6507  }
6508  if (_v) {
6509  return _wrap_StringList___setslice____SWIG_0(self, args);
6510  }
6511  }
6512  }
6513  }
6514  if (argc == 4) {
6515  int _v;
6516  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6517  _v = SWIG_CheckState(res);
6518  if (_v) {
6519  {
6520  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6521  _v = SWIG_CheckState(res);
6522  }
6523  if (_v) {
6524  {
6525  int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
6526  _v = SWIG_CheckState(res);
6527  }
6528  if (_v) {
6529  int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
6530  _v = SWIG_CheckState(res);
6531  if (_v) {
6532  return _wrap_StringList___setslice____SWIG_1(self, args);
6533  }
6534  }
6535  }
6536  }
6537  }
6538 
6539 fail:
6540  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList___setslice__'.\n"
6541  " Possible C/C++ prototypes are:\n"
6542  " std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
6543  " std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
6544  return 0;
6545 }
6546 
6547 
6548 SWIGINTERN PyObject *_wrap_StringList___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6549  PyObject *resultobj = 0;
6550  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6551  std::vector< std::string >::difference_type arg2 ;
6552  std::vector< std::string >::difference_type arg3 ;
6553  void *argp1 = 0 ;
6554  int res1 = 0 ;
6555  ptrdiff_t val2 ;
6556  int ecode2 = 0 ;
6557  ptrdiff_t val3 ;
6558  int ecode3 = 0 ;
6559  PyObject * obj0 = 0 ;
6560  PyObject * obj1 = 0 ;
6561  PyObject * obj2 = 0 ;
6562 
6563  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6564  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6565  if (!SWIG_IsOK(res1)) {
6566  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6567  }
6568  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6569  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6570  if (!SWIG_IsOK(ecode2)) {
6571  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6572  }
6573  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6574  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6575  if (!SWIG_IsOK(ecode3)) {
6576  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
6577  }
6578  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
6579  try {
6580  std_vector_Sl_std_string_Sg____delslice__(arg1,arg2,arg3);
6581  } catch(std::out_of_range &_e) {
6582  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6583  } catch(std::invalid_argument &_e) {
6584  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6585  }
6586  resultobj = SWIG_Py_Void();
6587  return resultobj;
6588 fail:
6589  return NULL;
6590 }
6591 
6592 
6593 SWIGINTERN PyObject *_wrap_StringList___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594  PyObject *resultobj = 0;
6595  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6596  std::vector< std::string >::difference_type arg2 ;
6597  void *argp1 = 0 ;
6598  int res1 = 0 ;
6599  ptrdiff_t val2 ;
6600  int ecode2 = 0 ;
6601  PyObject * obj0 = 0 ;
6602  PyObject * obj1 = 0 ;
6603 
6604  if (!PyArg_ParseTuple(args,(char *)"OO:StringList___delitem__",&obj0,&obj1)) SWIG_fail;
6605  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6606  if (!SWIG_IsOK(res1)) {
6607  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6608  }
6609  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6610  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6611  if (!SWIG_IsOK(ecode2)) {
6612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6613  }
6614  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6615  try {
6616  std_vector_Sl_std_string_Sg____delitem____SWIG_0(arg1,arg2);
6617  } catch(std::out_of_range &_e) {
6618  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6619  } catch(std::invalid_argument &_e) {
6620  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6621  }
6622  resultobj = SWIG_Py_Void();
6623  return resultobj;
6624 fail:
6625  return NULL;
6626 }
6627 
6628 
6629 SWIGINTERN PyObject *_wrap_StringList___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6630  PyObject *resultobj = 0;
6631  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6632  PySliceObject *arg2 = (PySliceObject *) 0 ;
6633  void *argp1 = 0 ;
6634  int res1 = 0 ;
6635  PyObject * obj0 = 0 ;
6636  PyObject * obj1 = 0 ;
6637  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
6638 
6639  if (!PyArg_ParseTuple(args,(char *)"OO:StringList___getitem__",&obj0,&obj1)) SWIG_fail;
6640  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6641  if (!SWIG_IsOK(res1)) {
6642  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6643  }
6644  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6645  {
6646  if (!PySlice_Check(obj1)) {
6647  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
6648  }
6649  arg2 = (PySliceObject *) obj1;
6650  }
6651  try {
6652  result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
6653  } catch(std::out_of_range &_e) {
6654  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6655  } catch(std::invalid_argument &_e) {
6656  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6657  }
6658  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN | 0 );
6659  return resultobj;
6660 fail:
6661  return NULL;
6662 }
6663 
6664 
6665 SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6666  PyObject *resultobj = 0;
6667  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6668  PySliceObject *arg2 = (PySliceObject *) 0 ;
6669  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
6670  void *argp1 = 0 ;
6671  int res1 = 0 ;
6672  int res3 = SWIG_OLDOBJ ;
6673  PyObject * obj0 = 0 ;
6674  PyObject * obj1 = 0 ;
6675  PyObject * obj2 = 0 ;
6676 
6677  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6678  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6679  if (!SWIG_IsOK(res1)) {
6680  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6681  }
6682  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6683  {
6684  if (!PySlice_Check(obj1)) {
6685  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
6686  }
6687  arg2 = (PySliceObject *) obj1;
6688  }
6689  {
6690  std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
6691  res3 = swig::asptr(obj2, &ptr);
6692  if (!SWIG_IsOK(res3)) {
6693  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'");
6694  }
6695  if (!ptr) {
6696  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'");
6697  }
6698  arg3 = ptr;
6699  }
6700  try {
6701  std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
6702  } catch(std::out_of_range &_e) {
6703  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6704  } catch(std::invalid_argument &_e) {
6705  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6706  }
6707  resultobj = SWIG_Py_Void();
6708  if (SWIG_IsNewObj(res3)) delete arg3;
6709  return resultobj;
6710 fail:
6711  if (SWIG_IsNewObj(res3)) delete arg3;
6712  return NULL;
6713 }
6714 
6715 
6716 SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6717  PyObject *resultobj = 0;
6718  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6719  PySliceObject *arg2 = (PySliceObject *) 0 ;
6720  void *argp1 = 0 ;
6721  int res1 = 0 ;
6722  PyObject * obj0 = 0 ;
6723  PyObject * obj1 = 0 ;
6724 
6725  if (!PyArg_ParseTuple(args,(char *)"OO:StringList___setitem__",&obj0,&obj1)) SWIG_fail;
6726  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6727  if (!SWIG_IsOK(res1)) {
6728  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6729  }
6730  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6731  {
6732  if (!PySlice_Check(obj1)) {
6733  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
6734  }
6735  arg2 = (PySliceObject *) obj1;
6736  }
6737  try {
6738  std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
6739  } catch(std::out_of_range &_e) {
6740  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6741  } catch(std::invalid_argument &_e) {
6742  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6743  }
6744  resultobj = SWIG_Py_Void();
6745  return resultobj;
6746 fail:
6747  return NULL;
6748 }
6749 
6750 
6751 SWIGINTERN PyObject *_wrap_StringList___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6752  PyObject *resultobj = 0;
6753  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6754  PySliceObject *arg2 = (PySliceObject *) 0 ;
6755  void *argp1 = 0 ;
6756  int res1 = 0 ;
6757  PyObject * obj0 = 0 ;
6758  PyObject * obj1 = 0 ;
6759 
6760  if (!PyArg_ParseTuple(args,(char *)"OO:StringList___delitem__",&obj0,&obj1)) SWIG_fail;
6761  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6762  if (!SWIG_IsOK(res1)) {
6763  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6764  }
6765  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6766  {
6767  if (!PySlice_Check(obj1)) {
6768  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
6769  }
6770  arg2 = (PySliceObject *) obj1;
6771  }
6772  try {
6773  std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
6774  } catch(std::out_of_range &_e) {
6775  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6776  } catch(std::invalid_argument &_e) {
6777  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6778  }
6779  resultobj = SWIG_Py_Void();
6780  return resultobj;
6781 fail:
6782  return NULL;
6783 }
6784 
6785 
6786 SWIGINTERN PyObject *_wrap_StringList___delitem__(PyObject *self, PyObject *args) {
6787  Py_ssize_t argc;
6788  PyObject *argv[3] = {
6789  0
6790  };
6791  Py_ssize_t ii;
6792 
6793  if (!PyTuple_Check(args)) SWIG_fail;
6794  argc = PyObject_Length(args);
6795  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6796  argv[ii] = PyTuple_GET_ITEM(args,ii);
6797  }
6798  if (argc == 2) {
6799  int _v;
6800  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6801  _v = SWIG_CheckState(res);
6802  if (_v) {
6803  {
6804  _v = PySlice_Check(argv[1]);
6805  }
6806  if (_v) {
6807  return _wrap_StringList___delitem____SWIG_1(self, args);
6808  }
6809  }
6810  }
6811  if (argc == 2) {
6812  int _v;
6813  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6814  _v = SWIG_CheckState(res);
6815  if (_v) {
6816  {
6817  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6818  _v = SWIG_CheckState(res);
6819  }
6820  if (_v) {
6821  return _wrap_StringList___delitem____SWIG_0(self, args);
6822  }
6823  }
6824  }
6825 
6826 fail:
6827  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList___delitem__'.\n"
6828  " Possible C/C++ prototypes are:\n"
6829  " std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
6830  " std::vector< std::string >::__delitem__(PySliceObject *)\n");
6831  return 0;
6832 }
6833 
6834 
6835 SWIGINTERN PyObject *_wrap_StringList___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6836  PyObject *resultobj = 0;
6837  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6838  std::vector< std::string >::difference_type arg2 ;
6839  void *argp1 = 0 ;
6840  int res1 = 0 ;
6841  ptrdiff_t val2 ;
6842  int ecode2 = 0 ;
6843  PyObject * obj0 = 0 ;
6844  PyObject * obj1 = 0 ;
6845  std::vector< std::string >::value_type *result = 0 ;
6846 
6847  if (!PyArg_ParseTuple(args,(char *)"OO:StringList___getitem__",&obj0,&obj1)) SWIG_fail;
6848  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6849  if (!SWIG_IsOK(res1)) {
6850  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
6851  }
6852  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6853  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6854  if (!SWIG_IsOK(ecode2)) {
6855  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6856  }
6857  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6858  try {
6859  result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,arg2);
6860  } catch(std::out_of_range &_e) {
6861  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6862  }
6863  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
6864  return resultobj;
6865 fail:
6866  return NULL;
6867 }
6868 
6869 
6870 SWIGINTERN PyObject *_wrap_StringList___getitem__(PyObject *self, PyObject *args) {
6871  Py_ssize_t argc;
6872  PyObject *argv[3] = {
6873  0
6874  };
6875  Py_ssize_t ii;
6876 
6877  if (!PyTuple_Check(args)) SWIG_fail;
6878  argc = PyObject_Length(args);
6879  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6880  argv[ii] = PyTuple_GET_ITEM(args,ii);
6881  }
6882  if (argc == 2) {
6883  int _v;
6884  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6885  _v = SWIG_CheckState(res);
6886  if (_v) {
6887  {
6888  _v = PySlice_Check(argv[1]);
6889  }
6890  if (_v) {
6891  return _wrap_StringList___getitem____SWIG_0(self, args);
6892  }
6893  }
6894  }
6895  if (argc == 2) {
6896  int _v;
6897  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6898  _v = SWIG_CheckState(res);
6899  if (_v) {
6900  {
6901  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6902  _v = SWIG_CheckState(res);
6903  }
6904  if (_v) {
6905  return _wrap_StringList___getitem____SWIG_1(self, args);
6906  }
6907  }
6908  }
6909 
6910 fail:
6911  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList___getitem__'.\n"
6912  " Possible C/C++ prototypes are:\n"
6913  " std::vector< std::string >::__getitem__(PySliceObject *)\n"
6914  " std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
6915  return 0;
6916 }
6917 
6918 
6919 SWIGINTERN PyObject *_wrap_StringList___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6920  PyObject *resultobj = 0;
6921  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
6922  std::vector< std::string >::difference_type arg2 ;
6923  std::vector< std::string >::value_type *arg3 = 0 ;
6924  void *argp1 = 0 ;
6925  int res1 = 0 ;
6926  ptrdiff_t val2 ;
6927  int ecode2 = 0 ;
6928  int res3 = SWIG_OLDOBJ ;
6929  PyObject * obj0 = 0 ;
6930  PyObject * obj1 = 0 ;
6931  PyObject * obj2 = 0 ;
6932 
6933  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6934  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
6935  if (!SWIG_IsOK(res1)) {
6936  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'");
6937  }
6938  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
6939  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6940  if (!SWIG_IsOK(ecode2)) {
6941  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
6942  }
6943  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
6944  {
6945  std::string *ptr = (std::string *)0;
6946  res3 = SWIG_AsPtr_std_string(obj2, &ptr);
6947  if (!SWIG_IsOK(res3)) {
6948  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
6949  }
6950  if (!ptr) {
6951  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
6952  }
6953  arg3 = ptr;
6954  }
6955  try {
6956  std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,arg2,(std::string const &)*arg3);
6957  } catch(std::out_of_range &_e) {
6958  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6959  }
6960  resultobj = SWIG_Py_Void();
6961  if (SWIG_IsNewObj(res3)) delete arg3;
6962  return resultobj;
6963 fail:
6964  if (SWIG_IsNewObj(res3)) delete arg3;
6965  return NULL;
6966 }
6967 
6968 
6969 SWIGINTERN PyObject *_wrap_StringList___setitem__(PyObject *self, PyObject *args) {
6970  Py_ssize_t argc;
6971  PyObject *argv[4] = {
6972  0
6973  };
6974  Py_ssize_t ii;
6975 
6976  if (!PyTuple_Check(args)) SWIG_fail;
6977  argc = PyObject_Length(args);
6978  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
6979  argv[ii] = PyTuple_GET_ITEM(args,ii);
6980  }
6981  if (argc == 2) {
6982  int _v;
6983  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6984  _v = SWIG_CheckState(res);
6985  if (_v) {
6986  {
6987  _v = PySlice_Check(argv[1]);
6988  }
6989  if (_v) {
6990  return _wrap_StringList___setitem____SWIG_1(self, args);
6991  }
6992  }
6993  }
6994  if (argc == 3) {
6995  int _v;
6996  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
6997  _v = SWIG_CheckState(res);
6998  if (_v) {
6999  {
7000  _v = PySlice_Check(argv[1]);
7001  }
7002  if (_v) {
7003  int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
7004  _v = SWIG_CheckState(res);
7005  if (_v) {
7006  return _wrap_StringList___setitem____SWIG_0(self, args);
7007  }
7008  }
7009  }
7010  }
7011  if (argc == 3) {
7012  int _v;
7013  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7014  _v = SWIG_CheckState(res);
7015  if (_v) {
7016  {
7017  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7018  _v = SWIG_CheckState(res);
7019  }
7020  if (_v) {
7021  int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
7022  _v = SWIG_CheckState(res);
7023  if (_v) {
7024  return _wrap_StringList___setitem____SWIG_2(self, args);
7025  }
7026  }
7027  }
7028  }
7029 
7030 fail:
7031  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList___setitem__'.\n"
7032  " Possible C/C++ prototypes are:\n"
7033  " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
7034  " std::vector< std::string >::__setitem__(PySliceObject *)\n"
7035  " std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
7036  return 0;
7037 }
7038 
7039 
7040 SWIGINTERN PyObject *_wrap_StringList_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7041  PyObject *resultobj = 0;
7042  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7043  void *argp1 = 0 ;
7044  int res1 = 0 ;
7045  PyObject * obj0 = 0 ;
7046  std::vector< std::string >::value_type result;
7047 
7048  if (!PyArg_ParseTuple(args,(char *)"O:StringList_pop",&obj0)) SWIG_fail;
7049  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7050  if (!SWIG_IsOK(res1)) {
7051  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7052  }
7053  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7054  try {
7055  result = std_vector_Sl_std_string_Sg__pop(arg1);
7056  } catch(std::out_of_range &_e) {
7057  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7058  }
7059  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
7060  return resultobj;
7061 fail:
7062  return NULL;
7063 }
7064 
7065 
7066 SWIGINTERN PyObject *_wrap_StringList_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7067  PyObject *resultobj = 0;
7068  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7069  std::vector< std::string >::value_type *arg2 = 0 ;
7070  void *argp1 = 0 ;
7071  int res1 = 0 ;
7072  int res2 = SWIG_OLDOBJ ;
7073  PyObject * obj0 = 0 ;
7074  PyObject * obj1 = 0 ;
7075 
7076  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_append",&obj0,&obj1)) SWIG_fail;
7077  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7078  if (!SWIG_IsOK(res1)) {
7079  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_append" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7080  }
7081  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7082  {
7083  std::string *ptr = (std::string *)0;
7084  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7085  if (!SWIG_IsOK(res2)) {
7086  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7087  }
7088  if (!ptr) {
7089  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7090  }
7091  arg2 = ptr;
7092  }
7093  std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
7094  resultobj = SWIG_Py_Void();
7095  if (SWIG_IsNewObj(res2)) delete arg2;
7096  return resultobj;
7097 fail:
7098  if (SWIG_IsNewObj(res2)) delete arg2;
7099  return NULL;
7100 }
7101 
7102 
7103 SWIGINTERN PyObject *_wrap_new_StringList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7104  PyObject *resultobj = 0;
7105  std::vector< std::string > *result = 0 ;
7106 
7107  if (!PyArg_ParseTuple(args,(char *)":new_StringList")) SWIG_fail;
7108  result = (std::vector< std::string > *)new std::vector< std::string >();
7109  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW | 0 );
7110  return resultobj;
7111 fail:
7112  return NULL;
7113 }
7114 
7115 
7116 SWIGINTERN PyObject *_wrap_new_StringList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7117  PyObject *resultobj = 0;
7118  std::vector< std::string > *arg1 = 0 ;
7119  int res1 = SWIG_OLDOBJ ;
7120  PyObject * obj0 = 0 ;
7121  std::vector< std::string > *result = 0 ;
7122 
7123  if (!PyArg_ParseTuple(args,(char *)"O:new_StringList",&obj0)) SWIG_fail;
7124  {
7125  std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
7126  res1 = swig::asptr(obj0, &ptr);
7127  if (!SWIG_IsOK(res1)) {
7128  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::vector< std::string > const &""'");
7129  }
7130  if (!ptr) {
7131  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringList" "', argument " "1"" of type '" "std::vector< std::string > const &""'");
7132  }
7133  arg1 = ptr;
7134  }
7135  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
7136  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW | 0 );
7137  if (SWIG_IsNewObj(res1)) delete arg1;
7138  return resultobj;
7139 fail:
7140  if (SWIG_IsNewObj(res1)) delete arg1;
7141  return NULL;
7142 }
7143 
7144 
7145 SWIGINTERN PyObject *_wrap_StringList_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7146  PyObject *resultobj = 0;
7147  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7148  void *argp1 = 0 ;
7149  int res1 = 0 ;
7150  PyObject * obj0 = 0 ;
7151  bool result;
7152 
7153  if (!PyArg_ParseTuple(args,(char *)"O:StringList_empty",&obj0)) SWIG_fail;
7154  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7155  if (!SWIG_IsOK(res1)) {
7156  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
7157  }
7158  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7159  result = (bool)((std::vector< std::string > const *)arg1)->empty();
7160  resultobj = SWIG_From_bool(static_cast< bool >(result));
7161  return resultobj;
7162 fail:
7163  return NULL;
7164 }
7165 
7166 
7167 SWIGINTERN PyObject *_wrap_StringList_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7168  PyObject *resultobj = 0;
7169  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7170  void *argp1 = 0 ;
7171  int res1 = 0 ;
7172  PyObject * obj0 = 0 ;
7173  std::vector< std::string >::size_type result;
7174 
7175  if (!PyArg_ParseTuple(args,(char *)"O:StringList_size",&obj0)) SWIG_fail;
7176  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7177  if (!SWIG_IsOK(res1)) {
7178  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
7179  }
7180  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7181  result = ((std::vector< std::string > const *)arg1)->size();
7182  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7183  return resultobj;
7184 fail:
7185  return NULL;
7186 }
7187 
7188 
7189 SWIGINTERN PyObject *_wrap_StringList_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7190  PyObject *resultobj = 0;
7191  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7192  std::vector< std::string > *arg2 = 0 ;
7193  void *argp1 = 0 ;
7194  int res1 = 0 ;
7195  void *argp2 = 0 ;
7196  int res2 = 0 ;
7197  PyObject * obj0 = 0 ;
7198  PyObject * obj1 = 0 ;
7199 
7200  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_swap",&obj0,&obj1)) SWIG_fail;
7201  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7202  if (!SWIG_IsOK(res1)) {
7203  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7204  }
7205  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7206  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 );
7207  if (!SWIG_IsOK(res2)) {
7208  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'");
7209  }
7210  if (!argp2) {
7211  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'");
7212  }
7213  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
7214  (arg1)->swap(*arg2);
7215  resultobj = SWIG_Py_Void();
7216  return resultobj;
7217 fail:
7218  return NULL;
7219 }
7220 
7221 
7222 SWIGINTERN PyObject *_wrap_StringList_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7223  PyObject *resultobj = 0;
7224  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7225  void *argp1 = 0 ;
7226  int res1 = 0 ;
7227  PyObject * obj0 = 0 ;
7228  std::vector< std::string >::iterator result;
7229 
7230  if (!PyArg_ParseTuple(args,(char *)"O:StringList_begin",&obj0)) SWIG_fail;
7231  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7232  if (!SWIG_IsOK(res1)) {
7233  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7234  }
7235  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7236  result = (arg1)->begin();
7237  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
7238  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7239  return resultobj;
7240 fail:
7241  return NULL;
7242 }
7243 
7244 
7245 SWIGINTERN PyObject *_wrap_StringList_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7246  PyObject *resultobj = 0;
7247  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7248  void *argp1 = 0 ;
7249  int res1 = 0 ;
7250  PyObject * obj0 = 0 ;
7251  std::vector< std::string >::iterator result;
7252 
7253  if (!PyArg_ParseTuple(args,(char *)"O:StringList_end",&obj0)) SWIG_fail;
7254  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7255  if (!SWIG_IsOK(res1)) {
7256  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_end" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7257  }
7258  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7259  result = (arg1)->end();
7260  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
7261  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7262  return resultobj;
7263 fail:
7264  return NULL;
7265 }
7266 
7267 
7268 SWIGINTERN PyObject *_wrap_StringList_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7269  PyObject *resultobj = 0;
7270  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7271  void *argp1 = 0 ;
7272  int res1 = 0 ;
7273  PyObject * obj0 = 0 ;
7274  std::vector< std::string >::reverse_iterator result;
7275 
7276  if (!PyArg_ParseTuple(args,(char *)"O:StringList_rbegin",&obj0)) SWIG_fail;
7277  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7278  if (!SWIG_IsOK(res1)) {
7279  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7280  }
7281  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7282  result = (arg1)->rbegin();
7283  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
7284  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7285  return resultobj;
7286 fail:
7287  return NULL;
7288 }
7289 
7290 
7291 SWIGINTERN PyObject *_wrap_StringList_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7292  PyObject *resultobj = 0;
7293  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7294  void *argp1 = 0 ;
7295  int res1 = 0 ;
7296  PyObject * obj0 = 0 ;
7297  std::vector< std::string >::reverse_iterator result;
7298 
7299  if (!PyArg_ParseTuple(args,(char *)"O:StringList_rend",&obj0)) SWIG_fail;
7300  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7301  if (!SWIG_IsOK(res1)) {
7302  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7303  }
7304  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7305  result = (arg1)->rend();
7306  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
7307  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7308  return resultobj;
7309 fail:
7310  return NULL;
7311 }
7312 
7313 
7314 SWIGINTERN PyObject *_wrap_StringList_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7315  PyObject *resultobj = 0;
7316  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7317  void *argp1 = 0 ;
7318  int res1 = 0 ;
7319  PyObject * obj0 = 0 ;
7320 
7321  if (!PyArg_ParseTuple(args,(char *)"O:StringList_clear",&obj0)) SWIG_fail;
7322  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7323  if (!SWIG_IsOK(res1)) {
7324  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7325  }
7326  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7327  (arg1)->clear();
7328  resultobj = SWIG_Py_Void();
7329  return resultobj;
7330 fail:
7331  return NULL;
7332 }
7333 
7334 
7335 SWIGINTERN PyObject *_wrap_StringList_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7336  PyObject *resultobj = 0;
7337  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7338  void *argp1 = 0 ;
7339  int res1 = 0 ;
7340  PyObject * obj0 = 0 ;
7341  SwigValueWrapper< std::allocator< std::string > > result;
7342 
7343  if (!PyArg_ParseTuple(args,(char *)"O:StringList_get_allocator",&obj0)) SWIG_fail;
7344  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7345  if (!SWIG_IsOK(res1)) {
7346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
7347  }
7348  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7349  result = ((std::vector< std::string > const *)arg1)->get_allocator();
7350  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN | 0 );
7351  return resultobj;
7352 fail:
7353  return NULL;
7354 }
7355 
7356 
7357 SWIGINTERN PyObject *_wrap_new_StringList__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7358  PyObject *resultobj = 0;
7359  std::vector< std::string >::size_type arg1 ;
7360  size_t val1 ;
7361  int ecode1 = 0 ;
7362  PyObject * obj0 = 0 ;
7363  std::vector< std::string > *result = 0 ;
7364 
7365  if (!PyArg_ParseTuple(args,(char *)"O:new_StringList",&obj0)) SWIG_fail;
7366  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7367  if (!SWIG_IsOK(ecode1)) {
7368  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
7369  }
7370  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
7371  result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
7372  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW | 0 );
7373  return resultobj;
7374 fail:
7375  return NULL;
7376 }
7377 
7378 
7379 SWIGINTERN PyObject *_wrap_StringList_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380  PyObject *resultobj = 0;
7381  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7382  void *argp1 = 0 ;
7383  int res1 = 0 ;
7384  PyObject * obj0 = 0 ;
7385 
7386  if (!PyArg_ParseTuple(args,(char *)"O:StringList_pop_back",&obj0)) SWIG_fail;
7387  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7388  if (!SWIG_IsOK(res1)) {
7389  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7390  }
7391  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7392  (arg1)->pop_back();
7393  resultobj = SWIG_Py_Void();
7394  return resultobj;
7395 fail:
7396  return NULL;
7397 }
7398 
7399 
7400 SWIGINTERN PyObject *_wrap_StringList_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401  PyObject *resultobj = 0;
7402  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7403  std::vector< std::string >::size_type arg2 ;
7404  void *argp1 = 0 ;
7405  int res1 = 0 ;
7406  size_t val2 ;
7407  int ecode2 = 0 ;
7408  PyObject * obj0 = 0 ;
7409  PyObject * obj1 = 0 ;
7410 
7411  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_resize",&obj0,&obj1)) SWIG_fail;
7412  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7413  if (!SWIG_IsOK(res1)) {
7414  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7415  }
7416  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7417  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7418  if (!SWIG_IsOK(ecode2)) {
7419  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
7420  }
7421  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
7422  (arg1)->resize(arg2);
7423  resultobj = SWIG_Py_Void();
7424  return resultobj;
7425 fail:
7426  return NULL;
7427 }
7428 
7429 
7430 SWIGINTERN PyObject *_wrap_StringList_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7431  PyObject *resultobj = 0;
7432  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7433  std::vector< std::string >::iterator arg2 ;
7434  void *argp1 = 0 ;
7435  int res1 = 0 ;
7436  swig::SwigPyIterator *iter2 = 0 ;
7437  int res2 ;
7438  PyObject * obj0 = 0 ;
7439  PyObject * obj1 = 0 ;
7440  std::vector< std::string >::iterator result;
7441 
7442  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_erase",&obj0,&obj1)) SWIG_fail;
7443  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7444  if (!SWIG_IsOK(res1)) {
7445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7446  }
7447  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7448  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7449  if (!SWIG_IsOK(res2) || !iter2) {
7450  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7451  } else {
7453  if (iter_t) {
7454  arg2 = iter_t->get_current();
7455  } else {
7456  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7457  }
7458  }
7459  result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,arg2);
7460  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
7461  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7462  return resultobj;
7463 fail:
7464  return NULL;
7465 }
7466 
7467 
7468 SWIGINTERN PyObject *_wrap_StringList_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7469  PyObject *resultobj = 0;
7470  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7471  std::vector< std::string >::iterator arg2 ;
7472  std::vector< std::string >::iterator arg3 ;
7473  void *argp1 = 0 ;
7474  int res1 = 0 ;
7475  swig::SwigPyIterator *iter2 = 0 ;
7476  int res2 ;
7477  swig::SwigPyIterator *iter3 = 0 ;
7478  int res3 ;
7479  PyObject * obj0 = 0 ;
7480  PyObject * obj1 = 0 ;
7481  PyObject * obj2 = 0 ;
7482  std::vector< std::string >::iterator result;
7483 
7484  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList_erase",&obj0,&obj1,&obj2)) SWIG_fail;
7485  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7486  if (!SWIG_IsOK(res1)) {
7487  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7488  }
7489  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7490  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7491  if (!SWIG_IsOK(res2) || !iter2) {
7492  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7493  } else {
7495  if (iter_t) {
7496  arg2 = iter_t->get_current();
7497  } else {
7498  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7499  }
7500  }
7501  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
7502  if (!SWIG_IsOK(res3) || !iter3) {
7503  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
7504  } else {
7506  if (iter_t) {
7507  arg3 = iter_t->get_current();
7508  } else {
7509  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
7510  }
7511  }
7512  result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,arg2,arg3);
7513  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
7514  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7515  return resultobj;
7516 fail:
7517  return NULL;
7518 }
7519 
7520 
7521 SWIGINTERN PyObject *_wrap_StringList_erase(PyObject *self, PyObject *args) {
7522  Py_ssize_t argc;
7523  PyObject *argv[4] = {
7524  0
7525  };
7526  Py_ssize_t ii;
7527 
7528  if (!PyTuple_Check(args)) SWIG_fail;
7529  argc = PyObject_Length(args);
7530  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
7531  argv[ii] = PyTuple_GET_ITEM(args,ii);
7532  }
7533  if (argc == 2) {
7534  int _v;
7535  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7536  _v = SWIG_CheckState(res);
7537  if (_v) {
7538  swig::SwigPyIterator *iter = 0;
7539  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
7540  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
7541  if (_v) {
7542  return _wrap_StringList_erase__SWIG_0(self, args);
7543  }
7544  }
7545  }
7546  if (argc == 3) {
7547  int _v;
7548  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7549  _v = SWIG_CheckState(res);
7550  if (_v) {
7551  swig::SwigPyIterator *iter = 0;
7552  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
7553  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
7554  if (_v) {
7555  swig::SwigPyIterator *iter = 0;
7556  int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
7557  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
7558  if (_v) {
7559  return _wrap_StringList_erase__SWIG_1(self, args);
7560  }
7561  }
7562  }
7563  }
7564 
7565 fail:
7566  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList_erase'.\n"
7567  " Possible C/C++ prototypes are:\n"
7568  " std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
7569  " std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
7570  return 0;
7571 }
7572 
7573 
7574 SWIGINTERN PyObject *_wrap_new_StringList__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7575  PyObject *resultobj = 0;
7576  std::vector< std::string >::size_type arg1 ;
7577  std::vector< std::string >::value_type *arg2 = 0 ;
7578  size_t val1 ;
7579  int ecode1 = 0 ;
7580  int res2 = SWIG_OLDOBJ ;
7581  PyObject * obj0 = 0 ;
7582  PyObject * obj1 = 0 ;
7583  std::vector< std::string > *result = 0 ;
7584 
7585  if (!PyArg_ParseTuple(args,(char *)"OO:new_StringList",&obj0,&obj1)) SWIG_fail;
7586  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7587  if (!SWIG_IsOK(ecode1)) {
7588  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringList" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
7589  }
7590  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
7591  {
7592  std::string *ptr = (std::string *)0;
7593  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7594  if (!SWIG_IsOK(res2)) {
7595  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StringList" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7596  }
7597  if (!ptr) {
7598  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringList" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7599  }
7600  arg2 = ptr;
7601  }
7602  result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
7603  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW | 0 );
7604  if (SWIG_IsNewObj(res2)) delete arg2;
7605  return resultobj;
7606 fail:
7607  if (SWIG_IsNewObj(res2)) delete arg2;
7608  return NULL;
7609 }
7610 
7611 
7612 SWIGINTERN PyObject *_wrap_new_StringList(PyObject *self, PyObject *args) {
7613  Py_ssize_t argc;
7614  PyObject *argv[3] = {
7615  0
7616  };
7617  Py_ssize_t ii;
7618 
7619  if (!PyTuple_Check(args)) SWIG_fail;
7620  argc = PyObject_Length(args);
7621  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
7622  argv[ii] = PyTuple_GET_ITEM(args,ii);
7623  }
7624  if (argc == 0) {
7625  return _wrap_new_StringList__SWIG_0(self, args);
7626  }
7627  if (argc == 1) {
7628  int _v;
7629  {
7630  int res = SWIG_AsVal_size_t(argv[0], NULL);
7631  _v = SWIG_CheckState(res);
7632  }
7633  if (_v) {
7634  return _wrap_new_StringList__SWIG_2(self, args);
7635  }
7636  }
7637  if (argc == 1) {
7638  int _v;
7639  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7640  _v = SWIG_CheckState(res);
7641  if (_v) {
7642  return _wrap_new_StringList__SWIG_1(self, args);
7643  }
7644  }
7645  if (argc == 2) {
7646  int _v;
7647  {
7648  int res = SWIG_AsVal_size_t(argv[0], NULL);
7649  _v = SWIG_CheckState(res);
7650  }
7651  if (_v) {
7652  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7653  _v = SWIG_CheckState(res);
7654  if (_v) {
7655  return _wrap_new_StringList__SWIG_3(self, args);
7656  }
7657  }
7658  }
7659 
7660 fail:
7661  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StringList'.\n"
7662  " Possible C/C++ prototypes are:\n"
7663  " std::vector< std::string >::vector()\n"
7664  " std::vector< std::string >::vector(std::vector< std::string > const &)\n"
7665  " std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
7666  " std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
7667  return 0;
7668 }
7669 
7670 
7671 SWIGINTERN PyObject *_wrap_StringList_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7672  PyObject *resultobj = 0;
7673  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7674  std::vector< std::string >::value_type *arg2 = 0 ;
7675  void *argp1 = 0 ;
7676  int res1 = 0 ;
7677  int res2 = SWIG_OLDOBJ ;
7678  PyObject * obj0 = 0 ;
7679  PyObject * obj1 = 0 ;
7680 
7681  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_push_back",&obj0,&obj1)) SWIG_fail;
7682  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7683  if (!SWIG_IsOK(res1)) {
7684  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7685  }
7686  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7687  {
7688  std::string *ptr = (std::string *)0;
7689  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7690  if (!SWIG_IsOK(res2)) {
7691  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringList_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7692  }
7693  if (!ptr) {
7694  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'");
7695  }
7696  arg2 = ptr;
7697  }
7698  (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
7699  resultobj = SWIG_Py_Void();
7700  if (SWIG_IsNewObj(res2)) delete arg2;
7701  return resultobj;
7702 fail:
7703  if (SWIG_IsNewObj(res2)) delete arg2;
7704  return NULL;
7705 }
7706 
7707 
7708 SWIGINTERN PyObject *_wrap_StringList_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709  PyObject *resultobj = 0;
7710  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7711  void *argp1 = 0 ;
7712  int res1 = 0 ;
7713  PyObject * obj0 = 0 ;
7714  std::vector< std::string >::value_type *result = 0 ;
7715 
7716  if (!PyArg_ParseTuple(args,(char *)"O:StringList_front",&obj0)) SWIG_fail;
7717  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7718  if (!SWIG_IsOK(res1)) {
7719  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
7720  }
7721  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7722  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
7723  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
7724  return resultobj;
7725 fail:
7726  return NULL;
7727 }
7728 
7729 
7730 SWIGINTERN PyObject *_wrap_StringList_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7731  PyObject *resultobj = 0;
7732  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7733  void *argp1 = 0 ;
7734  int res1 = 0 ;
7735  PyObject * obj0 = 0 ;
7736  std::vector< std::string >::value_type *result = 0 ;
7737 
7738  if (!PyArg_ParseTuple(args,(char *)"O:StringList_back",&obj0)) SWIG_fail;
7739  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7740  if (!SWIG_IsOK(res1)) {
7741  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
7742  }
7743  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7744  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
7745  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
7746  return resultobj;
7747 fail:
7748  return NULL;
7749 }
7750 
7751 
7752 SWIGINTERN PyObject *_wrap_StringList_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7753  PyObject *resultobj = 0;
7754  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7755  std::vector< std::string >::size_type arg2 ;
7756  std::vector< std::string >::value_type *arg3 = 0 ;
7757  void *argp1 = 0 ;
7758  int res1 = 0 ;
7759  size_t val2 ;
7760  int ecode2 = 0 ;
7761  int res3 = SWIG_OLDOBJ ;
7762  PyObject * obj0 = 0 ;
7763  PyObject * obj1 = 0 ;
7764  PyObject * obj2 = 0 ;
7765 
7766  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList_assign",&obj0,&obj1,&obj2)) SWIG_fail;
7767  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7768  if (!SWIG_IsOK(res1)) {
7769  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7770  }
7771  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7772  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7773  if (!SWIG_IsOK(ecode2)) {
7774  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
7775  }
7776  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
7777  {
7778  std::string *ptr = (std::string *)0;
7779  res3 = SWIG_AsPtr_std_string(obj2, &ptr);
7780  if (!SWIG_IsOK(res3)) {
7781  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7782  }
7783  if (!ptr) {
7784  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7785  }
7786  arg3 = ptr;
7787  }
7788  (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
7789  resultobj = SWIG_Py_Void();
7790  if (SWIG_IsNewObj(res3)) delete arg3;
7791  return resultobj;
7792 fail:
7793  if (SWIG_IsNewObj(res3)) delete arg3;
7794  return NULL;
7795 }
7796 
7797 
7798 SWIGINTERN PyObject *_wrap_StringList_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7799  PyObject *resultobj = 0;
7800  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7801  std::vector< std::string >::size_type arg2 ;
7802  std::vector< std::string >::value_type *arg3 = 0 ;
7803  void *argp1 = 0 ;
7804  int res1 = 0 ;
7805  size_t val2 ;
7806  int ecode2 = 0 ;
7807  int res3 = SWIG_OLDOBJ ;
7808  PyObject * obj0 = 0 ;
7809  PyObject * obj1 = 0 ;
7810  PyObject * obj2 = 0 ;
7811 
7812  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList_resize",&obj0,&obj1,&obj2)) SWIG_fail;
7813  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7814  if (!SWIG_IsOK(res1)) {
7815  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7816  }
7817  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7818  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7819  if (!SWIG_IsOK(ecode2)) {
7820  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
7821  }
7822  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
7823  {
7824  std::string *ptr = (std::string *)0;
7825  res3 = SWIG_AsPtr_std_string(obj2, &ptr);
7826  if (!SWIG_IsOK(res3)) {
7827  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7828  }
7829  if (!ptr) {
7830  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7831  }
7832  arg3 = ptr;
7833  }
7834  (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
7835  resultobj = SWIG_Py_Void();
7836  if (SWIG_IsNewObj(res3)) delete arg3;
7837  return resultobj;
7838 fail:
7839  if (SWIG_IsNewObj(res3)) delete arg3;
7840  return NULL;
7841 }
7842 
7843 
7844 SWIGINTERN PyObject *_wrap_StringList_resize(PyObject *self, PyObject *args) {
7845  Py_ssize_t argc;
7846  PyObject *argv[4] = {
7847  0
7848  };
7849  Py_ssize_t ii;
7850 
7851  if (!PyTuple_Check(args)) SWIG_fail;
7852  argc = PyObject_Length(args);
7853  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
7854  argv[ii] = PyTuple_GET_ITEM(args,ii);
7855  }
7856  if (argc == 2) {
7857  int _v;
7858  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7859  _v = SWIG_CheckState(res);
7860  if (_v) {
7861  {
7862  int res = SWIG_AsVal_size_t(argv[1], NULL);
7863  _v = SWIG_CheckState(res);
7864  }
7865  if (_v) {
7866  return _wrap_StringList_resize__SWIG_0(self, args);
7867  }
7868  }
7869  }
7870  if (argc == 3) {
7871  int _v;
7872  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
7873  _v = SWIG_CheckState(res);
7874  if (_v) {
7875  {
7876  int res = SWIG_AsVal_size_t(argv[1], NULL);
7877  _v = SWIG_CheckState(res);
7878  }
7879  if (_v) {
7880  int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
7881  _v = SWIG_CheckState(res);
7882  if (_v) {
7883  return _wrap_StringList_resize__SWIG_1(self, args);
7884  }
7885  }
7886  }
7887  }
7888 
7889 fail:
7890  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList_resize'.\n"
7891  " Possible C/C++ prototypes are:\n"
7892  " std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
7893  " std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
7894  return 0;
7895 }
7896 
7897 
7898 SWIGINTERN PyObject *_wrap_StringList_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899  PyObject *resultobj = 0;
7900  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7901  std::vector< std::string >::iterator arg2 ;
7902  std::vector< std::string >::value_type *arg3 = 0 ;
7903  void *argp1 = 0 ;
7904  int res1 = 0 ;
7905  swig::SwigPyIterator *iter2 = 0 ;
7906  int res2 ;
7907  int res3 = SWIG_OLDOBJ ;
7908  PyObject * obj0 = 0 ;
7909  PyObject * obj1 = 0 ;
7910  PyObject * obj2 = 0 ;
7911  std::vector< std::string >::iterator result;
7912 
7913  if (!PyArg_ParseTuple(args,(char *)"OOO:StringList_insert",&obj0,&obj1,&obj2)) SWIG_fail;
7914  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7915  if (!SWIG_IsOK(res1)) {
7916  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7917  }
7918  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7919  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7920  if (!SWIG_IsOK(res2) || !iter2) {
7921  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7922  } else {
7924  if (iter_t) {
7925  arg2 = iter_t->get_current();
7926  } else {
7927  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7928  }
7929  }
7930  {
7931  std::string *ptr = (std::string *)0;
7932  res3 = SWIG_AsPtr_std_string(obj2, &ptr);
7933  if (!SWIG_IsOK(res3)) {
7934  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringList_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7935  }
7936  if (!ptr) {
7937  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'");
7938  }
7939  arg3 = ptr;
7940  }
7941  result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,arg2,(std::string const &)*arg3);
7942  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
7943  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7944  if (SWIG_IsNewObj(res3)) delete arg3;
7945  return resultobj;
7946 fail:
7947  if (SWIG_IsNewObj(res3)) delete arg3;
7948  return NULL;
7949 }
7950 
7951 
7952 SWIGINTERN PyObject *_wrap_StringList_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7953  PyObject *resultobj = 0;
7954  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
7955  std::vector< std::string >::iterator arg2 ;
7956  std::vector< std::string >::size_type arg3 ;
7957  std::vector< std::string >::value_type *arg4 = 0 ;
7958  void *argp1 = 0 ;
7959  int res1 = 0 ;
7960  swig::SwigPyIterator *iter2 = 0 ;
7961  int res2 ;
7962  size_t val3 ;
7963  int ecode3 = 0 ;
7964  int res4 = SWIG_OLDOBJ ;
7965  PyObject * obj0 = 0 ;
7966  PyObject * obj1 = 0 ;
7967  PyObject * obj2 = 0 ;
7968  PyObject * obj3 = 0 ;
7969 
7970  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringList_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7971  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
7972  if (!SWIG_IsOK(res1)) {
7973  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'");
7974  }
7975  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
7976  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7977  if (!SWIG_IsOK(res2) || !iter2) {
7978  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7979  } else {
7981  if (iter_t) {
7982  arg2 = iter_t->get_current();
7983  } else {
7984  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringList_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
7985  }
7986  }
7987  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
7988  if (!SWIG_IsOK(ecode3)) {
7989  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringList_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
7990  }
7991  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
7992  {
7993  std::string *ptr = (std::string *)0;
7994  res4 = SWIG_AsPtr_std_string(obj3, &ptr);
7995  if (!SWIG_IsOK(res4)) {
7996  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringList_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'");
7997  }
7998  if (!ptr) {
7999  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringList_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'");
8000  }
8001  arg4 = ptr;
8002  }
8003  std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,arg2,arg3,(std::string const &)*arg4);
8004  resultobj = SWIG_Py_Void();
8005  if (SWIG_IsNewObj(res4)) delete arg4;
8006  return resultobj;
8007 fail:
8008  if (SWIG_IsNewObj(res4)) delete arg4;
8009  return NULL;
8010 }
8011 
8012 
8013 SWIGINTERN PyObject *_wrap_StringList_insert(PyObject *self, PyObject *args) {
8014  Py_ssize_t argc;
8015  PyObject *argv[5] = {
8016  0
8017  };
8018  Py_ssize_t ii;
8019 
8020  if (!PyTuple_Check(args)) SWIG_fail;
8021  argc = PyObject_Length(args);
8022  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8023  argv[ii] = PyTuple_GET_ITEM(args,ii);
8024  }
8025  if (argc == 3) {
8026  int _v;
8027  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
8028  _v = SWIG_CheckState(res);
8029  if (_v) {
8030  swig::SwigPyIterator *iter = 0;
8031  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8032  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
8033  if (_v) {
8034  int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
8035  _v = SWIG_CheckState(res);
8036  if (_v) {
8037  return _wrap_StringList_insert__SWIG_0(self, args);
8038  }
8039  }
8040  }
8041  }
8042  if (argc == 4) {
8043  int _v;
8044  int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
8045  _v = SWIG_CheckState(res);
8046  if (_v) {
8047  swig::SwigPyIterator *iter = 0;
8048  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8049  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
8050  if (_v) {
8051  {
8052  int res = SWIG_AsVal_size_t(argv[2], NULL);
8053  _v = SWIG_CheckState(res);
8054  }
8055  if (_v) {
8056  int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
8057  _v = SWIG_CheckState(res);
8058  if (_v) {
8059  return _wrap_StringList_insert__SWIG_1(self, args);
8060  }
8061  }
8062  }
8063  }
8064  }
8065 
8066 fail:
8067  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringList_insert'.\n"
8068  " Possible C/C++ prototypes are:\n"
8069  " std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
8070  " std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
8071  return 0;
8072 }
8073 
8074 
8075 SWIGINTERN PyObject *_wrap_StringList_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8076  PyObject *resultobj = 0;
8077  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
8078  std::vector< std::string >::size_type arg2 ;
8079  void *argp1 = 0 ;
8080  int res1 = 0 ;
8081  size_t val2 ;
8082  int ecode2 = 0 ;
8083  PyObject * obj0 = 0 ;
8084  PyObject * obj1 = 0 ;
8085 
8086  if (!PyArg_ParseTuple(args,(char *)"OO:StringList_reserve",&obj0,&obj1)) SWIG_fail;
8087  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
8088  if (!SWIG_IsOK(res1)) {
8089  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'");
8090  }
8091  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
8092  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8093  if (!SWIG_IsOK(ecode2)) {
8094  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringList_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
8095  }
8096  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
8097  (arg1)->reserve(arg2);
8098  resultobj = SWIG_Py_Void();
8099  return resultobj;
8100 fail:
8101  return NULL;
8102 }
8103 
8104 
8105 SWIGINTERN PyObject *_wrap_StringList_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8106  PyObject *resultobj = 0;
8107  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
8108  void *argp1 = 0 ;
8109  int res1 = 0 ;
8110  PyObject * obj0 = 0 ;
8111  std::vector< std::string >::size_type result;
8112 
8113  if (!PyArg_ParseTuple(args,(char *)"O:StringList_capacity",&obj0)) SWIG_fail;
8114  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
8115  if (!SWIG_IsOK(res1)) {
8116  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'");
8117  }
8118  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
8119  result = ((std::vector< std::string > const *)arg1)->capacity();
8120  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8121  return resultobj;
8122 fail:
8123  return NULL;
8124 }
8125 
8126 
8127 SWIGINTERN PyObject *_wrap_delete_StringList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8128  PyObject *resultobj = 0;
8129  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
8130  void *argp1 = 0 ;
8131  int res1 = 0 ;
8132  PyObject * obj0 = 0 ;
8133 
8134  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringList",&obj0)) SWIG_fail;
8135  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN | 0 );
8136  if (!SWIG_IsOK(res1)) {
8137  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringList" "', argument " "1"" of type '" "std::vector< std::string > *""'");
8138  }
8139  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
8140  delete arg1;
8141  resultobj = SWIG_Py_Void();
8142  return resultobj;
8143 fail:
8144  return NULL;
8145 }
8146 
8147 
8148 SWIGINTERN PyObject *StringList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8149  PyObject *obj;
8150  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
8151  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_NewClientData(obj));
8152  return SWIG_Py_Void();
8153 }
8154 
8155 SWIGINTERN PyObject *_wrap_VecDouble_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156  PyObject *resultobj = 0;
8157  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8158  PyObject **arg2 = (PyObject **) 0 ;
8159  void *argp1 = 0 ;
8160  int res1 = 0 ;
8161  PyObject * obj0 = 0 ;
8162  swig::SwigPyIterator *result = 0 ;
8163 
8164  arg2 = &obj0;
8165  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_iterator",&obj0)) SWIG_fail;
8166  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8167  if (!SWIG_IsOK(res1)) {
8168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
8169  }
8170  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8171  result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
8172  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
8173  return resultobj;
8174 fail:
8175  return NULL;
8176 }
8177 
8178 
8179 SWIGINTERN PyObject *_wrap_VecDouble___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8180  PyObject *resultobj = 0;
8181  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8182  void *argp1 = 0 ;
8183  int res1 = 0 ;
8184  PyObject * obj0 = 0 ;
8185  bool result;
8186 
8187  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble___nonzero__",&obj0)) SWIG_fail;
8188  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8189  if (!SWIG_IsOK(res1)) {
8190  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
8191  }
8192  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8193  result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
8194  resultobj = SWIG_From_bool(static_cast< bool >(result));
8195  return resultobj;
8196 fail:
8197  return NULL;
8198 }
8199 
8200 
8201 SWIGINTERN PyObject *_wrap_VecDouble___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8202  PyObject *resultobj = 0;
8203  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8204  void *argp1 = 0 ;
8205  int res1 = 0 ;
8206  PyObject * obj0 = 0 ;
8207  bool result;
8208 
8209  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble___bool__",&obj0)) SWIG_fail;
8210  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8211  if (!SWIG_IsOK(res1)) {
8212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
8213  }
8214  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8215  result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
8216  resultobj = SWIG_From_bool(static_cast< bool >(result));
8217  return resultobj;
8218 fail:
8219  return NULL;
8220 }
8221 
8222 
8223 SWIGINTERN PyObject *_wrap_VecDouble___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224  PyObject *resultobj = 0;
8225  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8226  void *argp1 = 0 ;
8227  int res1 = 0 ;
8228  PyObject * obj0 = 0 ;
8229  std::vector< double >::size_type result;
8230 
8231  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble___len__",&obj0)) SWIG_fail;
8232  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8233  if (!SWIG_IsOK(res1)) {
8234  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
8235  }
8236  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8237  result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
8238  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8239  return resultobj;
8240 fail:
8241  return NULL;
8242 }
8243 
8244 
8245 SWIGINTERN PyObject *_wrap_VecDouble___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8246  PyObject *resultobj = 0;
8247  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8248  std::vector< double >::difference_type arg2 ;
8249  std::vector< double >::difference_type arg3 ;
8250  void *argp1 = 0 ;
8251  int res1 = 0 ;
8252  ptrdiff_t val2 ;
8253  int ecode2 = 0 ;
8254  ptrdiff_t val3 ;
8255  int ecode3 = 0 ;
8256  PyObject * obj0 = 0 ;
8257  PyObject * obj1 = 0 ;
8258  PyObject * obj2 = 0 ;
8259  std::vector< double,std::allocator< double > > *result = 0 ;
8260 
8261  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8262  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8263  if (!SWIG_IsOK(res1)) {
8264  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
8265  }
8266  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8267  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8268  if (!SWIG_IsOK(ecode2)) {
8269  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8270  }
8271  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8272  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8273  if (!SWIG_IsOK(ecode3)) {
8274  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
8275  }
8276  arg3 = static_cast< std::vector< double >::difference_type >(val3);
8277  try {
8278  result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
8279  } catch(std::out_of_range &_e) {
8280  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8281  } catch(std::invalid_argument &_e) {
8282  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8283  }
8284  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
8285  return resultobj;
8286 fail:
8287  return NULL;
8288 }
8289 
8290 
8291 SWIGINTERN PyObject *_wrap_VecDouble___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8292  PyObject *resultobj = 0;
8293  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8294  std::vector< double >::difference_type arg2 ;
8295  std::vector< double >::difference_type arg3 ;
8296  void *argp1 = 0 ;
8297  int res1 = 0 ;
8298  ptrdiff_t val2 ;
8299  int ecode2 = 0 ;
8300  ptrdiff_t val3 ;
8301  int ecode3 = 0 ;
8302  PyObject * obj0 = 0 ;
8303  PyObject * obj1 = 0 ;
8304  PyObject * obj2 = 0 ;
8305 
8306  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8307  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8308  if (!SWIG_IsOK(res1)) {
8309  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
8310  }
8311  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8312  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8313  if (!SWIG_IsOK(ecode2)) {
8314  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8315  }
8316  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8317  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8318  if (!SWIG_IsOK(ecode3)) {
8319  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
8320  }
8321  arg3 = static_cast< std::vector< double >::difference_type >(val3);
8322  try {
8323  std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
8324  } catch(std::out_of_range &_e) {
8325  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8326  } catch(std::invalid_argument &_e) {
8327  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8328  }
8329  resultobj = SWIG_Py_Void();
8330  return resultobj;
8331 fail:
8332  return NULL;
8333 }
8334 
8335 
8336 SWIGINTERN PyObject *_wrap_VecDouble___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8337  PyObject *resultobj = 0;
8338  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8339  std::vector< double >::difference_type arg2 ;
8340  std::vector< double >::difference_type arg3 ;
8341  std::vector< double,std::allocator< double > > *arg4 = 0 ;
8342  void *argp1 = 0 ;
8343  int res1 = 0 ;
8344  ptrdiff_t val2 ;
8345  int ecode2 = 0 ;
8346  ptrdiff_t val3 ;
8347  int ecode3 = 0 ;
8348  int res4 = SWIG_OLDOBJ ;
8349  PyObject * obj0 = 0 ;
8350  PyObject * obj1 = 0 ;
8351  PyObject * obj2 = 0 ;
8352  PyObject * obj3 = 0 ;
8353 
8354  if (!PyArg_ParseTuple(args,(char *)"OOOO:VecDouble___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8355  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8356  if (!SWIG_IsOK(res1)) {
8357  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
8358  }
8359  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8360  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8361  if (!SWIG_IsOK(ecode2)) {
8362  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8363  }
8364  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8365  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8366  if (!SWIG_IsOK(ecode3)) {
8367  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
8368  }
8369  arg3 = static_cast< std::vector< double >::difference_type >(val3);
8370  {
8371  std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
8372  res4 = swig::asptr(obj3, &ptr);
8373  if (!SWIG_IsOK(res4)) {
8374  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VecDouble___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
8375  }
8376  if (!ptr) {
8377  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VecDouble___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
8378  }
8379  arg4 = ptr;
8380  }
8381  try {
8382  std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
8383  } catch(std::out_of_range &_e) {
8384  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8385  } catch(std::invalid_argument &_e) {
8386  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8387  }
8388  resultobj = SWIG_Py_Void();
8389  if (SWIG_IsNewObj(res4)) delete arg4;
8390  return resultobj;
8391 fail:
8392  if (SWIG_IsNewObj(res4)) delete arg4;
8393  return NULL;
8394 }
8395 
8396 
8397 SWIGINTERN PyObject *_wrap_VecDouble___setslice__(PyObject *self, PyObject *args) {
8398  Py_ssize_t argc;
8399  PyObject *argv[5] = {
8400  0
8401  };
8402  Py_ssize_t ii;
8403 
8404  if (!PyTuple_Check(args)) SWIG_fail;
8405  argc = PyObject_Length(args);
8406  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8407  argv[ii] = PyTuple_GET_ITEM(args,ii);
8408  }
8409  if (argc == 3) {
8410  int _v;
8411  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8412  _v = SWIG_CheckState(res);
8413  if (_v) {
8414  {
8415  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8416  _v = SWIG_CheckState(res);
8417  }
8418  if (_v) {
8419  {
8420  int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8421  _v = SWIG_CheckState(res);
8422  }
8423  if (_v) {
8424  return _wrap_VecDouble___setslice____SWIG_0(self, args);
8425  }
8426  }
8427  }
8428  }
8429  if (argc == 4) {
8430  int _v;
8431  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8432  _v = SWIG_CheckState(res);
8433  if (_v) {
8434  {
8435  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8436  _v = SWIG_CheckState(res);
8437  }
8438  if (_v) {
8439  {
8440  int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8441  _v = SWIG_CheckState(res);
8442  }
8443  if (_v) {
8444  int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
8445  _v = SWIG_CheckState(res);
8446  if (_v) {
8447  return _wrap_VecDouble___setslice____SWIG_1(self, args);
8448  }
8449  }
8450  }
8451  }
8452  }
8453 
8454 fail:
8455  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble___setslice__'.\n"
8456  " Possible C/C++ prototypes are:\n"
8457  " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
8458  " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
8459  return 0;
8460 }
8461 
8462 
8463 SWIGINTERN PyObject *_wrap_VecDouble___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8464  PyObject *resultobj = 0;
8465  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8466  std::vector< double >::difference_type arg2 ;
8467  std::vector< double >::difference_type arg3 ;
8468  void *argp1 = 0 ;
8469  int res1 = 0 ;
8470  ptrdiff_t val2 ;
8471  int ecode2 = 0 ;
8472  ptrdiff_t val3 ;
8473  int ecode3 = 0 ;
8474  PyObject * obj0 = 0 ;
8475  PyObject * obj1 = 0 ;
8476  PyObject * obj2 = 0 ;
8477 
8478  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8479  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8480  if (!SWIG_IsOK(res1)) {
8481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
8482  }
8483  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8484  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8485  if (!SWIG_IsOK(ecode2)) {
8486  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8487  }
8488  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8489  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8490  if (!SWIG_IsOK(ecode3)) {
8491  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
8492  }
8493  arg3 = static_cast< std::vector< double >::difference_type >(val3);
8494  try {
8495  std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
8496  } catch(std::out_of_range &_e) {
8497  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8498  } catch(std::invalid_argument &_e) {
8499  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8500  }
8501  resultobj = SWIG_Py_Void();
8502  return resultobj;
8503 fail:
8504  return NULL;
8505 }
8506 
8507 
8508 SWIGINTERN PyObject *_wrap_VecDouble___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8509  PyObject *resultobj = 0;
8510  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8511  std::vector< double >::difference_type arg2 ;
8512  void *argp1 = 0 ;
8513  int res1 = 0 ;
8514  ptrdiff_t val2 ;
8515  int ecode2 = 0 ;
8516  PyObject * obj0 = 0 ;
8517  PyObject * obj1 = 0 ;
8518 
8519  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble___delitem__",&obj0,&obj1)) SWIG_fail;
8520  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8521  if (!SWIG_IsOK(res1)) {
8522  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8523  }
8524  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8525  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8526  if (!SWIG_IsOK(ecode2)) {
8527  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8528  }
8529  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8530  try {
8531  std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
8532  } catch(std::out_of_range &_e) {
8533  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8534  } catch(std::invalid_argument &_e) {
8535  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8536  }
8537  resultobj = SWIG_Py_Void();
8538  return resultobj;
8539 fail:
8540  return NULL;
8541 }
8542 
8543 
8544 SWIGINTERN PyObject *_wrap_VecDouble___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545  PyObject *resultobj = 0;
8546  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8547  PySliceObject *arg2 = (PySliceObject *) 0 ;
8548  void *argp1 = 0 ;
8549  int res1 = 0 ;
8550  PyObject * obj0 = 0 ;
8551  PyObject * obj1 = 0 ;
8552  std::vector< double,std::allocator< double > > *result = 0 ;
8553 
8554  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble___getitem__",&obj0,&obj1)) SWIG_fail;
8555  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8556  if (!SWIG_IsOK(res1)) {
8557  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8558  }
8559  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8560  {
8561  if (!PySlice_Check(obj1)) {
8562  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
8563  }
8564  arg2 = (PySliceObject *) obj1;
8565  }
8566  try {
8567  result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
8568  } catch(std::out_of_range &_e) {
8569  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8570  } catch(std::invalid_argument &_e) {
8571  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8572  }
8573  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
8574  return resultobj;
8575 fail:
8576  return NULL;
8577 }
8578 
8579 
8580 SWIGINTERN PyObject *_wrap_VecDouble___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8581  PyObject *resultobj = 0;
8582  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8583  PySliceObject *arg2 = (PySliceObject *) 0 ;
8584  std::vector< double,std::allocator< double > > *arg3 = 0 ;
8585  void *argp1 = 0 ;
8586  int res1 = 0 ;
8587  int res3 = SWIG_OLDOBJ ;
8588  PyObject * obj0 = 0 ;
8589  PyObject * obj1 = 0 ;
8590  PyObject * obj2 = 0 ;
8591 
8592  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
8593  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8594  if (!SWIG_IsOK(res1)) {
8595  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8596  }
8597  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8598  {
8599  if (!PySlice_Check(obj1)) {
8600  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
8601  }
8602  arg2 = (PySliceObject *) obj1;
8603  }
8604  {
8605  std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
8606  res3 = swig::asptr(obj2, &ptr);
8607  if (!SWIG_IsOK(res3)) {
8608  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VecDouble___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
8609  }
8610  if (!ptr) {
8611  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VecDouble___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
8612  }
8613  arg3 = ptr;
8614  }
8615  try {
8616  std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
8617  } catch(std::out_of_range &_e) {
8618  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8619  } catch(std::invalid_argument &_e) {
8620  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8621  }
8622  resultobj = SWIG_Py_Void();
8623  if (SWIG_IsNewObj(res3)) delete arg3;
8624  return resultobj;
8625 fail:
8626  if (SWIG_IsNewObj(res3)) delete arg3;
8627  return NULL;
8628 }
8629 
8630 
8631 SWIGINTERN PyObject *_wrap_VecDouble___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8632  PyObject *resultobj = 0;
8633  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8634  PySliceObject *arg2 = (PySliceObject *) 0 ;
8635  void *argp1 = 0 ;
8636  int res1 = 0 ;
8637  PyObject * obj0 = 0 ;
8638  PyObject * obj1 = 0 ;
8639 
8640  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble___setitem__",&obj0,&obj1)) SWIG_fail;
8641  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8642  if (!SWIG_IsOK(res1)) {
8643  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8644  }
8645  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8646  {
8647  if (!PySlice_Check(obj1)) {
8648  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
8649  }
8650  arg2 = (PySliceObject *) obj1;
8651  }
8652  try {
8653  std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
8654  } catch(std::out_of_range &_e) {
8655  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8656  } catch(std::invalid_argument &_e) {
8657  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8658  }
8659  resultobj = SWIG_Py_Void();
8660  return resultobj;
8661 fail:
8662  return NULL;
8663 }
8664 
8665 
8666 SWIGINTERN PyObject *_wrap_VecDouble___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8667  PyObject *resultobj = 0;
8668  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8669  PySliceObject *arg2 = (PySliceObject *) 0 ;
8670  void *argp1 = 0 ;
8671  int res1 = 0 ;
8672  PyObject * obj0 = 0 ;
8673  PyObject * obj1 = 0 ;
8674 
8675  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble___delitem__",&obj0,&obj1)) SWIG_fail;
8676  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8677  if (!SWIG_IsOK(res1)) {
8678  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8679  }
8680  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8681  {
8682  if (!PySlice_Check(obj1)) {
8683  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
8684  }
8685  arg2 = (PySliceObject *) obj1;
8686  }
8687  try {
8688  std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
8689  } catch(std::out_of_range &_e) {
8690  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8691  } catch(std::invalid_argument &_e) {
8692  SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8693  }
8694  resultobj = SWIG_Py_Void();
8695  return resultobj;
8696 fail:
8697  return NULL;
8698 }
8699 
8700 
8701 SWIGINTERN PyObject *_wrap_VecDouble___delitem__(PyObject *self, PyObject *args) {
8702  Py_ssize_t argc;
8703  PyObject *argv[3] = {
8704  0
8705  };
8706  Py_ssize_t ii;
8707 
8708  if (!PyTuple_Check(args)) SWIG_fail;
8709  argc = PyObject_Length(args);
8710  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
8711  argv[ii] = PyTuple_GET_ITEM(args,ii);
8712  }
8713  if (argc == 2) {
8714  int _v;
8715  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8716  _v = SWIG_CheckState(res);
8717  if (_v) {
8718  {
8719  _v = PySlice_Check(argv[1]);
8720  }
8721  if (_v) {
8722  return _wrap_VecDouble___delitem____SWIG_1(self, args);
8723  }
8724  }
8725  }
8726  if (argc == 2) {
8727  int _v;
8728  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8729  _v = SWIG_CheckState(res);
8730  if (_v) {
8731  {
8732  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8733  _v = SWIG_CheckState(res);
8734  }
8735  if (_v) {
8736  return _wrap_VecDouble___delitem____SWIG_0(self, args);
8737  }
8738  }
8739  }
8740 
8741 fail:
8742  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble___delitem__'.\n"
8743  " Possible C/C++ prototypes are:\n"
8744  " std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
8745  " std::vector< double >::__delitem__(PySliceObject *)\n");
8746  return 0;
8747 }
8748 
8749 
8750 SWIGINTERN PyObject *_wrap_VecDouble___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8751  PyObject *resultobj = 0;
8752  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8753  std::vector< double >::difference_type arg2 ;
8754  void *argp1 = 0 ;
8755  int res1 = 0 ;
8756  ptrdiff_t val2 ;
8757  int ecode2 = 0 ;
8758  PyObject * obj0 = 0 ;
8759  PyObject * obj1 = 0 ;
8760  std::vector< double >::value_type *result = 0 ;
8761 
8762  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble___getitem__",&obj0,&obj1)) SWIG_fail;
8763  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8764  if (!SWIG_IsOK(res1)) {
8765  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
8766  }
8767  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8768  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8769  if (!SWIG_IsOK(ecode2)) {
8770  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8771  }
8772  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8773  try {
8774  result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
8775  } catch(std::out_of_range &_e) {
8776  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8777  }
8778  resultobj = SWIG_From_double(static_cast< double >(*result));
8779  return resultobj;
8780 fail:
8781  return NULL;
8782 }
8783 
8784 
8785 SWIGINTERN PyObject *_wrap_VecDouble___getitem__(PyObject *self, PyObject *args) {
8786  Py_ssize_t argc;
8787  PyObject *argv[3] = {
8788  0
8789  };
8790  Py_ssize_t ii;
8791 
8792  if (!PyTuple_Check(args)) SWIG_fail;
8793  argc = PyObject_Length(args);
8794  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
8795  argv[ii] = PyTuple_GET_ITEM(args,ii);
8796  }
8797  if (argc == 2) {
8798  int _v;
8799  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8800  _v = SWIG_CheckState(res);
8801  if (_v) {
8802  {
8803  _v = PySlice_Check(argv[1]);
8804  }
8805  if (_v) {
8806  return _wrap_VecDouble___getitem____SWIG_0(self, args);
8807  }
8808  }
8809  }
8810  if (argc == 2) {
8811  int _v;
8812  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8813  _v = SWIG_CheckState(res);
8814  if (_v) {
8815  {
8816  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8817  _v = SWIG_CheckState(res);
8818  }
8819  if (_v) {
8820  return _wrap_VecDouble___getitem____SWIG_1(self, args);
8821  }
8822  }
8823  }
8824 
8825 fail:
8826  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble___getitem__'.\n"
8827  " Possible C/C++ prototypes are:\n"
8828  " std::vector< double >::__getitem__(PySliceObject *)\n"
8829  " std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
8830  return 0;
8831 }
8832 
8833 
8834 SWIGINTERN PyObject *_wrap_VecDouble___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8835  PyObject *resultobj = 0;
8836  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8837  std::vector< double >::difference_type arg2 ;
8838  std::vector< double >::value_type *arg3 = 0 ;
8839  void *argp1 = 0 ;
8840  int res1 = 0 ;
8841  ptrdiff_t val2 ;
8842  int ecode2 = 0 ;
8843  std::vector< double >::value_type temp3 ;
8844  double val3 ;
8845  int ecode3 = 0 ;
8846  PyObject * obj0 = 0 ;
8847  PyObject * obj1 = 0 ;
8848  PyObject * obj2 = 0 ;
8849 
8850  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
8851  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8852  if (!SWIG_IsOK(res1)) {
8853  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
8854  }
8855  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8856  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8857  if (!SWIG_IsOK(ecode2)) {
8858  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
8859  }
8860  arg2 = static_cast< std::vector< double >::difference_type >(val2);
8861  ecode3 = SWIG_AsVal_double(obj2, &val3);
8862  if (!SWIG_IsOK(ecode3)) {
8863  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
8864  }
8865  temp3 = static_cast< std::vector< double >::value_type >(val3);
8866  arg3 = &temp3;
8867  try {
8868  std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
8869  } catch(std::out_of_range &_e) {
8870  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8871  }
8872  resultobj = SWIG_Py_Void();
8873  return resultobj;
8874 fail:
8875  return NULL;
8876 }
8877 
8878 
8879 SWIGINTERN PyObject *_wrap_VecDouble___setitem__(PyObject *self, PyObject *args) {
8880  Py_ssize_t argc;
8881  PyObject *argv[4] = {
8882  0
8883  };
8884  Py_ssize_t ii;
8885 
8886  if (!PyTuple_Check(args)) SWIG_fail;
8887  argc = PyObject_Length(args);
8888  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
8889  argv[ii] = PyTuple_GET_ITEM(args,ii);
8890  }
8891  if (argc == 2) {
8892  int _v;
8893  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8894  _v = SWIG_CheckState(res);
8895  if (_v) {
8896  {
8897  _v = PySlice_Check(argv[1]);
8898  }
8899  if (_v) {
8900  return _wrap_VecDouble___setitem____SWIG_1(self, args);
8901  }
8902  }
8903  }
8904  if (argc == 3) {
8905  int _v;
8906  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8907  _v = SWIG_CheckState(res);
8908  if (_v) {
8909  {
8910  _v = PySlice_Check(argv[1]);
8911  }
8912  if (_v) {
8913  int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
8914  _v = SWIG_CheckState(res);
8915  if (_v) {
8916  return _wrap_VecDouble___setitem____SWIG_0(self, args);
8917  }
8918  }
8919  }
8920  }
8921  if (argc == 3) {
8922  int _v;
8923  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
8924  _v = SWIG_CheckState(res);
8925  if (_v) {
8926  {
8927  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8928  _v = SWIG_CheckState(res);
8929  }
8930  if (_v) {
8931  {
8932  int res = SWIG_AsVal_double(argv[2], NULL);
8933  _v = SWIG_CheckState(res);
8934  }
8935  if (_v) {
8936  return _wrap_VecDouble___setitem____SWIG_2(self, args);
8937  }
8938  }
8939  }
8940  }
8941 
8942 fail:
8943  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble___setitem__'.\n"
8944  " Possible C/C++ prototypes are:\n"
8945  " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
8946  " std::vector< double >::__setitem__(PySliceObject *)\n"
8947  " std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
8948  return 0;
8949 }
8950 
8951 
8952 SWIGINTERN PyObject *_wrap_VecDouble_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953  PyObject *resultobj = 0;
8954  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8955  void *argp1 = 0 ;
8956  int res1 = 0 ;
8957  PyObject * obj0 = 0 ;
8958  std::vector< double >::value_type result;
8959 
8960  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_pop",&obj0)) SWIG_fail;
8961  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8962  if (!SWIG_IsOK(res1)) {
8963  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
8964  }
8965  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8966  try {
8967  result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
8968  } catch(std::out_of_range &_e) {
8969  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8970  }
8971  resultobj = SWIG_From_double(static_cast< double >(result));
8972  return resultobj;
8973 fail:
8974  return NULL;
8975 }
8976 
8977 
8978 SWIGINTERN PyObject *_wrap_VecDouble_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8979  PyObject *resultobj = 0;
8980  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
8981  std::vector< double >::value_type *arg2 = 0 ;
8982  void *argp1 = 0 ;
8983  int res1 = 0 ;
8984  std::vector< double >::value_type temp2 ;
8985  double val2 ;
8986  int ecode2 = 0 ;
8987  PyObject * obj0 = 0 ;
8988  PyObject * obj1 = 0 ;
8989 
8990  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_append",&obj0,&obj1)) SWIG_fail;
8991  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
8992  if (!SWIG_IsOK(res1)) {
8993  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_append" "', argument " "1"" of type '" "std::vector< double > *""'");
8994  }
8995  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
8996  ecode2 = SWIG_AsVal_double(obj1, &val2);
8997  if (!SWIG_IsOK(ecode2)) {
8998  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
8999  }
9000  temp2 = static_cast< std::vector< double >::value_type >(val2);
9001  arg2 = &temp2;
9002  std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
9003  resultobj = SWIG_Py_Void();
9004  return resultobj;
9005 fail:
9006  return NULL;
9007 }
9008 
9009 
9010 SWIGINTERN PyObject *_wrap_new_VecDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011  PyObject *resultobj = 0;
9012  std::vector< double > *result = 0 ;
9013 
9014  if (!PyArg_ParseTuple(args,(char *)":new_VecDouble")) SWIG_fail;
9015  result = (std::vector< double > *)new std::vector< double >();
9016  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
9017  return resultobj;
9018 fail:
9019  return NULL;
9020 }
9021 
9022 
9023 SWIGINTERN PyObject *_wrap_new_VecDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024  PyObject *resultobj = 0;
9025  std::vector< double > *arg1 = 0 ;
9026  int res1 = SWIG_OLDOBJ ;
9027  PyObject * obj0 = 0 ;
9028  std::vector< double > *result = 0 ;
9029 
9030  if (!PyArg_ParseTuple(args,(char *)"O:new_VecDouble",&obj0)) SWIG_fail;
9031  {
9032  std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
9033  res1 = swig::asptr(obj0, &ptr);
9034  if (!SWIG_IsOK(res1)) {
9035  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VecDouble" "', argument " "1"" of type '" "std::vector< double > const &""'");
9036  }
9037  if (!ptr) {
9038  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VecDouble" "', argument " "1"" of type '" "std::vector< double > const &""'");
9039  }
9040  arg1 = ptr;
9041  }
9042  result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
9043  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
9044  if (SWIG_IsNewObj(res1)) delete arg1;
9045  return resultobj;
9046 fail:
9047  if (SWIG_IsNewObj(res1)) delete arg1;
9048  return NULL;
9049 }
9050 
9051 
9052 SWIGINTERN PyObject *_wrap_VecDouble_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053  PyObject *resultobj = 0;
9054  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9055  void *argp1 = 0 ;
9056  int res1 = 0 ;
9057  PyObject * obj0 = 0 ;
9058  bool result;
9059 
9060  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_empty",&obj0)) SWIG_fail;
9061  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9062  if (!SWIG_IsOK(res1)) {
9063  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
9064  }
9065  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9066  result = (bool)((std::vector< double > const *)arg1)->empty();
9067  resultobj = SWIG_From_bool(static_cast< bool >(result));
9068  return resultobj;
9069 fail:
9070  return NULL;
9071 }
9072 
9073 
9074 SWIGINTERN PyObject *_wrap_VecDouble_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075  PyObject *resultobj = 0;
9076  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9077  void *argp1 = 0 ;
9078  int res1 = 0 ;
9079  PyObject * obj0 = 0 ;
9080  std::vector< double >::size_type result;
9081 
9082  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_size",&obj0)) SWIG_fail;
9083  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9084  if (!SWIG_IsOK(res1)) {
9085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
9086  }
9087  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9088  result = ((std::vector< double > const *)arg1)->size();
9089  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9090  return resultobj;
9091 fail:
9092  return NULL;
9093 }
9094 
9095 
9096 SWIGINTERN PyObject *_wrap_VecDouble_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9097  PyObject *resultobj = 0;
9098  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9099  std::vector< double > *arg2 = 0 ;
9100  void *argp1 = 0 ;
9101  int res1 = 0 ;
9102  void *argp2 = 0 ;
9103  int res2 = 0 ;
9104  PyObject * obj0 = 0 ;
9105  PyObject * obj1 = 0 ;
9106 
9107  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_swap",&obj0,&obj1)) SWIG_fail;
9108  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9109  if (!SWIG_IsOK(res1)) {
9110  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
9111  }
9112  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9113  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
9114  if (!SWIG_IsOK(res2)) {
9115  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VecDouble_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
9116  }
9117  if (!argp2) {
9118  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VecDouble_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
9119  }
9120  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
9121  (arg1)->swap(*arg2);
9122  resultobj = SWIG_Py_Void();
9123  return resultobj;
9124 fail:
9125  return NULL;
9126 }
9127 
9128 
9129 SWIGINTERN PyObject *_wrap_VecDouble_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130  PyObject *resultobj = 0;
9131  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9132  void *argp1 = 0 ;
9133  int res1 = 0 ;
9134  PyObject * obj0 = 0 ;
9135  std::vector< double >::iterator result;
9136 
9137  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_begin",&obj0)) SWIG_fail;
9138  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9139  if (!SWIG_IsOK(res1)) {
9140  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_begin" "', argument " "1"" of type '" "std::vector< double > *""'");
9141  }
9142  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9143  result = (arg1)->begin();
9144  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
9145  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9146  return resultobj;
9147 fail:
9148  return NULL;
9149 }
9150 
9151 
9152 SWIGINTERN PyObject *_wrap_VecDouble_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9153  PyObject *resultobj = 0;
9154  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9155  void *argp1 = 0 ;
9156  int res1 = 0 ;
9157  PyObject * obj0 = 0 ;
9158  std::vector< double >::iterator result;
9159 
9160  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_end",&obj0)) SWIG_fail;
9161  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9162  if (!SWIG_IsOK(res1)) {
9163  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_end" "', argument " "1"" of type '" "std::vector< double > *""'");
9164  }
9165  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9166  result = (arg1)->end();
9167  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
9168  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9169  return resultobj;
9170 fail:
9171  return NULL;
9172 }
9173 
9174 
9175 SWIGINTERN PyObject *_wrap_VecDouble_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9176  PyObject *resultobj = 0;
9177  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9178  void *argp1 = 0 ;
9179  int res1 = 0 ;
9180  PyObject * obj0 = 0 ;
9181  std::vector< double >::reverse_iterator result;
9182 
9183  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_rbegin",&obj0)) SWIG_fail;
9184  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9185  if (!SWIG_IsOK(res1)) {
9186  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'");
9187  }
9188  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9189  result = (arg1)->rbegin();
9190  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
9191  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9192  return resultobj;
9193 fail:
9194  return NULL;
9195 }
9196 
9197 
9198 SWIGINTERN PyObject *_wrap_VecDouble_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199  PyObject *resultobj = 0;
9200  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9201  void *argp1 = 0 ;
9202  int res1 = 0 ;
9203  PyObject * obj0 = 0 ;
9204  std::vector< double >::reverse_iterator result;
9205 
9206  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_rend",&obj0)) SWIG_fail;
9207  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9208  if (!SWIG_IsOK(res1)) {
9209  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_rend" "', argument " "1"" of type '" "std::vector< double > *""'");
9210  }
9211  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9212  result = (arg1)->rend();
9213  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
9214  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9215  return resultobj;
9216 fail:
9217  return NULL;
9218 }
9219 
9220 
9221 SWIGINTERN PyObject *_wrap_VecDouble_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222  PyObject *resultobj = 0;
9223  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9224  void *argp1 = 0 ;
9225  int res1 = 0 ;
9226  PyObject * obj0 = 0 ;
9227 
9228  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_clear",&obj0)) SWIG_fail;
9229  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9230  if (!SWIG_IsOK(res1)) {
9231  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
9232  }
9233  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9234  (arg1)->clear();
9235  resultobj = SWIG_Py_Void();
9236  return resultobj;
9237 fail:
9238  return NULL;
9239 }
9240 
9241 
9242 SWIGINTERN PyObject *_wrap_VecDouble_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243  PyObject *resultobj = 0;
9244  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9245  void *argp1 = 0 ;
9246  int res1 = 0 ;
9247  PyObject * obj0 = 0 ;
9248  SwigValueWrapper< std::allocator< double > > result;
9249 
9250  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_get_allocator",&obj0)) SWIG_fail;
9251  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9252  if (!SWIG_IsOK(res1)) {
9253  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
9254  }
9255  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9256  result = ((std::vector< double > const *)arg1)->get_allocator();
9257  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN | 0 );
9258  return resultobj;
9259 fail:
9260  return NULL;
9261 }
9262 
9263 
9264 SWIGINTERN PyObject *_wrap_new_VecDouble__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9265  PyObject *resultobj = 0;
9266  std::vector< double >::size_type arg1 ;
9267  size_t val1 ;
9268  int ecode1 = 0 ;
9269  PyObject * obj0 = 0 ;
9270  std::vector< double > *result = 0 ;
9271 
9272  if (!PyArg_ParseTuple(args,(char *)"O:new_VecDouble",&obj0)) SWIG_fail;
9273  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9274  if (!SWIG_IsOK(ecode1)) {
9275  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VecDouble" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
9276  }
9277  arg1 = static_cast< std::vector< double >::size_type >(val1);
9278  result = (std::vector< double > *)new std::vector< double >(arg1);
9279  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
9280  return resultobj;
9281 fail:
9282  return NULL;
9283 }
9284 
9285 
9286 SWIGINTERN PyObject *_wrap_VecDouble_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9287  PyObject *resultobj = 0;
9288  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9289  void *argp1 = 0 ;
9290  int res1 = 0 ;
9291  PyObject * obj0 = 0 ;
9292 
9293  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_pop_back",&obj0)) SWIG_fail;
9294  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9295  if (!SWIG_IsOK(res1)) {
9296  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
9297  }
9298  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9299  (arg1)->pop_back();
9300  resultobj = SWIG_Py_Void();
9301  return resultobj;
9302 fail:
9303  return NULL;
9304 }
9305 
9306 
9307 SWIGINTERN PyObject *_wrap_VecDouble_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9308  PyObject *resultobj = 0;
9309  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9310  std::vector< double >::size_type arg2 ;
9311  void *argp1 = 0 ;
9312  int res1 = 0 ;
9313  size_t val2 ;
9314  int ecode2 = 0 ;
9315  PyObject * obj0 = 0 ;
9316  PyObject * obj1 = 0 ;
9317 
9318  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_resize",&obj0,&obj1)) SWIG_fail;
9319  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9320  if (!SWIG_IsOK(res1)) {
9321  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
9322  }
9323  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9324  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9325  if (!SWIG_IsOK(ecode2)) {
9326  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
9327  }
9328  arg2 = static_cast< std::vector< double >::size_type >(val2);
9329  (arg1)->resize(arg2);
9330  resultobj = SWIG_Py_Void();
9331  return resultobj;
9332 fail:
9333  return NULL;
9334 }
9335 
9336 
9337 SWIGINTERN PyObject *_wrap_VecDouble_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338  PyObject *resultobj = 0;
9339  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9340  std::vector< double >::iterator arg2 ;
9341  void *argp1 = 0 ;
9342  int res1 = 0 ;
9343  swig::SwigPyIterator *iter2 = 0 ;
9344  int res2 ;
9345  PyObject * obj0 = 0 ;
9346  PyObject * obj1 = 0 ;
9347  std::vector< double >::iterator result;
9348 
9349  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_erase",&obj0,&obj1)) SWIG_fail;
9350  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9351  if (!SWIG_IsOK(res1)) {
9352  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
9353  }
9354  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9355  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9356  if (!SWIG_IsOK(res2) || !iter2) {
9357  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9358  } else {
9360  if (iter_t) {
9361  arg2 = iter_t->get_current();
9362  } else {
9363  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9364  }
9365  }
9366  result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
9367  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
9368  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9369  return resultobj;
9370 fail:
9371  return NULL;
9372 }
9373 
9374 
9375 SWIGINTERN PyObject *_wrap_VecDouble_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9376  PyObject *resultobj = 0;
9377  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9378  std::vector< double >::iterator arg2 ;
9379  std::vector< double >::iterator arg3 ;
9380  void *argp1 = 0 ;
9381  int res1 = 0 ;
9382  swig::SwigPyIterator *iter2 = 0 ;
9383  int res2 ;
9384  swig::SwigPyIterator *iter3 = 0 ;
9385  int res3 ;
9386  PyObject * obj0 = 0 ;
9387  PyObject * obj1 = 0 ;
9388  PyObject * obj2 = 0 ;
9389  std::vector< double >::iterator result;
9390 
9391  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9392  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9393  if (!SWIG_IsOK(res1)) {
9394  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
9395  }
9396  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9397  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9398  if (!SWIG_IsOK(res2) || !iter2) {
9399  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9400  } else {
9402  if (iter_t) {
9403  arg2 = iter_t->get_current();
9404  } else {
9405  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9406  }
9407  }
9408  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
9409  if (!SWIG_IsOK(res3) || !iter3) {
9410  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
9411  } else {
9413  if (iter_t) {
9414  arg3 = iter_t->get_current();
9415  } else {
9416  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
9417  }
9418  }
9419  result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
9420  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
9421  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9422  return resultobj;
9423 fail:
9424  return NULL;
9425 }
9426 
9427 
9428 SWIGINTERN PyObject *_wrap_VecDouble_erase(PyObject *self, PyObject *args) {
9429  Py_ssize_t argc;
9430  PyObject *argv[4] = {
9431  0
9432  };
9433  Py_ssize_t ii;
9434 
9435  if (!PyTuple_Check(args)) SWIG_fail;
9436  argc = PyObject_Length(args);
9437  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9438  argv[ii] = PyTuple_GET_ITEM(args,ii);
9439  }
9440  if (argc == 2) {
9441  int _v;
9442  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9443  _v = SWIG_CheckState(res);
9444  if (_v) {
9445  swig::SwigPyIterator *iter = 0;
9446  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9447  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
9448  if (_v) {
9449  return _wrap_VecDouble_erase__SWIG_0(self, args);
9450  }
9451  }
9452  }
9453  if (argc == 3) {
9454  int _v;
9455  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9456  _v = SWIG_CheckState(res);
9457  if (_v) {
9458  swig::SwigPyIterator *iter = 0;
9459  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9460  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
9461  if (_v) {
9462  swig::SwigPyIterator *iter = 0;
9463  int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9464  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
9465  if (_v) {
9466  return _wrap_VecDouble_erase__SWIG_1(self, args);
9467  }
9468  }
9469  }
9470  }
9471 
9472 fail:
9473  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble_erase'.\n"
9474  " Possible C/C++ prototypes are:\n"
9475  " std::vector< double >::erase(std::vector< double >::iterator)\n"
9476  " std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
9477  return 0;
9478 }
9479 
9480 
9481 SWIGINTERN PyObject *_wrap_new_VecDouble__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9482  PyObject *resultobj = 0;
9483  std::vector< double >::size_type arg1 ;
9484  std::vector< double >::value_type *arg2 = 0 ;
9485  size_t val1 ;
9486  int ecode1 = 0 ;
9487  std::vector< double >::value_type temp2 ;
9488  double val2 ;
9489  int ecode2 = 0 ;
9490  PyObject * obj0 = 0 ;
9491  PyObject * obj1 = 0 ;
9492  std::vector< double > *result = 0 ;
9493 
9494  if (!PyArg_ParseTuple(args,(char *)"OO:new_VecDouble",&obj0,&obj1)) SWIG_fail;
9495  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9496  if (!SWIG_IsOK(ecode1)) {
9497  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VecDouble" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
9498  }
9499  arg1 = static_cast< std::vector< double >::size_type >(val1);
9500  ecode2 = SWIG_AsVal_double(obj1, &val2);
9501  if (!SWIG_IsOK(ecode2)) {
9502  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VecDouble" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
9503  }
9504  temp2 = static_cast< std::vector< double >::value_type >(val2);
9505  arg2 = &temp2;
9506  result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
9507  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
9508  return resultobj;
9509 fail:
9510  return NULL;
9511 }
9512 
9513 
9514 SWIGINTERN PyObject *_wrap_new_VecDouble(PyObject *self, PyObject *args) {
9515  Py_ssize_t argc;
9516  PyObject *argv[3] = {
9517  0
9518  };
9519  Py_ssize_t ii;
9520 
9521  if (!PyTuple_Check(args)) SWIG_fail;
9522  argc = PyObject_Length(args);
9523  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
9524  argv[ii] = PyTuple_GET_ITEM(args,ii);
9525  }
9526  if (argc == 0) {
9527  return _wrap_new_VecDouble__SWIG_0(self, args);
9528  }
9529  if (argc == 1) {
9530  int _v;
9531  {
9532  int res = SWIG_AsVal_size_t(argv[0], NULL);
9533  _v = SWIG_CheckState(res);
9534  }
9535  if (_v) {
9536  return _wrap_new_VecDouble__SWIG_2(self, args);
9537  }
9538  }
9539  if (argc == 1) {
9540  int _v;
9541  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9542  _v = SWIG_CheckState(res);
9543  if (_v) {
9544  return _wrap_new_VecDouble__SWIG_1(self, args);
9545  }
9546  }
9547  if (argc == 2) {
9548  int _v;
9549  {
9550  int res = SWIG_AsVal_size_t(argv[0], NULL);
9551  _v = SWIG_CheckState(res);
9552  }
9553  if (_v) {
9554  {
9555  int res = SWIG_AsVal_double(argv[1], NULL);
9556  _v = SWIG_CheckState(res);
9557  }
9558  if (_v) {
9559  return _wrap_new_VecDouble__SWIG_3(self, args);
9560  }
9561  }
9562  }
9563 
9564 fail:
9565  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VecDouble'.\n"
9566  " Possible C/C++ prototypes are:\n"
9567  " std::vector< double >::vector()\n"
9568  " std::vector< double >::vector(std::vector< double > const &)\n"
9569  " std::vector< double >::vector(std::vector< double >::size_type)\n"
9570  " std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
9571  return 0;
9572 }
9573 
9574 
9575 SWIGINTERN PyObject *_wrap_VecDouble_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9576  PyObject *resultobj = 0;
9577  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9578  std::vector< double >::value_type *arg2 = 0 ;
9579  void *argp1 = 0 ;
9580  int res1 = 0 ;
9581  std::vector< double >::value_type temp2 ;
9582  double val2 ;
9583  int ecode2 = 0 ;
9584  PyObject * obj0 = 0 ;
9585  PyObject * obj1 = 0 ;
9586 
9587  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_push_back",&obj0,&obj1)) SWIG_fail;
9588  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9589  if (!SWIG_IsOK(res1)) {
9590  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
9591  }
9592  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9593  ecode2 = SWIG_AsVal_double(obj1, &val2);
9594  if (!SWIG_IsOK(ecode2)) {
9595  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
9596  }
9597  temp2 = static_cast< std::vector< double >::value_type >(val2);
9598  arg2 = &temp2;
9599  (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
9600  resultobj = SWIG_Py_Void();
9601  return resultobj;
9602 fail:
9603  return NULL;
9604 }
9605 
9606 
9607 SWIGINTERN PyObject *_wrap_VecDouble_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608  PyObject *resultobj = 0;
9609  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9610  void *argp1 = 0 ;
9611  int res1 = 0 ;
9612  PyObject * obj0 = 0 ;
9613  std::vector< double >::value_type *result = 0 ;
9614 
9615  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_front",&obj0)) SWIG_fail;
9616  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9617  if (!SWIG_IsOK(res1)) {
9618  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
9619  }
9620  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9621  result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
9622  resultobj = SWIG_From_double(static_cast< double >(*result));
9623  return resultobj;
9624 fail:
9625  return NULL;
9626 }
9627 
9628 
9629 SWIGINTERN PyObject *_wrap_VecDouble_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630  PyObject *resultobj = 0;
9631  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9632  void *argp1 = 0 ;
9633  int res1 = 0 ;
9634  PyObject * obj0 = 0 ;
9635  std::vector< double >::value_type *result = 0 ;
9636 
9637  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_back",&obj0)) SWIG_fail;
9638  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9639  if (!SWIG_IsOK(res1)) {
9640  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
9641  }
9642  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9643  result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
9644  resultobj = SWIG_From_double(static_cast< double >(*result));
9645  return resultobj;
9646 fail:
9647  return NULL;
9648 }
9649 
9650 
9651 SWIGINTERN PyObject *_wrap_VecDouble_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9652  PyObject *resultobj = 0;
9653  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9654  std::vector< double >::size_type arg2 ;
9655  std::vector< double >::value_type *arg3 = 0 ;
9656  void *argp1 = 0 ;
9657  int res1 = 0 ;
9658  size_t val2 ;
9659  int ecode2 = 0 ;
9660  std::vector< double >::value_type temp3 ;
9661  double val3 ;
9662  int ecode3 = 0 ;
9663  PyObject * obj0 = 0 ;
9664  PyObject * obj1 = 0 ;
9665  PyObject * obj2 = 0 ;
9666 
9667  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble_assign",&obj0,&obj1,&obj2)) SWIG_fail;
9668  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9669  if (!SWIG_IsOK(res1)) {
9670  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
9671  }
9672  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9673  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9674  if (!SWIG_IsOK(ecode2)) {
9675  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
9676  }
9677  arg2 = static_cast< std::vector< double >::size_type >(val2);
9678  ecode3 = SWIG_AsVal_double(obj2, &val3);
9679  if (!SWIG_IsOK(ecode3)) {
9680  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
9681  }
9682  temp3 = static_cast< std::vector< double >::value_type >(val3);
9683  arg3 = &temp3;
9684  (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
9685  resultobj = SWIG_Py_Void();
9686  return resultobj;
9687 fail:
9688  return NULL;
9689 }
9690 
9691 
9692 SWIGINTERN PyObject *_wrap_VecDouble_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693  PyObject *resultobj = 0;
9694  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9695  std::vector< double >::size_type arg2 ;
9696  std::vector< double >::value_type *arg3 = 0 ;
9697  void *argp1 = 0 ;
9698  int res1 = 0 ;
9699  size_t val2 ;
9700  int ecode2 = 0 ;
9701  std::vector< double >::value_type temp3 ;
9702  double val3 ;
9703  int ecode3 = 0 ;
9704  PyObject * obj0 = 0 ;
9705  PyObject * obj1 = 0 ;
9706  PyObject * obj2 = 0 ;
9707 
9708  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble_resize",&obj0,&obj1,&obj2)) SWIG_fail;
9709  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9710  if (!SWIG_IsOK(res1)) {
9711  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
9712  }
9713  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9714  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9715  if (!SWIG_IsOK(ecode2)) {
9716  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
9717  }
9718  arg2 = static_cast< std::vector< double >::size_type >(val2);
9719  ecode3 = SWIG_AsVal_double(obj2, &val3);
9720  if (!SWIG_IsOK(ecode3)) {
9721  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
9722  }
9723  temp3 = static_cast< std::vector< double >::value_type >(val3);
9724  arg3 = &temp3;
9725  (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
9726  resultobj = SWIG_Py_Void();
9727  return resultobj;
9728 fail:
9729  return NULL;
9730 }
9731 
9732 
9733 SWIGINTERN PyObject *_wrap_VecDouble_resize(PyObject *self, PyObject *args) {
9734  Py_ssize_t argc;
9735  PyObject *argv[4] = {
9736  0
9737  };
9738  Py_ssize_t ii;
9739 
9740  if (!PyTuple_Check(args)) SWIG_fail;
9741  argc = PyObject_Length(args);
9742  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9743  argv[ii] = PyTuple_GET_ITEM(args,ii);
9744  }
9745  if (argc == 2) {
9746  int _v;
9747  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9748  _v = SWIG_CheckState(res);
9749  if (_v) {
9750  {
9751  int res = SWIG_AsVal_size_t(argv[1], NULL);
9752  _v = SWIG_CheckState(res);
9753  }
9754  if (_v) {
9755  return _wrap_VecDouble_resize__SWIG_0(self, args);
9756  }
9757  }
9758  }
9759  if (argc == 3) {
9760  int _v;
9761  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9762  _v = SWIG_CheckState(res);
9763  if (_v) {
9764  {
9765  int res = SWIG_AsVal_size_t(argv[1], NULL);
9766  _v = SWIG_CheckState(res);
9767  }
9768  if (_v) {
9769  {
9770  int res = SWIG_AsVal_double(argv[2], NULL);
9771  _v = SWIG_CheckState(res);
9772  }
9773  if (_v) {
9774  return _wrap_VecDouble_resize__SWIG_1(self, args);
9775  }
9776  }
9777  }
9778  }
9779 
9780 fail:
9781  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble_resize'.\n"
9782  " Possible C/C++ prototypes are:\n"
9783  " std::vector< double >::resize(std::vector< double >::size_type)\n"
9784  " std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
9785  return 0;
9786 }
9787 
9788 
9789 SWIGINTERN PyObject *_wrap_VecDouble_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9790  PyObject *resultobj = 0;
9791  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9792  std::vector< double >::iterator arg2 ;
9793  std::vector< double >::value_type *arg3 = 0 ;
9794  void *argp1 = 0 ;
9795  int res1 = 0 ;
9796  swig::SwigPyIterator *iter2 = 0 ;
9797  int res2 ;
9798  std::vector< double >::value_type temp3 ;
9799  double val3 ;
9800  int ecode3 = 0 ;
9801  PyObject * obj0 = 0 ;
9802  PyObject * obj1 = 0 ;
9803  PyObject * obj2 = 0 ;
9804  std::vector< double >::iterator result;
9805 
9806  if (!PyArg_ParseTuple(args,(char *)"OOO:VecDouble_insert",&obj0,&obj1,&obj2)) SWIG_fail;
9807  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9808  if (!SWIG_IsOK(res1)) {
9809  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
9810  }
9811  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9812  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9813  if (!SWIG_IsOK(res2) || !iter2) {
9814  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9815  } else {
9817  if (iter_t) {
9818  arg2 = iter_t->get_current();
9819  } else {
9820  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9821  }
9822  }
9823  ecode3 = SWIG_AsVal_double(obj2, &val3);
9824  if (!SWIG_IsOK(ecode3)) {
9825  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
9826  }
9827  temp3 = static_cast< std::vector< double >::value_type >(val3);
9828  arg3 = &temp3;
9829  result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
9830  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
9831  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9832  return resultobj;
9833 fail:
9834  return NULL;
9835 }
9836 
9837 
9838 SWIGINTERN PyObject *_wrap_VecDouble_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9839  PyObject *resultobj = 0;
9840  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9841  std::vector< double >::iterator arg2 ;
9842  std::vector< double >::size_type arg3 ;
9843  std::vector< double >::value_type *arg4 = 0 ;
9844  void *argp1 = 0 ;
9845  int res1 = 0 ;
9846  swig::SwigPyIterator *iter2 = 0 ;
9847  int res2 ;
9848  size_t val3 ;
9849  int ecode3 = 0 ;
9850  std::vector< double >::value_type temp4 ;
9851  double val4 ;
9852  int ecode4 = 0 ;
9853  PyObject * obj0 = 0 ;
9854  PyObject * obj1 = 0 ;
9855  PyObject * obj2 = 0 ;
9856  PyObject * obj3 = 0 ;
9857 
9858  if (!PyArg_ParseTuple(args,(char *)"OOOO:VecDouble_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9859  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9860  if (!SWIG_IsOK(res1)) {
9861  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
9862  }
9863  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9864  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9865  if (!SWIG_IsOK(res2) || !iter2) {
9866  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9867  } else {
9869  if (iter_t) {
9870  arg2 = iter_t->get_current();
9871  } else {
9872  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VecDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
9873  }
9874  }
9875  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9876  if (!SWIG_IsOK(ecode3)) {
9877  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VecDouble_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
9878  }
9879  arg3 = static_cast< std::vector< double >::size_type >(val3);
9880  ecode4 = SWIG_AsVal_double(obj3, &val4);
9881  if (!SWIG_IsOK(ecode4)) {
9882  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VecDouble_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
9883  }
9884  temp4 = static_cast< std::vector< double >::value_type >(val4);
9885  arg4 = &temp4;
9886  std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
9887  resultobj = SWIG_Py_Void();
9888  return resultobj;
9889 fail:
9890  return NULL;
9891 }
9892 
9893 
9894 SWIGINTERN PyObject *_wrap_VecDouble_insert(PyObject *self, PyObject *args) {
9895  Py_ssize_t argc;
9896  PyObject *argv[5] = {
9897  0
9898  };
9899  Py_ssize_t ii;
9900 
9901  if (!PyTuple_Check(args)) SWIG_fail;
9902  argc = PyObject_Length(args);
9903  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
9904  argv[ii] = PyTuple_GET_ITEM(args,ii);
9905  }
9906  if (argc == 3) {
9907  int _v;
9908  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9909  _v = SWIG_CheckState(res);
9910  if (_v) {
9911  swig::SwigPyIterator *iter = 0;
9912  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9913  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
9914  if (_v) {
9915  {
9916  int res = SWIG_AsVal_double(argv[2], NULL);
9917  _v = SWIG_CheckState(res);
9918  }
9919  if (_v) {
9920  return _wrap_VecDouble_insert__SWIG_0(self, args);
9921  }
9922  }
9923  }
9924  }
9925  if (argc == 4) {
9926  int _v;
9927  int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
9928  _v = SWIG_CheckState(res);
9929  if (_v) {
9930  swig::SwigPyIterator *iter = 0;
9931  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9932  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
9933  if (_v) {
9934  {
9935  int res = SWIG_AsVal_size_t(argv[2], NULL);
9936  _v = SWIG_CheckState(res);
9937  }
9938  if (_v) {
9939  {
9940  int res = SWIG_AsVal_double(argv[3], NULL);
9941  _v = SWIG_CheckState(res);
9942  }
9943  if (_v) {
9944  return _wrap_VecDouble_insert__SWIG_1(self, args);
9945  }
9946  }
9947  }
9948  }
9949  }
9950 
9951 fail:
9952  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VecDouble_insert'.\n"
9953  " Possible C/C++ prototypes are:\n"
9954  " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
9955  " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
9956  return 0;
9957 }
9958 
9959 
9960 SWIGINTERN PyObject *_wrap_VecDouble_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9961  PyObject *resultobj = 0;
9962  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9963  std::vector< double >::size_type arg2 ;
9964  void *argp1 = 0 ;
9965  int res1 = 0 ;
9966  size_t val2 ;
9967  int ecode2 = 0 ;
9968  PyObject * obj0 = 0 ;
9969  PyObject * obj1 = 0 ;
9970 
9971  if (!PyArg_ParseTuple(args,(char *)"OO:VecDouble_reserve",&obj0,&obj1)) SWIG_fail;
9972  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
9973  if (!SWIG_IsOK(res1)) {
9974  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
9975  }
9976  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
9977  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9978  if (!SWIG_IsOK(ecode2)) {
9979  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VecDouble_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
9980  }
9981  arg2 = static_cast< std::vector< double >::size_type >(val2);
9982  (arg1)->reserve(arg2);
9983  resultobj = SWIG_Py_Void();
9984  return resultobj;
9985 fail:
9986  return NULL;
9987 }
9988 
9989 
9990 SWIGINTERN PyObject *_wrap_VecDouble_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9991  PyObject *resultobj = 0;
9992  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
9993  void *argp1 = 0 ;
9994  int res1 = 0 ;
9995  PyObject * obj0 = 0 ;
9996  std::vector< double >::size_type result;
9997 
9998  if (!PyArg_ParseTuple(args,(char *)"O:VecDouble_capacity",&obj0)) SWIG_fail;
9999  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
10000  if (!SWIG_IsOK(res1)) {
10001  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VecDouble_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
10002  }
10003  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
10004  result = ((std::vector< double > const *)arg1)->capacity();
10005  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10006  return resultobj;
10007 fail:
10008  return NULL;
10009 }
10010 
10011 
10012 SWIGINTERN PyObject *_wrap_delete_VecDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10013  PyObject *resultobj = 0;
10014  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
10015  void *argp1 = 0 ;
10016  int res1 = 0 ;
10017  PyObject * obj0 = 0 ;
10018 
10019  if (!PyArg_ParseTuple(args,(char *)"O:delete_VecDouble",&obj0)) SWIG_fail;
10020  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
10021  if (!SWIG_IsOK(res1)) {
10022  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VecDouble" "', argument " "1"" of type '" "std::vector< double > *""'");
10023  }
10024  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
10025  delete arg1;
10026  resultobj = SWIG_Py_Void();
10027  return resultobj;
10028 fail:
10029  return NULL;
10030 }
10031 
10032 
10033 SWIGINTERN PyObject *VecDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10034  PyObject *obj;
10035  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
10036  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
10037  return SWIG_Py_Void();
10038 }
10039 
10040 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapResolution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10041  PyObject *resultobj = 0;
10043  double arg2 ;
10044  void *argp1 = 0 ;
10045  int res1 = 0 ;
10046  double val2 ;
10047  int ecode2 = 0 ;
10048  PyObject * obj0 = 0 ;
10049  PyObject * obj1 = 0 ;
10050 
10051  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mapResolution_set",&obj0,&obj1)) SWIG_fail;
10052  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10053  if (!SWIG_IsOK(res1)) {
10054  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapResolution_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10055  }
10056  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10057  ecode2 = SWIG_AsVal_double(obj1, &val2);
10058  if (!SWIG_IsOK(ecode2)) {
10059  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_mapResolution_set" "', argument " "2"" of type '" "double""'");
10060  }
10061  arg2 = static_cast< double >(val2);
10062  if (arg1) (arg1)->mapResolution = arg2;
10063  resultobj = SWIG_Py_Void();
10064  return resultobj;
10065 fail:
10066  return NULL;
10067 }
10068 
10069 
10070 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapResolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10071  PyObject *resultobj = 0;
10073  void *argp1 = 0 ;
10074  int res1 = 0 ;
10075  PyObject * obj0 = 0 ;
10076  double result;
10077 
10078  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mapResolution_get",&obj0)) SWIG_fail;
10079  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10080  if (!SWIG_IsOK(res1)) {
10081  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapResolution_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10082  }
10083  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10084  result = (double) ((arg1)->mapResolution);
10085  resultobj = SWIG_From_double(static_cast< double >(result));
10086  return resultobj;
10087 fail:
10088  return NULL;
10089 }
10090 
10091 
10092 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bandwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10093  PyObject *resultobj = 0;
10095  unsigned int arg2 ;
10096  void *argp1 = 0 ;
10097  int res1 = 0 ;
10098  unsigned int val2 ;
10099  int ecode2 = 0 ;
10100  PyObject * obj0 = 0 ;
10101  PyObject * obj1 = 0 ;
10102 
10103  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_bandwidth_set",&obj0,&obj1)) SWIG_fail;
10104  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10105  if (!SWIG_IsOK(res1)) {
10106  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bandwidth_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10107  }
10108  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10109  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10110  if (!SWIG_IsOK(ecode2)) {
10111  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_bandwidth_set" "', argument " "2"" of type '" "unsigned int""'");
10112  }
10113  arg2 = static_cast< unsigned int >(val2);
10114  if (arg1) (arg1)->bandwidth = arg2;
10115  resultobj = SWIG_Py_Void();
10116  return resultobj;
10117 fail:
10118  return NULL;
10119 }
10120 
10121 
10122 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bandwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10123  PyObject *resultobj = 0;
10125  void *argp1 = 0 ;
10126  int res1 = 0 ;
10127  PyObject * obj0 = 0 ;
10128  unsigned int result;
10129 
10130  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_bandwidth_get",&obj0)) SWIG_fail;
10131  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10132  if (!SWIG_IsOK(res1)) {
10133  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bandwidth_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10134  }
10135  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10136  result = (unsigned int) ((arg1)->bandwidth);
10137  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10138  return resultobj;
10139 fail:
10140  return NULL;
10141 }
10142 
10143 
10144 SWIGINTERN PyObject *_wrap_ProSHADE_settings_glIntegOrder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145  PyObject *resultobj = 0;
10147  unsigned int arg2 ;
10148  void *argp1 = 0 ;
10149  int res1 = 0 ;
10150  unsigned int val2 ;
10151  int ecode2 = 0 ;
10152  PyObject * obj0 = 0 ;
10153  PyObject * obj1 = 0 ;
10154 
10155  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_glIntegOrder_set",&obj0,&obj1)) SWIG_fail;
10156  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10157  if (!SWIG_IsOK(res1)) {
10158  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_glIntegOrder_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10159  }
10160  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10161  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10162  if (!SWIG_IsOK(ecode2)) {
10163  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_glIntegOrder_set" "', argument " "2"" of type '" "unsigned int""'");
10164  }
10165  arg2 = static_cast< unsigned int >(val2);
10166  if (arg1) (arg1)->glIntegOrder = arg2;
10167  resultobj = SWIG_Py_Void();
10168  return resultobj;
10169 fail:
10170  return NULL;
10171 }
10172 
10173 
10174 SWIGINTERN PyObject *_wrap_ProSHADE_settings_glIntegOrder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10175  PyObject *resultobj = 0;
10177  void *argp1 = 0 ;
10178  int res1 = 0 ;
10179  PyObject * obj0 = 0 ;
10180  unsigned int result;
10181 
10182  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_glIntegOrder_get",&obj0)) SWIG_fail;
10183  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10184  if (!SWIG_IsOK(res1)) {
10185  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_glIntegOrder_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10186  }
10187  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10188  result = (unsigned int) ((arg1)->glIntegOrder);
10189  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10190  return resultobj;
10191 fail:
10192  return NULL;
10193 }
10194 
10195 
10196 SWIGINTERN PyObject *_wrap_ProSHADE_settings_theta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10197  PyObject *resultobj = 0;
10199  unsigned int arg2 ;
10200  void *argp1 = 0 ;
10201  int res1 = 0 ;
10202  unsigned int val2 ;
10203  int ecode2 = 0 ;
10204  PyObject * obj0 = 0 ;
10205  PyObject * obj1 = 0 ;
10206 
10207  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_theta_set",&obj0,&obj1)) SWIG_fail;
10208  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10209  if (!SWIG_IsOK(res1)) {
10210  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_theta_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10211  }
10212  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10213  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10214  if (!SWIG_IsOK(ecode2)) {
10215  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_theta_set" "', argument " "2"" of type '" "unsigned int""'");
10216  }
10217  arg2 = static_cast< unsigned int >(val2);
10218  if (arg1) (arg1)->theta = arg2;
10219  resultobj = SWIG_Py_Void();
10220  return resultobj;
10221 fail:
10222  return NULL;
10223 }
10224 
10225 
10226 SWIGINTERN PyObject *_wrap_ProSHADE_settings_theta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10227  PyObject *resultobj = 0;
10229  void *argp1 = 0 ;
10230  int res1 = 0 ;
10231  PyObject * obj0 = 0 ;
10232  unsigned int result;
10233 
10234  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_theta_get",&obj0)) SWIG_fail;
10235  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10236  if (!SWIG_IsOK(res1)) {
10237  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_theta_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10238  }
10239  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10240  result = (unsigned int) ((arg1)->theta);
10241  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10242  return resultobj;
10243 fail:
10244  return NULL;
10245 }
10246 
10247 
10248 SWIGINTERN PyObject *_wrap_ProSHADE_settings_phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10249  PyObject *resultobj = 0;
10251  unsigned int arg2 ;
10252  void *argp1 = 0 ;
10253  int res1 = 0 ;
10254  unsigned int val2 ;
10255  int ecode2 = 0 ;
10256  PyObject * obj0 = 0 ;
10257  PyObject * obj1 = 0 ;
10258 
10259  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_phi_set",&obj0,&obj1)) SWIG_fail;
10260  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10261  if (!SWIG_IsOK(res1)) {
10262  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_phi_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10263  }
10264  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10265  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10266  if (!SWIG_IsOK(ecode2)) {
10267  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_phi_set" "', argument " "2"" of type '" "unsigned int""'");
10268  }
10269  arg2 = static_cast< unsigned int >(val2);
10270  if (arg1) (arg1)->phi = arg2;
10271  resultobj = SWIG_Py_Void();
10272  return resultobj;
10273 fail:
10274  return NULL;
10275 }
10276 
10277 
10278 SWIGINTERN PyObject *_wrap_ProSHADE_settings_phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279  PyObject *resultobj = 0;
10281  void *argp1 = 0 ;
10282  int res1 = 0 ;
10283  PyObject * obj0 = 0 ;
10284  unsigned int result;
10285 
10286  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_phi_get",&obj0)) SWIG_fail;
10287  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10288  if (!SWIG_IsOK(res1)) {
10289  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_phi_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10290  }
10291  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10292  result = (unsigned int) ((arg1)->phi);
10293  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10294  return resultobj;
10295 fail:
10296  return NULL;
10297 }
10298 
10299 
10300 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapResDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10301  PyObject *resultobj = 0;
10303  bool arg2 ;
10304  void *argp1 = 0 ;
10305  int res1 = 0 ;
10306  bool val2 ;
10307  int ecode2 = 0 ;
10308  PyObject * obj0 = 0 ;
10309  PyObject * obj1 = 0 ;
10310 
10311  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mapResDefault_set",&obj0,&obj1)) SWIG_fail;
10312  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10313  if (!SWIG_IsOK(res1)) {
10314  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapResDefault_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10315  }
10316  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10317  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10318  if (!SWIG_IsOK(ecode2)) {
10319  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_mapResDefault_set" "', argument " "2"" of type '" "bool""'");
10320  }
10321  arg2 = static_cast< bool >(val2);
10322  if (arg1) (arg1)->mapResDefault = arg2;
10323  resultobj = SWIG_Py_Void();
10324  return resultobj;
10325 fail:
10326  return NULL;
10327 }
10328 
10329 
10330 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapResDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10331  PyObject *resultobj = 0;
10333  void *argp1 = 0 ;
10334  int res1 = 0 ;
10335  PyObject * obj0 = 0 ;
10336  bool result;
10337 
10338  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mapResDefault_get",&obj0)) SWIG_fail;
10339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10340  if (!SWIG_IsOK(res1)) {
10341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapResDefault_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10342  }
10343  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10344  result = (bool) ((arg1)->mapResDefault);
10345  resultobj = SWIG_From_bool(static_cast< bool >(result));
10346  return resultobj;
10347 fail:
10348  return NULL;
10349 }
10350 
10351 
10352 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bFactorValue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10353  PyObject *resultobj = 0;
10355  double arg2 ;
10356  void *argp1 = 0 ;
10357  int res1 = 0 ;
10358  double val2 ;
10359  int ecode2 = 0 ;
10360  PyObject * obj0 = 0 ;
10361  PyObject * obj1 = 0 ;
10362 
10363  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_bFactorValue_set",&obj0,&obj1)) SWIG_fail;
10364  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10365  if (!SWIG_IsOK(res1)) {
10366  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bFactorValue_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10367  }
10368  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10369  ecode2 = SWIG_AsVal_double(obj1, &val2);
10370  if (!SWIG_IsOK(ecode2)) {
10371  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_bFactorValue_set" "', argument " "2"" of type '" "double""'");
10372  }
10373  arg2 = static_cast< double >(val2);
10374  if (arg1) (arg1)->bFactorValue = arg2;
10375  resultobj = SWIG_Py_Void();
10376  return resultobj;
10377 fail:
10378  return NULL;
10379 }
10380 
10381 
10382 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bFactorValue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10383  PyObject *resultobj = 0;
10385  void *argp1 = 0 ;
10386  int res1 = 0 ;
10387  PyObject * obj0 = 0 ;
10388  double result;
10389 
10390  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_bFactorValue_get",&obj0)) SWIG_fail;
10391  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10392  if (!SWIG_IsOK(res1)) {
10393  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bFactorValue_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10394  }
10395  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10396  result = (double) ((arg1)->bFactorValue);
10397  resultobj = SWIG_From_double(static_cast< double >(result));
10398  return resultobj;
10399 fail:
10400  return NULL;
10401 }
10402 
10403 
10404 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bFactorChange_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10405  PyObject *resultobj = 0;
10407  double arg2 ;
10408  void *argp1 = 0 ;
10409  int res1 = 0 ;
10410  double val2 ;
10411  int ecode2 = 0 ;
10412  PyObject * obj0 = 0 ;
10413  PyObject * obj1 = 0 ;
10414 
10415  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_bFactorChange_set",&obj0,&obj1)) SWIG_fail;
10416  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10417  if (!SWIG_IsOK(res1)) {
10418  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bFactorChange_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10419  }
10420  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10421  ecode2 = SWIG_AsVal_double(obj1, &val2);
10422  if (!SWIG_IsOK(ecode2)) {
10423  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_bFactorChange_set" "', argument " "2"" of type '" "double""'");
10424  }
10425  arg2 = static_cast< double >(val2);
10426  if (arg1) (arg1)->bFactorChange = arg2;
10427  resultobj = SWIG_Py_Void();
10428  return resultobj;
10429 fail:
10430  return NULL;
10431 }
10432 
10433 
10434 SWIGINTERN PyObject *_wrap_ProSHADE_settings_bFactorChange_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435  PyObject *resultobj = 0;
10437  void *argp1 = 0 ;
10438  int res1 = 0 ;
10439  PyObject * obj0 = 0 ;
10440  double result;
10441 
10442  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_bFactorChange_get",&obj0)) SWIG_fail;
10443  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10444  if (!SWIG_IsOK(res1)) {
10445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_bFactorChange_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10446  }
10447  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10448  result = (double) ((arg1)->bFactorChange);
10449  resultobj = SWIG_From_double(static_cast< double >(result));
10450  return resultobj;
10451 fail:
10452  return NULL;
10453 }
10454 
10455 
10456 SWIGINTERN PyObject *_wrap_ProSHADE_settings_noIQRsFromMap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457  PyObject *resultobj = 0;
10459  double arg2 ;
10460  void *argp1 = 0 ;
10461  int res1 = 0 ;
10462  double val2 ;
10463  int ecode2 = 0 ;
10464  PyObject * obj0 = 0 ;
10465  PyObject * obj1 = 0 ;
10466 
10467  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_noIQRsFromMap_set",&obj0,&obj1)) SWIG_fail;
10468  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10469  if (!SWIG_IsOK(res1)) {
10470  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_noIQRsFromMap_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10471  }
10472  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10473  ecode2 = SWIG_AsVal_double(obj1, &val2);
10474  if (!SWIG_IsOK(ecode2)) {
10475  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_noIQRsFromMap_set" "', argument " "2"" of type '" "double""'");
10476  }
10477  arg2 = static_cast< double >(val2);
10478  if (arg1) (arg1)->noIQRsFromMap = arg2;
10479  resultobj = SWIG_Py_Void();
10480  return resultobj;
10481 fail:
10482  return NULL;
10483 }
10484 
10485 
10486 SWIGINTERN PyObject *_wrap_ProSHADE_settings_noIQRsFromMap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10487  PyObject *resultobj = 0;
10489  void *argp1 = 0 ;
10490  int res1 = 0 ;
10491  PyObject * obj0 = 0 ;
10492  double result;
10493 
10494  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_noIQRsFromMap_get",&obj0)) SWIG_fail;
10495  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10496  if (!SWIG_IsOK(res1)) {
10497  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_noIQRsFromMap_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10498  }
10499  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10500  result = (double) ((arg1)->noIQRsFromMap);
10501  resultobj = SWIG_From_double(static_cast< double >(result));
10502  return resultobj;
10503 fail:
10504  return NULL;
10505 }
10506 
10507 
10508 SWIGINTERN PyObject *_wrap_ProSHADE_settings_shellSpacing_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509  PyObject *resultobj = 0;
10511  double arg2 ;
10512  void *argp1 = 0 ;
10513  int res1 = 0 ;
10514  double val2 ;
10515  int ecode2 = 0 ;
10516  PyObject * obj0 = 0 ;
10517  PyObject * obj1 = 0 ;
10518 
10519  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_shellSpacing_set",&obj0,&obj1)) SWIG_fail;
10520  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10521  if (!SWIG_IsOK(res1)) {
10522  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_shellSpacing_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10523  }
10524  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10525  ecode2 = SWIG_AsVal_double(obj1, &val2);
10526  if (!SWIG_IsOK(ecode2)) {
10527  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_shellSpacing_set" "', argument " "2"" of type '" "double""'");
10528  }
10529  arg2 = static_cast< double >(val2);
10530  if (arg1) (arg1)->shellSpacing = arg2;
10531  resultobj = SWIG_Py_Void();
10532  return resultobj;
10533 fail:
10534  return NULL;
10535 }
10536 
10537 
10538 SWIGINTERN PyObject *_wrap_ProSHADE_settings_shellSpacing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10539  PyObject *resultobj = 0;
10541  void *argp1 = 0 ;
10542  int res1 = 0 ;
10543  PyObject * obj0 = 0 ;
10544  double result;
10545 
10546  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_shellSpacing_get",&obj0)) SWIG_fail;
10547  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10548  if (!SWIG_IsOK(res1)) {
10549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_shellSpacing_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10550  }
10551  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10552  result = (double) ((arg1)->shellSpacing);
10553  resultobj = SWIG_From_double(static_cast< double >(result));
10554  return resultobj;
10555 fail:
10556  return NULL;
10557 }
10558 
10559 
10560 SWIGINTERN PyObject *_wrap_ProSHADE_settings_manualShells_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10561  PyObject *resultobj = 0;
10563  unsigned int arg2 ;
10564  void *argp1 = 0 ;
10565  int res1 = 0 ;
10566  unsigned int val2 ;
10567  int ecode2 = 0 ;
10568  PyObject * obj0 = 0 ;
10569  PyObject * obj1 = 0 ;
10570 
10571  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_manualShells_set",&obj0,&obj1)) SWIG_fail;
10572  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10573  if (!SWIG_IsOK(res1)) {
10574  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_manualShells_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10575  }
10576  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10577  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10578  if (!SWIG_IsOK(ecode2)) {
10579  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_manualShells_set" "', argument " "2"" of type '" "unsigned int""'");
10580  }
10581  arg2 = static_cast< unsigned int >(val2);
10582  if (arg1) (arg1)->manualShells = arg2;
10583  resultobj = SWIG_Py_Void();
10584  return resultobj;
10585 fail:
10586  return NULL;
10587 }
10588 
10589 
10590 SWIGINTERN PyObject *_wrap_ProSHADE_settings_manualShells_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10591  PyObject *resultobj = 0;
10593  void *argp1 = 0 ;
10594  int res1 = 0 ;
10595  PyObject * obj0 = 0 ;
10596  unsigned int result;
10597 
10598  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_manualShells_get",&obj0)) SWIG_fail;
10599  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10600  if (!SWIG_IsOK(res1)) {
10601  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_manualShells_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10602  }
10603  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10604  result = (unsigned int) ((arg1)->manualShells);
10605  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10606  return resultobj;
10607 fail:
10608  return NULL;
10609 }
10610 
10611 
10612 SWIGINTERN PyObject *_wrap_ProSHADE_settings_usePhase_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10613  PyObject *resultobj = 0;
10615  bool arg2 ;
10616  void *argp1 = 0 ;
10617  int res1 = 0 ;
10618  bool val2 ;
10619  int ecode2 = 0 ;
10620  PyObject * obj0 = 0 ;
10621  PyObject * obj1 = 0 ;
10622 
10623  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_usePhase_set",&obj0,&obj1)) SWIG_fail;
10624  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10625  if (!SWIG_IsOK(res1)) {
10626  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_usePhase_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10627  }
10628  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10629  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10630  if (!SWIG_IsOK(ecode2)) {
10631  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_usePhase_set" "', argument " "2"" of type '" "bool""'");
10632  }
10633  arg2 = static_cast< bool >(val2);
10634  if (arg1) (arg1)->usePhase = arg2;
10635  resultobj = SWIG_Py_Void();
10636  return resultobj;
10637 fail:
10638  return NULL;
10639 }
10640 
10641 
10642 SWIGINTERN PyObject *_wrap_ProSHADE_settings_usePhase_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10643  PyObject *resultobj = 0;
10645  void *argp1 = 0 ;
10646  int res1 = 0 ;
10647  PyObject * obj0 = 0 ;
10648  bool result;
10649 
10650  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_usePhase_get",&obj0)) SWIG_fail;
10651  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10652  if (!SWIG_IsOK(res1)) {
10653  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_usePhase_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10654  }
10655  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10656  result = (bool) ((arg1)->usePhase);
10657  resultobj = SWIG_From_bool(static_cast< bool >(result));
10658  return resultobj;
10659 fail:
10660  return NULL;
10661 }
10662 
10663 
10664 SWIGINTERN PyObject *_wrap_ProSHADE_settings_useCOM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665  PyObject *resultobj = 0;
10667  bool arg2 ;
10668  void *argp1 = 0 ;
10669  int res1 = 0 ;
10670  bool val2 ;
10671  int ecode2 = 0 ;
10672  PyObject * obj0 = 0 ;
10673  PyObject * obj1 = 0 ;
10674 
10675  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_useCOM_set",&obj0,&obj1)) SWIG_fail;
10676  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10677  if (!SWIG_IsOK(res1)) {
10678  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_useCOM_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10679  }
10680  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10681  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10682  if (!SWIG_IsOK(ecode2)) {
10683  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_useCOM_set" "', argument " "2"" of type '" "bool""'");
10684  }
10685  arg2 = static_cast< bool >(val2);
10686  if (arg1) (arg1)->useCOM = arg2;
10687  resultobj = SWIG_Py_Void();
10688  return resultobj;
10689 fail:
10690  return NULL;
10691 }
10692 
10693 
10694 SWIGINTERN PyObject *_wrap_ProSHADE_settings_useCOM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10695  PyObject *resultobj = 0;
10697  void *argp1 = 0 ;
10698  int res1 = 0 ;
10699  PyObject * obj0 = 0 ;
10700  bool result;
10701 
10702  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_useCOM_get",&obj0)) SWIG_fail;
10703  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10704  if (!SWIG_IsOK(res1)) {
10705  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_useCOM_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10706  }
10707  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10708  result = (bool) ((arg1)->useCOM);
10709  resultobj = SWIG_From_bool(static_cast< bool >(result));
10710  return resultobj;
10711 fail:
10712  return NULL;
10713 }
10714 
10715 
10716 SWIGINTERN PyObject *_wrap_ProSHADE_settings_firstLineCOM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10717  PyObject *resultobj = 0;
10719  bool arg2 ;
10720  void *argp1 = 0 ;
10721  int res1 = 0 ;
10722  bool val2 ;
10723  int ecode2 = 0 ;
10724  PyObject * obj0 = 0 ;
10725  PyObject * obj1 = 0 ;
10726 
10727  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_firstLineCOM_set",&obj0,&obj1)) SWIG_fail;
10728  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10729  if (!SWIG_IsOK(res1)) {
10730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_firstLineCOM_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10731  }
10732  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10733  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10734  if (!SWIG_IsOK(ecode2)) {
10735  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_firstLineCOM_set" "', argument " "2"" of type '" "bool""'");
10736  }
10737  arg2 = static_cast< bool >(val2);
10738  if (arg1) (arg1)->firstLineCOM = arg2;
10739  resultobj = SWIG_Py_Void();
10740  return resultobj;
10741 fail:
10742  return NULL;
10743 }
10744 
10745 
10746 SWIGINTERN PyObject *_wrap_ProSHADE_settings_firstLineCOM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10747  PyObject *resultobj = 0;
10749  void *argp1 = 0 ;
10750  int res1 = 0 ;
10751  PyObject * obj0 = 0 ;
10752  bool result;
10753 
10754  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_firstLineCOM_get",&obj0)) SWIG_fail;
10755  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10756  if (!SWIG_IsOK(res1)) {
10757  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_firstLineCOM_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10758  }
10759  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10760  result = (bool) ((arg1)->firstLineCOM);
10761  resultobj = SWIG_From_bool(static_cast< bool >(result));
10762  return resultobj;
10763 fail:
10764  return NULL;
10765 }
10766 
10767 
10768 SWIGINTERN PyObject *_wrap_ProSHADE_settings_extraSpace_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10769  PyObject *resultobj = 0;
10771  double arg2 ;
10772  void *argp1 = 0 ;
10773  int res1 = 0 ;
10774  double val2 ;
10775  int ecode2 = 0 ;
10776  PyObject * obj0 = 0 ;
10777  PyObject * obj1 = 0 ;
10778 
10779  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_extraSpace_set",&obj0,&obj1)) SWIG_fail;
10780  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10781  if (!SWIG_IsOK(res1)) {
10782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_extraSpace_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10783  }
10784  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10785  ecode2 = SWIG_AsVal_double(obj1, &val2);
10786  if (!SWIG_IsOK(ecode2)) {
10787  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_extraSpace_set" "', argument " "2"" of type '" "double""'");
10788  }
10789  arg2 = static_cast< double >(val2);
10790  if (arg1) (arg1)->extraSpace = arg2;
10791  resultobj = SWIG_Py_Void();
10792  return resultobj;
10793 fail:
10794  return NULL;
10795 }
10796 
10797 
10798 SWIGINTERN PyObject *_wrap_ProSHADE_settings_extraSpace_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10799  PyObject *resultobj = 0;
10801  void *argp1 = 0 ;
10802  int res1 = 0 ;
10803  PyObject * obj0 = 0 ;
10804  double result;
10805 
10806  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_extraSpace_get",&obj0)) SWIG_fail;
10807  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10808  if (!SWIG_IsOK(res1)) {
10809  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_extraSpace_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10810  }
10811  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10812  result = (double) ((arg1)->extraSpace);
10813  resultobj = SWIG_From_double(static_cast< double >(result));
10814  return resultobj;
10815 fail:
10816  return NULL;
10817 }
10818 
10819 
10820 SWIGINTERN PyObject *_wrap_ProSHADE_settings_alpha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10821  PyObject *resultobj = 0;
10823  double arg2 ;
10824  void *argp1 = 0 ;
10825  int res1 = 0 ;
10826  double val2 ;
10827  int ecode2 = 0 ;
10828  PyObject * obj0 = 0 ;
10829  PyObject * obj1 = 0 ;
10830 
10831  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_alpha_set",&obj0,&obj1)) SWIG_fail;
10832  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10833  if (!SWIG_IsOK(res1)) {
10834  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_alpha_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10835  }
10836  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10837  ecode2 = SWIG_AsVal_double(obj1, &val2);
10838  if (!SWIG_IsOK(ecode2)) {
10839  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_alpha_set" "', argument " "2"" of type '" "double""'");
10840  }
10841  arg2 = static_cast< double >(val2);
10842  if (arg1) (arg1)->alpha = arg2;
10843  resultobj = SWIG_Py_Void();
10844  return resultobj;
10845 fail:
10846  return NULL;
10847 }
10848 
10849 
10850 SWIGINTERN PyObject *_wrap_ProSHADE_settings_alpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10851  PyObject *resultobj = 0;
10853  void *argp1 = 0 ;
10854  int res1 = 0 ;
10855  PyObject * obj0 = 0 ;
10856  double result;
10857 
10858  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_alpha_get",&obj0)) SWIG_fail;
10859  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10860  if (!SWIG_IsOK(res1)) {
10861  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_alpha_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10862  }
10863  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10864  result = (double) ((arg1)->alpha);
10865  resultobj = SWIG_From_double(static_cast< double >(result));
10866  return resultobj;
10867 fail:
10868  return NULL;
10869 }
10870 
10871 
10872 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mPower_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10873  PyObject *resultobj = 0;
10875  double arg2 ;
10876  void *argp1 = 0 ;
10877  int res1 = 0 ;
10878  double val2 ;
10879  int ecode2 = 0 ;
10880  PyObject * obj0 = 0 ;
10881  PyObject * obj1 = 0 ;
10882 
10883  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mPower_set",&obj0,&obj1)) SWIG_fail;
10884  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10885  if (!SWIG_IsOK(res1)) {
10886  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mPower_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10887  }
10888  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10889  ecode2 = SWIG_AsVal_double(obj1, &val2);
10890  if (!SWIG_IsOK(ecode2)) {
10891  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_mPower_set" "', argument " "2"" of type '" "double""'");
10892  }
10893  arg2 = static_cast< double >(val2);
10894  if (arg1) (arg1)->mPower = arg2;
10895  resultobj = SWIG_Py_Void();
10896  return resultobj;
10897 fail:
10898  return NULL;
10899 }
10900 
10901 
10902 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mPower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10903  PyObject *resultobj = 0;
10905  void *argp1 = 0 ;
10906  int res1 = 0 ;
10907  PyObject * obj0 = 0 ;
10908  double result;
10909 
10910  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mPower_get",&obj0)) SWIG_fail;
10911  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10912  if (!SWIG_IsOK(res1)) {
10913  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mPower_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10914  }
10915  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10916  result = (double) ((arg1)->mPower);
10917  resultobj = SWIG_From_double(static_cast< double >(result));
10918  return resultobj;
10919 fail:
10920  return NULL;
10921 }
10922 
10923 
10924 SWIGINTERN PyObject *_wrap_ProSHADE_settings_ignoreLs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10925  PyObject *resultobj = 0;
10927  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
10928  void *argp1 = 0 ;
10929  int res1 = 0 ;
10930  void *argp2 = 0 ;
10931  int res2 = 0 ;
10932  PyObject * obj0 = 0 ;
10933  PyObject * obj1 = 0 ;
10934 
10935  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_ignoreLs_set",&obj0,&obj1)) SWIG_fail;
10936  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10937  if (!SWIG_IsOK(res1)) {
10938  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_ignoreLs_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10939  }
10940  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10941  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
10942  if (!SWIG_IsOK(res2)) {
10943  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_ignoreLs_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'");
10944  }
10945  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
10946  if (arg1) (arg1)->ignoreLs = *arg2;
10947  resultobj = SWIG_Py_Void();
10948  return resultobj;
10949 fail:
10950  return NULL;
10951 }
10952 
10953 
10954 SWIGINTERN PyObject *_wrap_ProSHADE_settings_ignoreLs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10955  PyObject *resultobj = 0;
10957  void *argp1 = 0 ;
10958  int res1 = 0 ;
10959  PyObject * obj0 = 0 ;
10960  std::vector< int,std::allocator< int > > *result = 0 ;
10961 
10962  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_ignoreLs_get",&obj0)) SWIG_fail;
10963  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10964  if (!SWIG_IsOK(res1)) {
10965  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_ignoreLs_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10966  }
10967  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10968  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->ignoreLs);
10969  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
10970  return resultobj;
10971 fail:
10972  return NULL;
10973 }
10974 
10975 
10976 SWIGINTERN PyObject *_wrap_ProSHADE_settings_structFiles_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10977  PyObject *resultobj = 0;
10979  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
10980  void *argp1 = 0 ;
10981  int res1 = 0 ;
10982  void *argp2 = 0 ;
10983  int res2 = 0 ;
10984  PyObject * obj0 = 0 ;
10985  PyObject * obj1 = 0 ;
10986 
10987  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_structFiles_set",&obj0,&obj1)) SWIG_fail;
10988  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
10989  if (!SWIG_IsOK(res1)) {
10990  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_structFiles_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
10991  }
10992  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
10993  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
10994  if (!SWIG_IsOK(res2)) {
10995  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_structFiles_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'");
10996  }
10997  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
10998  if (arg1) (arg1)->structFiles = *arg2;
10999  resultobj = SWIG_Py_Void();
11000  return resultobj;
11001 fail:
11002  return NULL;
11003 }
11004 
11005 
11006 SWIGINTERN PyObject *_wrap_ProSHADE_settings_structFiles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11007  PyObject *resultobj = 0;
11009  void *argp1 = 0 ;
11010  int res1 = 0 ;
11011  PyObject * obj0 = 0 ;
11012  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
11013 
11014  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_structFiles_get",&obj0)) SWIG_fail;
11015  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11016  if (!SWIG_IsOK(res1)) {
11017  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_structFiles_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11018  }
11019  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11020  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->structFiles);
11021  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
11022  return resultobj;
11023 fail:
11024  return NULL;
11025 }
11026 
11027 
11028 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakHeightNoIQRs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11029  PyObject *resultobj = 0;
11031  double arg2 ;
11032  void *argp1 = 0 ;
11033  int res1 = 0 ;
11034  double val2 ;
11035  int ecode2 = 0 ;
11036  PyObject * obj0 = 0 ;
11037  PyObject * obj1 = 0 ;
11038 
11039  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_peakHeightNoIQRs_set",&obj0,&obj1)) SWIG_fail;
11040  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11041  if (!SWIG_IsOK(res1)) {
11042  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakHeightNoIQRs_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11043  }
11044  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11045  ecode2 = SWIG_AsVal_double(obj1, &val2);
11046  if (!SWIG_IsOK(ecode2)) {
11047  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_peakHeightNoIQRs_set" "', argument " "2"" of type '" "double""'");
11048  }
11049  arg2 = static_cast< double >(val2);
11050  if (arg1) (arg1)->peakHeightNoIQRs = arg2;
11051  resultobj = SWIG_Py_Void();
11052  return resultobj;
11053 fail:
11054  return NULL;
11055 }
11056 
11057 
11058 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakHeightNoIQRs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11059  PyObject *resultobj = 0;
11061  void *argp1 = 0 ;
11062  int res1 = 0 ;
11063  PyObject * obj0 = 0 ;
11064  double result;
11065 
11066  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_peakHeightNoIQRs_get",&obj0)) SWIG_fail;
11067  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11068  if (!SWIG_IsOK(res1)) {
11069  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakHeightNoIQRs_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11070  }
11071  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11072  result = (double) ((arg1)->peakHeightNoIQRs);
11073  resultobj = SWIG_From_double(static_cast< double >(result));
11074  return resultobj;
11075 fail:
11076  return NULL;
11077 }
11078 
11079 
11080 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakDistanceForReal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11081  PyObject *resultobj = 0;
11083  double arg2 ;
11084  void *argp1 = 0 ;
11085  int res1 = 0 ;
11086  double val2 ;
11087  int ecode2 = 0 ;
11088  PyObject * obj0 = 0 ;
11089  PyObject * obj1 = 0 ;
11090 
11091  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_peakDistanceForReal_set",&obj0,&obj1)) SWIG_fail;
11092  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11093  if (!SWIG_IsOK(res1)) {
11094  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakDistanceForReal_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11095  }
11096  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11097  ecode2 = SWIG_AsVal_double(obj1, &val2);
11098  if (!SWIG_IsOK(ecode2)) {
11099  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_peakDistanceForReal_set" "', argument " "2"" of type '" "double""'");
11100  }
11101  arg2 = static_cast< double >(val2);
11102  if (arg1) (arg1)->peakDistanceForReal = arg2;
11103  resultobj = SWIG_Py_Void();
11104  return resultobj;
11105 fail:
11106  return NULL;
11107 }
11108 
11109 
11110 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakDistanceForReal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11111  PyObject *resultobj = 0;
11113  void *argp1 = 0 ;
11114  int res1 = 0 ;
11115  PyObject * obj0 = 0 ;
11116  double result;
11117 
11118  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_peakDistanceForReal_get",&obj0)) SWIG_fail;
11119  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11120  if (!SWIG_IsOK(res1)) {
11121  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakDistanceForReal_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11122  }
11123  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11124  result = (double) ((arg1)->peakDistanceForReal);
11125  resultobj = SWIG_From_double(static_cast< double >(result));
11126  return resultobj;
11127 fail:
11128  return NULL;
11129 }
11130 
11131 
11132 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakSurroundingPoints_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11133  PyObject *resultobj = 0;
11135  int arg2 ;
11136  void *argp1 = 0 ;
11137  int res1 = 0 ;
11138  int val2 ;
11139  int ecode2 = 0 ;
11140  PyObject * obj0 = 0 ;
11141  PyObject * obj1 = 0 ;
11142 
11143  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_peakSurroundingPoints_set",&obj0,&obj1)) SWIG_fail;
11144  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11145  if (!SWIG_IsOK(res1)) {
11146  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakSurroundingPoints_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11147  }
11148  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11149  ecode2 = SWIG_AsVal_int(obj1, &val2);
11150  if (!SWIG_IsOK(ecode2)) {
11151  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_peakSurroundingPoints_set" "', argument " "2"" of type '" "int""'");
11152  }
11153  arg2 = static_cast< int >(val2);
11154  if (arg1) (arg1)->peakSurroundingPoints = arg2;
11155  resultobj = SWIG_Py_Void();
11156  return resultobj;
11157 fail:
11158  return NULL;
11159 }
11160 
11161 
11162 SWIGINTERN PyObject *_wrap_ProSHADE_settings_peakSurroundingPoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163  PyObject *resultobj = 0;
11165  void *argp1 = 0 ;
11166  int res1 = 0 ;
11167  PyObject * obj0 = 0 ;
11168  int result;
11169 
11170  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_peakSurroundingPoints_get",&obj0)) SWIG_fail;
11171  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11172  if (!SWIG_IsOK(res1)) {
11173  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_peakSurroundingPoints_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11174  }
11175  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11176  result = (int) ((arg1)->peakSurroundingPoints);
11177  resultobj = SWIG_From_int(static_cast< int >(result));
11178  return resultobj;
11179 fail:
11180  return NULL;
11181 }
11182 
11183 
11184 SWIGINTERN PyObject *_wrap_ProSHADE_settings_aaErrorTolerance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11185  PyObject *resultobj = 0;
11187  double arg2 ;
11188  void *argp1 = 0 ;
11189  int res1 = 0 ;
11190  double val2 ;
11191  int ecode2 = 0 ;
11192  PyObject * obj0 = 0 ;
11193  PyObject * obj1 = 0 ;
11194 
11195  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_aaErrorTolerance_set",&obj0,&obj1)) SWIG_fail;
11196  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11197  if (!SWIG_IsOK(res1)) {
11198  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_aaErrorTolerance_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11199  }
11200  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11201  ecode2 = SWIG_AsVal_double(obj1, &val2);
11202  if (!SWIG_IsOK(ecode2)) {
11203  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_aaErrorTolerance_set" "', argument " "2"" of type '" "double""'");
11204  }
11205  arg2 = static_cast< double >(val2);
11206  if (arg1) (arg1)->aaErrorTolerance = arg2;
11207  resultobj = SWIG_Py_Void();
11208  return resultobj;
11209 fail:
11210  return NULL;
11211 }
11212 
11213 
11214 SWIGINTERN PyObject *_wrap_ProSHADE_settings_aaErrorTolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11215  PyObject *resultobj = 0;
11217  void *argp1 = 0 ;
11218  int res1 = 0 ;
11219  PyObject * obj0 = 0 ;
11220  double result;
11221 
11222  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_aaErrorTolerance_get",&obj0)) SWIG_fail;
11223  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11224  if (!SWIG_IsOK(res1)) {
11225  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_aaErrorTolerance_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11226  }
11227  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11228  result = (double) ((arg1)->aaErrorTolerance);
11229  resultobj = SWIG_From_double(static_cast< double >(result));
11230  return resultobj;
11231 fail:
11232  return NULL;
11233 }
11234 
11235 
11236 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symGapTolerance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11237  PyObject *resultobj = 0;
11239  double arg2 ;
11240  void *argp1 = 0 ;
11241  int res1 = 0 ;
11242  double val2 ;
11243  int ecode2 = 0 ;
11244  PyObject * obj0 = 0 ;
11245  PyObject * obj1 = 0 ;
11246 
11247  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_symGapTolerance_set",&obj0,&obj1)) SWIG_fail;
11248  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11249  if (!SWIG_IsOK(res1)) {
11250  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symGapTolerance_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11251  }
11252  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11253  ecode2 = SWIG_AsVal_double(obj1, &val2);
11254  if (!SWIG_IsOK(ecode2)) {
11255  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_symGapTolerance_set" "', argument " "2"" of type '" "double""'");
11256  }
11257  arg2 = static_cast< double >(val2);
11258  if (arg1) (arg1)->symGapTolerance = arg2;
11259  resultobj = SWIG_Py_Void();
11260  return resultobj;
11261 fail:
11262  return NULL;
11263 }
11264 
11265 
11266 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symGapTolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11267  PyObject *resultobj = 0;
11269  void *argp1 = 0 ;
11270  int res1 = 0 ;
11271  PyObject * obj0 = 0 ;
11272  double result;
11273 
11274  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_symGapTolerance_get",&obj0)) SWIG_fail;
11275  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11276  if (!SWIG_IsOK(res1)) {
11277  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symGapTolerance_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11278  }
11279  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11280  result = (double) ((arg1)->symGapTolerance);
11281  resultobj = SWIG_From_double(static_cast< double >(result));
11282  return resultobj;
11283 fail:
11284  return NULL;
11285 }
11286 
11287 
11288 SWIGINTERN PyObject *_wrap_ProSHADE_settings_energyLevelDist_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289  PyObject *resultobj = 0;
11291  bool arg2 ;
11292  void *argp1 = 0 ;
11293  int res1 = 0 ;
11294  bool val2 ;
11295  int ecode2 = 0 ;
11296  PyObject * obj0 = 0 ;
11297  PyObject * obj1 = 0 ;
11298 
11299  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_energyLevelDist_set",&obj0,&obj1)) SWIG_fail;
11300  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11301  if (!SWIG_IsOK(res1)) {
11302  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_energyLevelDist_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11303  }
11304  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11305  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11306  if (!SWIG_IsOK(ecode2)) {
11307  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_energyLevelDist_set" "', argument " "2"" of type '" "bool""'");
11308  }
11309  arg2 = static_cast< bool >(val2);
11310  if (arg1) (arg1)->energyLevelDist = arg2;
11311  resultobj = SWIG_Py_Void();
11312  return resultobj;
11313 fail:
11314  return NULL;
11315 }
11316 
11317 
11318 SWIGINTERN PyObject *_wrap_ProSHADE_settings_energyLevelDist_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11319  PyObject *resultobj = 0;
11321  void *argp1 = 0 ;
11322  int res1 = 0 ;
11323  PyObject * obj0 = 0 ;
11324  bool result;
11325 
11326  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_energyLevelDist_get",&obj0)) SWIG_fail;
11327  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11328  if (!SWIG_IsOK(res1)) {
11329  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_energyLevelDist_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11330  }
11331  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11332  result = (bool) ((arg1)->energyLevelDist);
11333  resultobj = SWIG_From_bool(static_cast< bool >(result));
11334  return resultobj;
11335 fail:
11336  return NULL;
11337 }
11338 
11339 
11340 SWIGINTERN PyObject *_wrap_ProSHADE_settings_traceSigmaDist_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11341  PyObject *resultobj = 0;
11343  bool arg2 ;
11344  void *argp1 = 0 ;
11345  int res1 = 0 ;
11346  bool val2 ;
11347  int ecode2 = 0 ;
11348  PyObject * obj0 = 0 ;
11349  PyObject * obj1 = 0 ;
11350 
11351  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_traceSigmaDist_set",&obj0,&obj1)) SWIG_fail;
11352  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11353  if (!SWIG_IsOK(res1)) {
11354  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_traceSigmaDist_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11355  }
11356  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11357  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11358  if (!SWIG_IsOK(ecode2)) {
11359  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_traceSigmaDist_set" "', argument " "2"" of type '" "bool""'");
11360  }
11361  arg2 = static_cast< bool >(val2);
11362  if (arg1) (arg1)->traceSigmaDist = arg2;
11363  resultobj = SWIG_Py_Void();
11364  return resultobj;
11365 fail:
11366  return NULL;
11367 }
11368 
11369 
11370 SWIGINTERN PyObject *_wrap_ProSHADE_settings_traceSigmaDist_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371  PyObject *resultobj = 0;
11373  void *argp1 = 0 ;
11374  int res1 = 0 ;
11375  PyObject * obj0 = 0 ;
11376  bool result;
11377 
11378  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_traceSigmaDist_get",&obj0)) SWIG_fail;
11379  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11380  if (!SWIG_IsOK(res1)) {
11381  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_traceSigmaDist_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11382  }
11383  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11384  result = (bool) ((arg1)->traceSigmaDist);
11385  resultobj = SWIG_From_bool(static_cast< bool >(result));
11386  return resultobj;
11387 fail:
11388  return NULL;
11389 }
11390 
11391 
11392 SWIGINTERN PyObject *_wrap_ProSHADE_settings_fullRotFnDist_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393  PyObject *resultobj = 0;
11395  bool arg2 ;
11396  void *argp1 = 0 ;
11397  int res1 = 0 ;
11398  bool val2 ;
11399  int ecode2 = 0 ;
11400  PyObject * obj0 = 0 ;
11401  PyObject * obj1 = 0 ;
11402 
11403  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_fullRotFnDist_set",&obj0,&obj1)) SWIG_fail;
11404  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11405  if (!SWIG_IsOK(res1)) {
11406  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_fullRotFnDist_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11407  }
11408  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11409  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11410  if (!SWIG_IsOK(ecode2)) {
11411  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_fullRotFnDist_set" "', argument " "2"" of type '" "bool""'");
11412  }
11413  arg2 = static_cast< bool >(val2);
11414  if (arg1) (arg1)->fullRotFnDist = arg2;
11415  resultobj = SWIG_Py_Void();
11416  return resultobj;
11417 fail:
11418  return NULL;
11419 }
11420 
11421 
11422 SWIGINTERN PyObject *_wrap_ProSHADE_settings_fullRotFnDist_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423  PyObject *resultobj = 0;
11425  void *argp1 = 0 ;
11426  int res1 = 0 ;
11427  PyObject * obj0 = 0 ;
11428  bool result;
11429 
11430  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_fullRotFnDist_get",&obj0)) SWIG_fail;
11431  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11432  if (!SWIG_IsOK(res1)) {
11433  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_fullRotFnDist_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11434  }
11435  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11436  result = (bool) ((arg1)->fullRotFnDist);
11437  resultobj = SWIG_From_bool(static_cast< bool >(result));
11438  return resultobj;
11439 fail:
11440  return NULL;
11441 }
11442 
11443 
11444 SWIGINTERN PyObject *_wrap_ProSHADE_settings_enLevelsThreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11445  PyObject *resultobj = 0;
11447  double arg2 ;
11448  void *argp1 = 0 ;
11449  int res1 = 0 ;
11450  double val2 ;
11451  int ecode2 = 0 ;
11452  PyObject * obj0 = 0 ;
11453  PyObject * obj1 = 0 ;
11454 
11455  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_enLevelsThreshold_set",&obj0,&obj1)) SWIG_fail;
11456  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11457  if (!SWIG_IsOK(res1)) {
11458  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_enLevelsThreshold_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11459  }
11460  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11461  ecode2 = SWIG_AsVal_double(obj1, &val2);
11462  if (!SWIG_IsOK(ecode2)) {
11463  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_enLevelsThreshold_set" "', argument " "2"" of type '" "double""'");
11464  }
11465  arg2 = static_cast< double >(val2);
11466  if (arg1) (arg1)->enLevelsThreshold = arg2;
11467  resultobj = SWIG_Py_Void();
11468  return resultobj;
11469 fail:
11470  return NULL;
11471 }
11472 
11473 
11474 SWIGINTERN PyObject *_wrap_ProSHADE_settings_enLevelsThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11475  PyObject *resultobj = 0;
11477  void *argp1 = 0 ;
11478  int res1 = 0 ;
11479  PyObject * obj0 = 0 ;
11480  double result;
11481 
11482  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_enLevelsThreshold_get",&obj0)) SWIG_fail;
11483  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11484  if (!SWIG_IsOK(res1)) {
11485  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_enLevelsThreshold_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11486  }
11487  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11488  result = (double) ((arg1)->enLevelsThreshold);
11489  resultobj = SWIG_From_double(static_cast< double >(result));
11490  return resultobj;
11491 fail:
11492  return NULL;
11493 }
11494 
11495 
11496 SWIGINTERN PyObject *_wrap_ProSHADE_settings_trSigmaThreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11497  PyObject *resultobj = 0;
11499  double arg2 ;
11500  void *argp1 = 0 ;
11501  int res1 = 0 ;
11502  double val2 ;
11503  int ecode2 = 0 ;
11504  PyObject * obj0 = 0 ;
11505  PyObject * obj1 = 0 ;
11506 
11507  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_trSigmaThreshold_set",&obj0,&obj1)) SWIG_fail;
11508  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11509  if (!SWIG_IsOK(res1)) {
11510  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_trSigmaThreshold_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11511  }
11512  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11513  ecode2 = SWIG_AsVal_double(obj1, &val2);
11514  if (!SWIG_IsOK(ecode2)) {
11515  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_trSigmaThreshold_set" "', argument " "2"" of type '" "double""'");
11516  }
11517  arg2 = static_cast< double >(val2);
11518  if (arg1) (arg1)->trSigmaThreshold = arg2;
11519  resultobj = SWIG_Py_Void();
11520  return resultobj;
11521 fail:
11522  return NULL;
11523 }
11524 
11525 
11526 SWIGINTERN PyObject *_wrap_ProSHADE_settings_trSigmaThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11527  PyObject *resultobj = 0;
11529  void *argp1 = 0 ;
11530  int res1 = 0 ;
11531  PyObject * obj0 = 0 ;
11532  double result;
11533 
11534  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_trSigmaThreshold_get",&obj0)) SWIG_fail;
11535  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11536  if (!SWIG_IsOK(res1)) {
11537  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_trSigmaThreshold_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11538  }
11539  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11540  result = (double) ((arg1)->trSigmaThreshold);
11541  resultobj = SWIG_From_double(static_cast< double >(result));
11542  return resultobj;
11543 fail:
11544  return NULL;
11545 }
11546 
11547 
11548 SWIGINTERN PyObject *_wrap_ProSHADE_settings_taskToPerform_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11549  PyObject *resultobj = 0;
11551  ProSHADE::Task arg2 ;
11552  void *argp1 = 0 ;
11553  int res1 = 0 ;
11554  int val2 ;
11555  int ecode2 = 0 ;
11556  PyObject * obj0 = 0 ;
11557  PyObject * obj1 = 0 ;
11558 
11559  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_taskToPerform_set",&obj0,&obj1)) SWIG_fail;
11560  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11561  if (!SWIG_IsOK(res1)) {
11562  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_taskToPerform_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11563  }
11564  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11565  ecode2 = SWIG_AsVal_int(obj1, &val2);
11566  if (!SWIG_IsOK(ecode2)) {
11567  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_taskToPerform_set" "', argument " "2"" of type '" "ProSHADE::Task""'");
11568  }
11569  arg2 = static_cast< ProSHADE::Task >(val2);
11570  if (arg1) (arg1)->taskToPerform = arg2;
11571  resultobj = SWIG_Py_Void();
11572  return resultobj;
11573 fail:
11574  return NULL;
11575 }
11576 
11577 
11578 SWIGINTERN PyObject *_wrap_ProSHADE_settings_taskToPerform_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11579  PyObject *resultobj = 0;
11581  void *argp1 = 0 ;
11582  int res1 = 0 ;
11583  PyObject * obj0 = 0 ;
11584  ProSHADE::Task result;
11585 
11586  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_taskToPerform_get",&obj0)) SWIG_fail;
11587  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11588  if (!SWIG_IsOK(res1)) {
11589  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_taskToPerform_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11590  }
11591  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11592  result = (ProSHADE::Task) ((arg1)->taskToPerform);
11593  resultobj = SWIG_From_int(static_cast< int >(result));
11594  return resultobj;
11595 fail:
11596  return NULL;
11597 }
11598 
11599 
11600 SWIGINTERN PyObject *_wrap_ProSHADE_settings_clearMapFile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11601  PyObject *resultobj = 0;
11603  std::string *arg2 = 0 ;
11604  void *argp1 = 0 ;
11605  int res1 = 0 ;
11606  int res2 = SWIG_OLDOBJ ;
11607  PyObject * obj0 = 0 ;
11608  PyObject * obj1 = 0 ;
11609 
11610  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_clearMapFile_set",&obj0,&obj1)) SWIG_fail;
11611  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11612  if (!SWIG_IsOK(res1)) {
11613  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_clearMapFile_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11614  }
11615  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11616  {
11617  std::string *ptr = (std::string *)0;
11618  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11619  if (!SWIG_IsOK(res2)) {
11620  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_clearMapFile_set" "', argument " "2"" of type '" "std::string const &""'");
11621  }
11622  if (!ptr) {
11623  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProSHADE_settings_clearMapFile_set" "', argument " "2"" of type '" "std::string const &""'");
11624  }
11625  arg2 = ptr;
11626  }
11627  if (arg1) (arg1)->clearMapFile = *arg2;
11628  resultobj = SWIG_Py_Void();
11629  if (SWIG_IsNewObj(res2)) delete arg2;
11630  return resultobj;
11631 fail:
11632  if (SWIG_IsNewObj(res2)) delete arg2;
11633  return NULL;
11634 }
11635 
11636 
11637 SWIGINTERN PyObject *_wrap_ProSHADE_settings_clearMapFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638  PyObject *resultobj = 0;
11640  void *argp1 = 0 ;
11641  int res1 = 0 ;
11642  PyObject * obj0 = 0 ;
11643  std::string *result = 0 ;
11644 
11645  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_clearMapFile_get",&obj0)) SWIG_fail;
11646  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11647  if (!SWIG_IsOK(res1)) {
11648  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_clearMapFile_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11649  }
11650  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11651  result = (std::string *) & ((arg1)->clearMapFile);
11652  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
11653  return resultobj;
11654 fail:
11655  return NULL;
11656 }
11657 
11658 
11659 SWIGINTERN PyObject *_wrap_ProSHADE_settings_useCubicMaps_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11660  PyObject *resultobj = 0;
11662  bool arg2 ;
11663  void *argp1 = 0 ;
11664  int res1 = 0 ;
11665  bool val2 ;
11666  int ecode2 = 0 ;
11667  PyObject * obj0 = 0 ;
11668  PyObject * obj1 = 0 ;
11669 
11670  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_useCubicMaps_set",&obj0,&obj1)) SWIG_fail;
11671  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11672  if (!SWIG_IsOK(res1)) {
11673  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_useCubicMaps_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11674  }
11675  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11676  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11677  if (!SWIG_IsOK(ecode2)) {
11678  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_useCubicMaps_set" "', argument " "2"" of type '" "bool""'");
11679  }
11680  arg2 = static_cast< bool >(val2);
11681  if (arg1) (arg1)->useCubicMaps = arg2;
11682  resultobj = SWIG_Py_Void();
11683  return resultobj;
11684 fail:
11685  return NULL;
11686 }
11687 
11688 
11689 SWIGINTERN PyObject *_wrap_ProSHADE_settings_useCubicMaps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11690  PyObject *resultobj = 0;
11692  void *argp1 = 0 ;
11693  int res1 = 0 ;
11694  PyObject * obj0 = 0 ;
11695  bool result;
11696 
11697  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_useCubicMaps_get",&obj0)) SWIG_fail;
11698  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11699  if (!SWIG_IsOK(res1)) {
11700  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_useCubicMaps_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11701  }
11702  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11703  result = (bool) ((arg1)->useCubicMaps);
11704  resultobj = SWIG_From_bool(static_cast< bool >(result));
11705  return resultobj;
11706 fail:
11707  return NULL;
11708 }
11709 
11710 
11711 SWIGINTERN PyObject *_wrap_ProSHADE_settings_clearMapData_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712  PyObject *resultobj = 0;
11714  bool arg2 ;
11715  void *argp1 = 0 ;
11716  int res1 = 0 ;
11717  bool val2 ;
11718  int ecode2 = 0 ;
11719  PyObject * obj0 = 0 ;
11720  PyObject * obj1 = 0 ;
11721 
11722  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_clearMapData_set",&obj0,&obj1)) SWIG_fail;
11723  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11724  if (!SWIG_IsOK(res1)) {
11725  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_clearMapData_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11726  }
11727  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11728  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11729  if (!SWIG_IsOK(ecode2)) {
11730  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_clearMapData_set" "', argument " "2"" of type '" "bool""'");
11731  }
11732  arg2 = static_cast< bool >(val2);
11733  if (arg1) (arg1)->clearMapData = arg2;
11734  resultobj = SWIG_Py_Void();
11735  return resultobj;
11736 fail:
11737  return NULL;
11738 }
11739 
11740 
11741 SWIGINTERN PyObject *_wrap_ProSHADE_settings_clearMapData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742  PyObject *resultobj = 0;
11744  void *argp1 = 0 ;
11745  int res1 = 0 ;
11746  PyObject * obj0 = 0 ;
11747  bool result;
11748 
11749  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_clearMapData_get",&obj0)) SWIG_fail;
11750  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11751  if (!SWIG_IsOK(res1)) {
11752  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_clearMapData_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11753  }
11754  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11755  result = (bool) ((arg1)->clearMapData);
11756  resultobj = SWIG_From_bool(static_cast< bool >(result));
11757  return resultobj;
11758 fail:
11759  return NULL;
11760 }
11761 
11762 
11763 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragBoxSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764  PyObject *resultobj = 0;
11766  double arg2 ;
11767  void *argp1 = 0 ;
11768  int res1 = 0 ;
11769  double val2 ;
11770  int ecode2 = 0 ;
11771  PyObject * obj0 = 0 ;
11772  PyObject * obj1 = 0 ;
11773 
11774  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mapFragBoxSize_set",&obj0,&obj1)) SWIG_fail;
11775  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11776  if (!SWIG_IsOK(res1)) {
11777  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragBoxSize_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11778  }
11779  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11780  ecode2 = SWIG_AsVal_double(obj1, &val2);
11781  if (!SWIG_IsOK(ecode2)) {
11782  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_mapFragBoxSize_set" "', argument " "2"" of type '" "double""'");
11783  }
11784  arg2 = static_cast< double >(val2);
11785  if (arg1) (arg1)->mapFragBoxSize = arg2;
11786  resultobj = SWIG_Py_Void();
11787  return resultobj;
11788 fail:
11789  return NULL;
11790 }
11791 
11792 
11793 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragBoxSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794  PyObject *resultobj = 0;
11796  void *argp1 = 0 ;
11797  int res1 = 0 ;
11798  PyObject * obj0 = 0 ;
11799  double result;
11800 
11801  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mapFragBoxSize_get",&obj0)) SWIG_fail;
11802  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11803  if (!SWIG_IsOK(res1)) {
11804  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragBoxSize_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11805  }
11806  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11807  result = (double) ((arg1)->mapFragBoxSize);
11808  resultobj = SWIG_From_double(static_cast< double >(result));
11809  return resultobj;
11810 fail:
11811  return NULL;
11812 }
11813 
11814 
11815 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11816  PyObject *resultobj = 0;
11818  std::string *arg2 = 0 ;
11819  void *argp1 = 0 ;
11820  int res1 = 0 ;
11821  int res2 = SWIG_OLDOBJ ;
11822  PyObject * obj0 = 0 ;
11823  PyObject * obj1 = 0 ;
11824 
11825  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mapFragName_set",&obj0,&obj1)) SWIG_fail;
11826  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11827  if (!SWIG_IsOK(res1)) {
11828  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragName_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11829  }
11830  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11831  {
11832  std::string *ptr = (std::string *)0;
11833  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11834  if (!SWIG_IsOK(res2)) {
11835  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_mapFragName_set" "', argument " "2"" of type '" "std::string const &""'");
11836  }
11837  if (!ptr) {
11838  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProSHADE_settings_mapFragName_set" "', argument " "2"" of type '" "std::string const &""'");
11839  }
11840  arg2 = ptr;
11841  }
11842  if (arg1) (arg1)->mapFragName = *arg2;
11843  resultobj = SWIG_Py_Void();
11844  if (SWIG_IsNewObj(res2)) delete arg2;
11845  return resultobj;
11846 fail:
11847  if (SWIG_IsNewObj(res2)) delete arg2;
11848  return NULL;
11849 }
11850 
11851 
11852 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11853  PyObject *resultobj = 0;
11855  void *argp1 = 0 ;
11856  int res1 = 0 ;
11857  PyObject * obj0 = 0 ;
11858  std::string *result = 0 ;
11859 
11860  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mapFragName_get",&obj0)) SWIG_fail;
11861  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11862  if (!SWIG_IsOK(res1)) {
11863  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragName_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11864  }
11865  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11866  result = (std::string *) & ((arg1)->mapFragName);
11867  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
11868  return resultobj;
11869 fail:
11870  return NULL;
11871 }
11872 
11873 
11874 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragBoxFraction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875  PyObject *resultobj = 0;
11877  double arg2 ;
11878  void *argp1 = 0 ;
11879  int res1 = 0 ;
11880  double val2 ;
11881  int ecode2 = 0 ;
11882  PyObject * obj0 = 0 ;
11883  PyObject * obj1 = 0 ;
11884 
11885  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_mapFragBoxFraction_set",&obj0,&obj1)) SWIG_fail;
11886  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11887  if (!SWIG_IsOK(res1)) {
11888  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragBoxFraction_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11889  }
11890  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11891  ecode2 = SWIG_AsVal_double(obj1, &val2);
11892  if (!SWIG_IsOK(ecode2)) {
11893  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_mapFragBoxFraction_set" "', argument " "2"" of type '" "double""'");
11894  }
11895  arg2 = static_cast< double >(val2);
11896  if (arg1) (arg1)->mapFragBoxFraction = arg2;
11897  resultobj = SWIG_Py_Void();
11898  return resultobj;
11899 fail:
11900  return NULL;
11901 }
11902 
11903 
11904 SWIGINTERN PyObject *_wrap_ProSHADE_settings_mapFragBoxFraction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905  PyObject *resultobj = 0;
11907  void *argp1 = 0 ;
11908  int res1 = 0 ;
11909  PyObject * obj0 = 0 ;
11910  double result;
11911 
11912  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_mapFragBoxFraction_get",&obj0)) SWIG_fail;
11913  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11914  if (!SWIG_IsOK(res1)) {
11915  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_mapFragBoxFraction_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11916  }
11917  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11918  result = (double) ((arg1)->mapFragBoxFraction);
11919  resultobj = SWIG_From_double(static_cast< double >(result));
11920  return resultobj;
11921 fail:
11922  return NULL;
11923 }
11924 
11925 
11926 SWIGINTERN PyObject *_wrap_ProSHADE_settings_databaseName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11927  PyObject *resultobj = 0;
11929  std::string *arg2 = 0 ;
11930  void *argp1 = 0 ;
11931  int res1 = 0 ;
11932  int res2 = SWIG_OLDOBJ ;
11933  PyObject * obj0 = 0 ;
11934  PyObject * obj1 = 0 ;
11935 
11936  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_databaseName_set",&obj0,&obj1)) SWIG_fail;
11937  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11938  if (!SWIG_IsOK(res1)) {
11939  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_databaseName_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11940  }
11941  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11942  {
11943  std::string *ptr = (std::string *)0;
11944  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11945  if (!SWIG_IsOK(res2)) {
11946  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_databaseName_set" "', argument " "2"" of type '" "std::string const &""'");
11947  }
11948  if (!ptr) {
11949  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProSHADE_settings_databaseName_set" "', argument " "2"" of type '" "std::string const &""'");
11950  }
11951  arg2 = ptr;
11952  }
11953  if (arg1) (arg1)->databaseName = *arg2;
11954  resultobj = SWIG_Py_Void();
11955  if (SWIG_IsNewObj(res2)) delete arg2;
11956  return resultobj;
11957 fail:
11958  if (SWIG_IsNewObj(res2)) delete arg2;
11959  return NULL;
11960 }
11961 
11962 
11963 SWIGINTERN PyObject *_wrap_ProSHADE_settings_databaseName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11964  PyObject *resultobj = 0;
11966  void *argp1 = 0 ;
11967  int res1 = 0 ;
11968  PyObject * obj0 = 0 ;
11969  std::string *result = 0 ;
11970 
11971  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_databaseName_get",&obj0)) SWIG_fail;
11972  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11973  if (!SWIG_IsOK(res1)) {
11974  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_databaseName_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
11975  }
11976  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
11977  result = (std::string *) & ((arg1)->databaseName);
11978  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
11979  return resultobj;
11980 fail:
11981  return NULL;
11982 }
11983 
11984 
11985 SWIGINTERN PyObject *_wrap_ProSHADE_settings_volumeTolerance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986  PyObject *resultobj = 0;
11988  double arg2 ;
11989  void *argp1 = 0 ;
11990  int res1 = 0 ;
11991  double val2 ;
11992  int ecode2 = 0 ;
11993  PyObject * obj0 = 0 ;
11994  PyObject * obj1 = 0 ;
11995 
11996  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_volumeTolerance_set",&obj0,&obj1)) SWIG_fail;
11997  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
11998  if (!SWIG_IsOK(res1)) {
11999  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_volumeTolerance_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12000  }
12001  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12002  ecode2 = SWIG_AsVal_double(obj1, &val2);
12003  if (!SWIG_IsOK(ecode2)) {
12004  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_volumeTolerance_set" "', argument " "2"" of type '" "double""'");
12005  }
12006  arg2 = static_cast< double >(val2);
12007  if (arg1) (arg1)->volumeTolerance = arg2;
12008  resultobj = SWIG_Py_Void();
12009  return resultobj;
12010 fail:
12011  return NULL;
12012 }
12013 
12014 
12015 SWIGINTERN PyObject *_wrap_ProSHADE_settings_volumeTolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12016  PyObject *resultobj = 0;
12018  void *argp1 = 0 ;
12019  int res1 = 0 ;
12020  PyObject * obj0 = 0 ;
12021  double result;
12022 
12023  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_volumeTolerance_get",&obj0)) SWIG_fail;
12024  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12025  if (!SWIG_IsOK(res1)) {
12026  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_volumeTolerance_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12027  }
12028  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12029  result = (double) ((arg1)->volumeTolerance);
12030  resultobj = SWIG_From_double(static_cast< double >(result));
12031  return resultobj;
12032 fail:
12033  return NULL;
12034 }
12035 
12036 
12037 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symmetryFold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038  PyObject *resultobj = 0;
12040  unsigned int arg2 ;
12041  void *argp1 = 0 ;
12042  int res1 = 0 ;
12043  unsigned int val2 ;
12044  int ecode2 = 0 ;
12045  PyObject * obj0 = 0 ;
12046  PyObject * obj1 = 0 ;
12047 
12048  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_symmetryFold_set",&obj0,&obj1)) SWIG_fail;
12049  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12050  if (!SWIG_IsOK(res1)) {
12051  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symmetryFold_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12052  }
12053  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12054  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
12055  if (!SWIG_IsOK(ecode2)) {
12056  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_symmetryFold_set" "', argument " "2"" of type '" "unsigned int""'");
12057  }
12058  arg2 = static_cast< unsigned int >(val2);
12059  if (arg1) (arg1)->symmetryFold = arg2;
12060  resultobj = SWIG_Py_Void();
12061  return resultobj;
12062 fail:
12063  return NULL;
12064 }
12065 
12066 
12067 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symmetryFold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12068  PyObject *resultobj = 0;
12070  void *argp1 = 0 ;
12071  int res1 = 0 ;
12072  PyObject * obj0 = 0 ;
12073  unsigned int result;
12074 
12075  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_symmetryFold_get",&obj0)) SWIG_fail;
12076  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12077  if (!SWIG_IsOK(res1)) {
12078  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symmetryFold_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12079  }
12080  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12081  result = (unsigned int) ((arg1)->symmetryFold);
12082  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
12083  return resultobj;
12084 fail:
12085  return NULL;
12086 }
12087 
12088 
12089 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symmetryType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090  PyObject *resultobj = 0;
12092  std::string *arg2 = 0 ;
12093  void *argp1 = 0 ;
12094  int res1 = 0 ;
12095  int res2 = SWIG_OLDOBJ ;
12096  PyObject * obj0 = 0 ;
12097  PyObject * obj1 = 0 ;
12098 
12099  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_symmetryType_set",&obj0,&obj1)) SWIG_fail;
12100  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12101  if (!SWIG_IsOK(res1)) {
12102  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symmetryType_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12103  }
12104  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12105  {
12106  std::string *ptr = (std::string *)0;
12107  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
12108  if (!SWIG_IsOK(res2)) {
12109  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_symmetryType_set" "', argument " "2"" of type '" "std::string const &""'");
12110  }
12111  if (!ptr) {
12112  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProSHADE_settings_symmetryType_set" "', argument " "2"" of type '" "std::string const &""'");
12113  }
12114  arg2 = ptr;
12115  }
12116  if (arg1) (arg1)->symmetryType = *arg2;
12117  resultobj = SWIG_Py_Void();
12118  if (SWIG_IsNewObj(res2)) delete arg2;
12119  return resultobj;
12120 fail:
12121  if (SWIG_IsNewObj(res2)) delete arg2;
12122  return NULL;
12123 }
12124 
12125 
12126 SWIGINTERN PyObject *_wrap_ProSHADE_settings_symmetryType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12127  PyObject *resultobj = 0;
12129  void *argp1 = 0 ;
12130  int res1 = 0 ;
12131  PyObject * obj0 = 0 ;
12132  std::string *result = 0 ;
12133 
12134  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_symmetryType_get",&obj0)) SWIG_fail;
12135  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12136  if (!SWIG_IsOK(res1)) {
12137  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_symmetryType_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12138  }
12139  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12140  result = (std::string *) & ((arg1)->symmetryType);
12141  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
12142  return resultobj;
12143 fail:
12144  return NULL;
12145 }
12146 
12147 
12148 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotAngle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12149  PyObject *resultobj = 0;
12151  double arg2 ;
12152  void *argp1 = 0 ;
12153  int res1 = 0 ;
12154  double val2 ;
12155  int ecode2 = 0 ;
12156  PyObject * obj0 = 0 ;
12157  PyObject * obj1 = 0 ;
12158 
12159  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_rotAngle_set",&obj0,&obj1)) SWIG_fail;
12160  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12161  if (!SWIG_IsOK(res1)) {
12162  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotAngle_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12163  }
12164  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12165  ecode2 = SWIG_AsVal_double(obj1, &val2);
12166  if (!SWIG_IsOK(ecode2)) {
12167  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_rotAngle_set" "', argument " "2"" of type '" "double""'");
12168  }
12169  arg2 = static_cast< double >(val2);
12170  if (arg1) (arg1)->rotAngle = arg2;
12171  resultobj = SWIG_Py_Void();
12172  return resultobj;
12173 fail:
12174  return NULL;
12175 }
12176 
12177 
12178 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotAngle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179  PyObject *resultobj = 0;
12181  void *argp1 = 0 ;
12182  int res1 = 0 ;
12183  PyObject * obj0 = 0 ;
12184  double result;
12185 
12186  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_rotAngle_get",&obj0)) SWIG_fail;
12187  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12188  if (!SWIG_IsOK(res1)) {
12189  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotAngle_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12190  }
12191  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12192  result = (double) ((arg1)->rotAngle);
12193  resultobj = SWIG_From_double(static_cast< double >(result));
12194  return resultobj;
12195 fail:
12196  return NULL;
12197 }
12198 
12199 
12200 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotXAxis_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201  PyObject *resultobj = 0;
12203  double arg2 ;
12204  void *argp1 = 0 ;
12205  int res1 = 0 ;
12206  double val2 ;
12207  int ecode2 = 0 ;
12208  PyObject * obj0 = 0 ;
12209  PyObject * obj1 = 0 ;
12210 
12211  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_rotXAxis_set",&obj0,&obj1)) SWIG_fail;
12212  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12213  if (!SWIG_IsOK(res1)) {
12214  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotXAxis_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12215  }
12216  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12217  ecode2 = SWIG_AsVal_double(obj1, &val2);
12218  if (!SWIG_IsOK(ecode2)) {
12219  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_rotXAxis_set" "', argument " "2"" of type '" "double""'");
12220  }
12221  arg2 = static_cast< double >(val2);
12222  if (arg1) (arg1)->rotXAxis = arg2;
12223  resultobj = SWIG_Py_Void();
12224  return resultobj;
12225 fail:
12226  return NULL;
12227 }
12228 
12229 
12230 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotXAxis_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12231  PyObject *resultobj = 0;
12233  void *argp1 = 0 ;
12234  int res1 = 0 ;
12235  PyObject * obj0 = 0 ;
12236  double result;
12237 
12238  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_rotXAxis_get",&obj0)) SWIG_fail;
12239  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12240  if (!SWIG_IsOK(res1)) {
12241  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotXAxis_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12242  }
12243  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12244  result = (double) ((arg1)->rotXAxis);
12245  resultobj = SWIG_From_double(static_cast< double >(result));
12246  return resultobj;
12247 fail:
12248  return NULL;
12249 }
12250 
12251 
12252 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotYAxis_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12253  PyObject *resultobj = 0;
12255  double arg2 ;
12256  void *argp1 = 0 ;
12257  int res1 = 0 ;
12258  double val2 ;
12259  int ecode2 = 0 ;
12260  PyObject * obj0 = 0 ;
12261  PyObject * obj1 = 0 ;
12262 
12263  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_rotYAxis_set",&obj0,&obj1)) SWIG_fail;
12264  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12265  if (!SWIG_IsOK(res1)) {
12266  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotYAxis_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12267  }
12268  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12269  ecode2 = SWIG_AsVal_double(obj1, &val2);
12270  if (!SWIG_IsOK(ecode2)) {
12271  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_rotYAxis_set" "', argument " "2"" of type '" "double""'");
12272  }
12273  arg2 = static_cast< double >(val2);
12274  if (arg1) (arg1)->rotYAxis = arg2;
12275  resultobj = SWIG_Py_Void();
12276  return resultobj;
12277 fail:
12278  return NULL;
12279 }
12280 
12281 
12282 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotYAxis_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283  PyObject *resultobj = 0;
12285  void *argp1 = 0 ;
12286  int res1 = 0 ;
12287  PyObject * obj0 = 0 ;
12288  double result;
12289 
12290  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_rotYAxis_get",&obj0)) SWIG_fail;
12291  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12292  if (!SWIG_IsOK(res1)) {
12293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotYAxis_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12294  }
12295  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12296  result = (double) ((arg1)->rotYAxis);
12297  resultobj = SWIG_From_double(static_cast< double >(result));
12298  return resultobj;
12299 fail:
12300  return NULL;
12301 }
12302 
12303 
12304 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotZAxis_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12305  PyObject *resultobj = 0;
12307  double arg2 ;
12308  void *argp1 = 0 ;
12309  int res1 = 0 ;
12310  double val2 ;
12311  int ecode2 = 0 ;
12312  PyObject * obj0 = 0 ;
12313  PyObject * obj1 = 0 ;
12314 
12315  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_rotZAxis_set",&obj0,&obj1)) SWIG_fail;
12316  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12317  if (!SWIG_IsOK(res1)) {
12318  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotZAxis_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12319  }
12320  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12321  ecode2 = SWIG_AsVal_double(obj1, &val2);
12322  if (!SWIG_IsOK(ecode2)) {
12323  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_rotZAxis_set" "', argument " "2"" of type '" "double""'");
12324  }
12325  arg2 = static_cast< double >(val2);
12326  if (arg1) (arg1)->rotZAxis = arg2;
12327  resultobj = SWIG_Py_Void();
12328  return resultobj;
12329 fail:
12330  return NULL;
12331 }
12332 
12333 
12334 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotZAxis_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335  PyObject *resultobj = 0;
12337  void *argp1 = 0 ;
12338  int res1 = 0 ;
12339  PyObject * obj0 = 0 ;
12340  double result;
12341 
12342  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_rotZAxis_get",&obj0)) SWIG_fail;
12343  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12344  if (!SWIG_IsOK(res1)) {
12345  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotZAxis_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12346  }
12347  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12348  result = (double) ((arg1)->rotZAxis);
12349  resultobj = SWIG_From_double(static_cast< double >(result));
12350  return resultobj;
12351 fail:
12352  return NULL;
12353 }
12354 
12355 
12356 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotChangeDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357  PyObject *resultobj = 0;
12359  bool arg2 ;
12360  void *argp1 = 0 ;
12361  int res1 = 0 ;
12362  bool val2 ;
12363  int ecode2 = 0 ;
12364  PyObject * obj0 = 0 ;
12365  PyObject * obj1 = 0 ;
12366 
12367  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_rotChangeDefault_set",&obj0,&obj1)) SWIG_fail;
12368  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12369  if (!SWIG_IsOK(res1)) {
12370  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotChangeDefault_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12371  }
12372  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12373  ecode2 = SWIG_AsVal_bool(obj1, &val2);
12374  if (!SWIG_IsOK(ecode2)) {
12375  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_rotChangeDefault_set" "', argument " "2"" of type '" "bool""'");
12376  }
12377  arg2 = static_cast< bool >(val2);
12378  if (arg1) (arg1)->rotChangeDefault = arg2;
12379  resultobj = SWIG_Py_Void();
12380  return resultobj;
12381 fail:
12382  return NULL;
12383 }
12384 
12385 
12386 SWIGINTERN PyObject *_wrap_ProSHADE_settings_rotChangeDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12387  PyObject *resultobj = 0;
12389  void *argp1 = 0 ;
12390  int res1 = 0 ;
12391  PyObject * obj0 = 0 ;
12392  bool result;
12393 
12394  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_rotChangeDefault_get",&obj0)) SWIG_fail;
12395  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12396  if (!SWIG_IsOK(res1)) {
12397  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_rotChangeDefault_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12398  }
12399  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12400  result = (bool) ((arg1)->rotChangeDefault);
12401  resultobj = SWIG_From_bool(static_cast< bool >(result));
12402  return resultobj;
12403 fail:
12404  return NULL;
12405 }
12406 
12407 
12408 SWIGINTERN PyObject *_wrap_ProSHADE_settings_xTranslation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409  PyObject *resultobj = 0;
12411  double arg2 ;
12412  void *argp1 = 0 ;
12413  int res1 = 0 ;
12414  double val2 ;
12415  int ecode2 = 0 ;
12416  PyObject * obj0 = 0 ;
12417  PyObject * obj1 = 0 ;
12418 
12419  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_xTranslation_set",&obj0,&obj1)) SWIG_fail;
12420  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12421  if (!SWIG_IsOK(res1)) {
12422  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_xTranslation_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12423  }
12424  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12425  ecode2 = SWIG_AsVal_double(obj1, &val2);
12426  if (!SWIG_IsOK(ecode2)) {
12427  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_xTranslation_set" "', argument " "2"" of type '" "double""'");
12428  }
12429  arg2 = static_cast< double >(val2);
12430  if (arg1) (arg1)->xTranslation = arg2;
12431  resultobj = SWIG_Py_Void();
12432  return resultobj;
12433 fail:
12434  return NULL;
12435 }
12436 
12437 
12438 SWIGINTERN PyObject *_wrap_ProSHADE_settings_xTranslation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12439  PyObject *resultobj = 0;
12441  void *argp1 = 0 ;
12442  int res1 = 0 ;
12443  PyObject * obj0 = 0 ;
12444  double result;
12445 
12446  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_xTranslation_get",&obj0)) SWIG_fail;
12447  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12448  if (!SWIG_IsOK(res1)) {
12449  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_xTranslation_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12450  }
12451  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12452  result = (double) ((arg1)->xTranslation);
12453  resultobj = SWIG_From_double(static_cast< double >(result));
12454  return resultobj;
12455 fail:
12456  return NULL;
12457 }
12458 
12459 
12460 SWIGINTERN PyObject *_wrap_ProSHADE_settings_yTranslation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461  PyObject *resultobj = 0;
12463  double arg2 ;
12464  void *argp1 = 0 ;
12465  int res1 = 0 ;
12466  double val2 ;
12467  int ecode2 = 0 ;
12468  PyObject * obj0 = 0 ;
12469  PyObject * obj1 = 0 ;
12470 
12471  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_yTranslation_set",&obj0,&obj1)) SWIG_fail;
12472  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12473  if (!SWIG_IsOK(res1)) {
12474  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_yTranslation_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12475  }
12476  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12477  ecode2 = SWIG_AsVal_double(obj1, &val2);
12478  if (!SWIG_IsOK(ecode2)) {
12479  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_yTranslation_set" "', argument " "2"" of type '" "double""'");
12480  }
12481  arg2 = static_cast< double >(val2);
12482  if (arg1) (arg1)->yTranslation = arg2;
12483  resultobj = SWIG_Py_Void();
12484  return resultobj;
12485 fail:
12486  return NULL;
12487 }
12488 
12489 
12490 SWIGINTERN PyObject *_wrap_ProSHADE_settings_yTranslation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12491  PyObject *resultobj = 0;
12493  void *argp1 = 0 ;
12494  int res1 = 0 ;
12495  PyObject * obj0 = 0 ;
12496  double result;
12497 
12498  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_yTranslation_get",&obj0)) SWIG_fail;
12499  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12500  if (!SWIG_IsOK(res1)) {
12501  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_yTranslation_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12502  }
12503  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12504  result = (double) ((arg1)->yTranslation);
12505  resultobj = SWIG_From_double(static_cast< double >(result));
12506  return resultobj;
12507 fail:
12508  return NULL;
12509 }
12510 
12511 
12512 SWIGINTERN PyObject *_wrap_ProSHADE_settings_zTranslation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12513  PyObject *resultobj = 0;
12515  double arg2 ;
12516  void *argp1 = 0 ;
12517  int res1 = 0 ;
12518  double val2 ;
12519  int ecode2 = 0 ;
12520  PyObject * obj0 = 0 ;
12521  PyObject * obj1 = 0 ;
12522 
12523  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_zTranslation_set",&obj0,&obj1)) SWIG_fail;
12524  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12525  if (!SWIG_IsOK(res1)) {
12526  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_zTranslation_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12527  }
12528  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12529  ecode2 = SWIG_AsVal_double(obj1, &val2);
12530  if (!SWIG_IsOK(ecode2)) {
12531  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_zTranslation_set" "', argument " "2"" of type '" "double""'");
12532  }
12533  arg2 = static_cast< double >(val2);
12534  if (arg1) (arg1)->zTranslation = arg2;
12535  resultobj = SWIG_Py_Void();
12536  return resultobj;
12537 fail:
12538  return NULL;
12539 }
12540 
12541 
12542 SWIGINTERN PyObject *_wrap_ProSHADE_settings_zTranslation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543  PyObject *resultobj = 0;
12545  void *argp1 = 0 ;
12546  int res1 = 0 ;
12547  PyObject * obj0 = 0 ;
12548  double result;
12549 
12550  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_zTranslation_get",&obj0)) SWIG_fail;
12551  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12552  if (!SWIG_IsOK(res1)) {
12553  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_zTranslation_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12554  }
12555  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12556  result = (double) ((arg1)->zTranslation);
12557  resultobj = SWIG_From_double(static_cast< double >(result));
12558  return resultobj;
12559 fail:
12560  return NULL;
12561 }
12562 
12563 
12564 SWIGINTERN PyObject *_wrap_ProSHADE_settings_overlayDefaults_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12565  PyObject *resultobj = 0;
12567  bool arg2 ;
12568  void *argp1 = 0 ;
12569  int res1 = 0 ;
12570  bool val2 ;
12571  int ecode2 = 0 ;
12572  PyObject * obj0 = 0 ;
12573  PyObject * obj1 = 0 ;
12574 
12575  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_overlayDefaults_set",&obj0,&obj1)) SWIG_fail;
12576  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12577  if (!SWIG_IsOK(res1)) {
12578  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_overlayDefaults_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12579  }
12580  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12581  ecode2 = SWIG_AsVal_bool(obj1, &val2);
12582  if (!SWIG_IsOK(ecode2)) {
12583  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_overlayDefaults_set" "', argument " "2"" of type '" "bool""'");
12584  }
12585  arg2 = static_cast< bool >(val2);
12586  if (arg1) (arg1)->overlayDefaults = arg2;
12587  resultobj = SWIG_Py_Void();
12588  return resultobj;
12589 fail:
12590  return NULL;
12591 }
12592 
12593 
12594 SWIGINTERN PyObject *_wrap_ProSHADE_settings_overlayDefaults_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12595  PyObject *resultobj = 0;
12597  void *argp1 = 0 ;
12598  int res1 = 0 ;
12599  PyObject * obj0 = 0 ;
12600  bool result;
12601 
12602  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_overlayDefaults_get",&obj0)) SWIG_fail;
12603  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12604  if (!SWIG_IsOK(res1)) {
12605  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_overlayDefaults_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12606  }
12607  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12608  result = (bool) ((arg1)->overlayDefaults);
12609  resultobj = SWIG_From_bool(static_cast< bool >(result));
12610  return resultobj;
12611 fail:
12612  return NULL;
12613 }
12614 
12615 
12616 SWIGINTERN PyObject *_wrap_ProSHADE_settings_axisOrder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12617  PyObject *resultobj = 0;
12619  std::string *arg2 = 0 ;
12620  void *argp1 = 0 ;
12621  int res1 = 0 ;
12622  int res2 = SWIG_OLDOBJ ;
12623  PyObject * obj0 = 0 ;
12624  PyObject * obj1 = 0 ;
12625 
12626  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_axisOrder_set",&obj0,&obj1)) SWIG_fail;
12627  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12628  if (!SWIG_IsOK(res1)) {
12629  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_axisOrder_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12630  }
12631  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12632  {
12633  std::string *ptr = (std::string *)0;
12634  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
12635  if (!SWIG_IsOK(res2)) {
12636  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProSHADE_settings_axisOrder_set" "', argument " "2"" of type '" "std::string const &""'");
12637  }
12638  if (!ptr) {
12639  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProSHADE_settings_axisOrder_set" "', argument " "2"" of type '" "std::string const &""'");
12640  }
12641  arg2 = ptr;
12642  }
12643  if (arg1) (arg1)->axisOrder = *arg2;
12644  resultobj = SWIG_Py_Void();
12645  if (SWIG_IsNewObj(res2)) delete arg2;
12646  return resultobj;
12647 fail:
12648  if (SWIG_IsNewObj(res2)) delete arg2;
12649  return NULL;
12650 }
12651 
12652 
12653 SWIGINTERN PyObject *_wrap_ProSHADE_settings_axisOrder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12654  PyObject *resultobj = 0;
12656  void *argp1 = 0 ;
12657  int res1 = 0 ;
12658  PyObject * obj0 = 0 ;
12659  std::string *result = 0 ;
12660 
12661  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_axisOrder_get",&obj0)) SWIG_fail;
12662  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12663  if (!SWIG_IsOK(res1)) {
12664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_axisOrder_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12665  }
12666  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12667  result = (std::string *) & ((arg1)->axisOrder);
12668  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
12669  return resultobj;
12670 fail:
12671  return NULL;
12672 }
12673 
12674 
12675 SWIGINTERN PyObject *_wrap_ProSHADE_settings_verbose_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12676  PyObject *resultobj = 0;
12678  int arg2 ;
12679  void *argp1 = 0 ;
12680  int res1 = 0 ;
12681  int val2 ;
12682  int ecode2 = 0 ;
12683  PyObject * obj0 = 0 ;
12684  PyObject * obj1 = 0 ;
12685 
12686  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_verbose_set",&obj0,&obj1)) SWIG_fail;
12687  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12688  if (!SWIG_IsOK(res1)) {
12689  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_verbose_set" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12690  }
12691  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12692  ecode2 = SWIG_AsVal_int(obj1, &val2);
12693  if (!SWIG_IsOK(ecode2)) {
12694  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_verbose_set" "', argument " "2"" of type '" "int""'");
12695  }
12696  arg2 = static_cast< int >(val2);
12697  if (arg1) (arg1)->verbose = arg2;
12698  resultobj = SWIG_Py_Void();
12699  return resultobj;
12700 fail:
12701  return NULL;
12702 }
12703 
12704 
12705 SWIGINTERN PyObject *_wrap_ProSHADE_settings_verbose_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12706  PyObject *resultobj = 0;
12708  void *argp1 = 0 ;
12709  int res1 = 0 ;
12710  PyObject * obj0 = 0 ;
12711  int result;
12712 
12713  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_verbose_get",&obj0)) SWIG_fail;
12714  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12715  if (!SWIG_IsOK(res1)) {
12716  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_verbose_get" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12717  }
12718  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12719  result = (int) ((arg1)->verbose);
12720  resultobj = SWIG_From_int(static_cast< int >(result));
12721  return resultobj;
12722 fail:
12723  return NULL;
12724 }
12725 
12726 
12727 SWIGINTERN PyObject *_wrap_new_ProSHADE_settings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12728  PyObject *resultobj = 0;
12729  ProSHADE::ProSHADE_settings *result = 0 ;
12730 
12731  if (!PyArg_ParseTuple(args,(char *)":new_ProSHADE_settings")) SWIG_fail;
12733  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProSHADE__ProSHADE_settings, SWIG_POINTER_NEW | 0 );
12734  return resultobj;
12735 fail:
12736  return NULL;
12737 }
12738 
12739 
12740 SWIGINTERN PyObject *_wrap_ProSHADE_settings_printSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741  PyObject *resultobj = 0;
12743  void *argp1 = 0 ;
12744  int res1 = 0 ;
12745  PyObject * obj0 = 0 ;
12746 
12747  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_settings_printSettings",&obj0)) SWIG_fail;
12748  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12749  if (!SWIG_IsOK(res1)) {
12750  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_printSettings" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12751  }
12752  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12753  (arg1)->printSettings();
12754  resultobj = SWIG_Py_Void();
12755  return resultobj;
12756 fail:
12757  return NULL;
12758 }
12759 
12760 
12761 SWIGINTERN PyObject *_wrap_ProSHADE_settings_getCommandLineParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12762  PyObject *resultobj = 0;
12764  int arg2 ;
12765  char **arg3 ;
12766  void *argp1 = 0 ;
12767  int res1 = 0 ;
12768  int val2 ;
12769  int ecode2 = 0 ;
12770  void *argp3 = 0 ;
12771  int res3 = 0 ;
12772  PyObject * obj0 = 0 ;
12773  PyObject * obj1 = 0 ;
12774  PyObject * obj2 = 0 ;
12775 
12776  if (!PyArg_ParseTuple(args,(char *)"OOO:ProSHADE_settings_getCommandLineParams",&obj0,&obj1,&obj2)) SWIG_fail;
12777  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12778  if (!SWIG_IsOK(res1)) {
12779  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_getCommandLineParams" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12780  }
12781  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12782  ecode2 = SWIG_AsVal_int(obj1, &val2);
12783  if (!SWIG_IsOK(ecode2)) {
12784  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_getCommandLineParams" "', argument " "2"" of type '" "int""'");
12785  }
12786  arg2 = static_cast< int >(val2);
12787  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 | 0 );
12788  if (!SWIG_IsOK(res3)) {
12789  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProSHADE_settings_getCommandLineParams" "', argument " "3"" of type '" "char *[]""'");
12790  }
12791  arg3 = reinterpret_cast< char ** >(argp3);
12792  (arg1)->getCommandLineParams(arg2,arg3);
12793  resultobj = SWIG_Py_Void();
12794  return resultobj;
12795 fail:
12796  return NULL;
12797 }
12798 
12799 
12800 SWIGINTERN PyObject *_wrap_ProSHADE_settings_ignoreLsAddValuePy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801  PyObject *resultobj = 0;
12803  int arg2 ;
12804  void *argp1 = 0 ;
12805  int res1 = 0 ;
12806  int val2 ;
12807  int ecode2 = 0 ;
12808  PyObject * obj0 = 0 ;
12809  PyObject * obj1 = 0 ;
12810 
12811  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_settings_ignoreLsAddValuePy",&obj0,&obj1)) SWIG_fail;
12812  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12813  if (!SWIG_IsOK(res1)) {
12814  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_settings_ignoreLsAddValuePy" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12815  }
12816  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12817  ecode2 = SWIG_AsVal_int(obj1, &val2);
12818  if (!SWIG_IsOK(ecode2)) {
12819  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProSHADE_settings_ignoreLsAddValuePy" "', argument " "2"" of type '" "int""'");
12820  }
12821  arg2 = static_cast< int >(val2);
12822  (arg1)->ignoreLsAddValuePy(arg2);
12823  resultobj = SWIG_Py_Void();
12824  return resultobj;
12825 fail:
12826  return NULL;
12827 }
12828 
12829 
12830 SWIGINTERN PyObject *_wrap_delete_ProSHADE_settings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831  PyObject *resultobj = 0;
12833  void *argp1 = 0 ;
12834  int res1 = 0 ;
12835  PyObject * obj0 = 0 ;
12836 
12837  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProSHADE_settings",&obj0)) SWIG_fail;
12838  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, SWIG_POINTER_DISOWN | 0 );
12839  if (!SWIG_IsOK(res1)) {
12840  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProSHADE_settings" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12841  }
12842  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12843  delete arg1;
12844  resultobj = SWIG_Py_Void();
12845  return resultobj;
12846 fail:
12847  return NULL;
12848 }
12849 
12850 
12851 SWIGINTERN PyObject *ProSHADE_settings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852  PyObject *obj;
12853  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
12854  SWIG_TypeNewClientData(SWIGTYPE_p_ProSHADE__ProSHADE_settings, SWIG_NewClientData(obj));
12855  return SWIG_Py_Void();
12856 }
12857 
12858 SWIGINTERN PyObject *_wrap_new_ProSHADE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12859  PyObject *resultobj = 0;
12861  void *argp1 = 0 ;
12862  int res1 = 0 ;
12863  PyObject * obj0 = 0 ;
12864  ProSHADE::ProSHADE *result = 0 ;
12865 
12866  if (!PyArg_ParseTuple(args,(char *)"O:new_ProSHADE",&obj0)) SWIG_fail;
12867  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE_settings, 0 | 0 );
12868  if (!SWIG_IsOK(res1)) {
12869  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProSHADE" "', argument " "1"" of type '" "ProSHADE::ProSHADE_settings *""'");
12870  }
12871  arg1 = reinterpret_cast< ProSHADE::ProSHADE_settings * >(argp1);
12872  result = (ProSHADE::ProSHADE *)new ProSHADE::ProSHADE(arg1);
12873  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProSHADE__ProSHADE, SWIG_POINTER_NEW | 0 );
12874  return resultobj;
12875 fail:
12876  return NULL;
12877 }
12878 
12879 
12880 SWIGINTERN PyObject *_wrap_delete_ProSHADE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881  PyObject *resultobj = 0;
12882  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12883  void *argp1 = 0 ;
12884  int res1 = 0 ;
12885  PyObject * obj0 = 0 ;
12886 
12887  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProSHADE",&obj0)) SWIG_fail;
12888  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, SWIG_POINTER_DISOWN | 0 );
12889  if (!SWIG_IsOK(res1)) {
12890  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProSHADE" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
12891  }
12892  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
12893  delete arg1;
12894  resultobj = SWIG_Py_Void();
12895  return resultobj;
12896 fail:
12897  return NULL;
12898 }
12899 
12900 
12901 SWIGINTERN PyObject *_wrap_ProSHADE_getCrossCorrDists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902  PyObject *resultobj = 0;
12903  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12904  void *argp1 = 0 ;
12905  int res1 = 0 ;
12906  PyObject * obj0 = 0 ;
12907  std::vector< double,std::allocator< double > > result;
12908 
12909  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getCrossCorrDists",&obj0)) SWIG_fail;
12910  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
12911  if (!SWIG_IsOK(res1)) {
12912  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getCrossCorrDists" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
12913  }
12914  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
12915  result = (arg1)->getCrossCorrDists();
12916  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
12917  return resultobj;
12918 fail:
12919  return NULL;
12920 }
12921 
12922 
12923 SWIGINTERN PyObject *_wrap_ProSHADE_getTraceSigmaDists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12924  PyObject *resultobj = 0;
12925  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12926  void *argp1 = 0 ;
12927  int res1 = 0 ;
12928  PyObject * obj0 = 0 ;
12929  std::vector< double,std::allocator< double > > result;
12930 
12931  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getTraceSigmaDists",&obj0)) SWIG_fail;
12932  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
12933  if (!SWIG_IsOK(res1)) {
12934  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getTraceSigmaDists" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
12935  }
12936  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
12937  result = (arg1)->getTraceSigmaDists();
12938  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
12939  return resultobj;
12940 fail:
12941  return NULL;
12942 }
12943 
12944 
12945 SWIGINTERN PyObject *_wrap_ProSHADE_getRotFunctionDists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12946  PyObject *resultobj = 0;
12947  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12948  void *argp1 = 0 ;
12949  int res1 = 0 ;
12950  PyObject * obj0 = 0 ;
12951  std::vector< double,std::allocator< double > > result;
12952 
12953  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getRotFunctionDists",&obj0)) SWIG_fail;
12954  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
12955  if (!SWIG_IsOK(res1)) {
12956  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getRotFunctionDists" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
12957  }
12958  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
12959  result = (arg1)->getRotFunctionDists();
12960  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
12961  return resultobj;
12962 fail:
12963  return NULL;
12964 }
12965 
12966 
12967 SWIGINTERN PyObject *_wrap_ProSHADE_getCyclicSymmetries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968  PyObject *resultobj = 0;
12969  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12970  void *argp1 = 0 ;
12971  int res1 = 0 ;
12972  PyObject * obj0 = 0 ;
12973  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
12974 
12975  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getCyclicSymmetries",&obj0)) SWIG_fail;
12976  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
12977  if (!SWIG_IsOK(res1)) {
12978  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getCyclicSymmetries" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
12979  }
12980  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
12981  result = (arg1)->getCyclicSymmetries();
12982  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
12983  return resultobj;
12984 fail:
12985  return NULL;
12986 }
12987 
12988 
12989 SWIGINTERN PyObject *_wrap_ProSHADE_getDihedralSymmetries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12990  PyObject *resultobj = 0;
12991  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
12992  void *argp1 = 0 ;
12993  int res1 = 0 ;
12994  PyObject * obj0 = 0 ;
12995  SwigValueWrapper< std::vector< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > >,std::allocator< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > > > > > result;
12996 
12997  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getDihedralSymmetries",&obj0)) SWIG_fail;
12998  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
12999  if (!SWIG_IsOK(res1)) {
13000  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getDihedralSymmetries" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13001  }
13002  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13003  result = (arg1)->getDihedralSymmetries();
13004  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > >,std::allocator< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > > > >(static_cast< const std::vector< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > >,std::allocator< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > > > >& >(result))), SWIGTYPE_p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t, SWIG_POINTER_OWN | 0 );
13005  return resultobj;
13006 fail:
13007  return NULL;
13008 }
13009 
13010 
13011 SWIGINTERN PyObject *_wrap_ProSHADE_getTetrahedralSymmetries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13012  PyObject *resultobj = 0;
13013  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13014  void *argp1 = 0 ;
13015  int res1 = 0 ;
13016  PyObject * obj0 = 0 ;
13017  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13018 
13019  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getTetrahedralSymmetries",&obj0)) SWIG_fail;
13020  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13021  if (!SWIG_IsOK(res1)) {
13022  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getTetrahedralSymmetries" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13023  }
13024  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13025  result = (arg1)->getTetrahedralSymmetries();
13026  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13027  return resultobj;
13028 fail:
13029  return NULL;
13030 }
13031 
13032 
13033 SWIGINTERN PyObject *_wrap_ProSHADE_getOctahedralSymmetries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13034  PyObject *resultobj = 0;
13035  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13036  void *argp1 = 0 ;
13037  int res1 = 0 ;
13038  PyObject * obj0 = 0 ;
13039  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13040 
13041  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getOctahedralSymmetries",&obj0)) SWIG_fail;
13042  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13043  if (!SWIG_IsOK(res1)) {
13044  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getOctahedralSymmetries" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13045  }
13046  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13047  result = (arg1)->getOctahedralSymmetries();
13048  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13049  return resultobj;
13050 fail:
13051  return NULL;
13052 }
13053 
13054 
13055 SWIGINTERN PyObject *_wrap_ProSHADE_getIcosahedralSymmetries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13056  PyObject *resultobj = 0;
13057  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13058  void *argp1 = 0 ;
13059  int res1 = 0 ;
13060  PyObject * obj0 = 0 ;
13061  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13062 
13063  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getIcosahedralSymmetries",&obj0)) SWIG_fail;
13064  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13065  if (!SWIG_IsOK(res1)) {
13066  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getIcosahedralSymmetries" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13067  }
13068  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13069  result = (arg1)->getIcosahedralSymmetries();
13070  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13071  return resultobj;
13072 fail:
13073  return NULL;
13074 }
13075 
13076 
13077 SWIGINTERN PyObject *_wrap_ProSHADE_getSymmetryElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13078  PyObject *resultobj = 0;
13079  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13080  void *argp1 = 0 ;
13081  int res1 = 0 ;
13082  PyObject * obj0 = 0 ;
13083  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13084 
13085  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getSymmetryElements",&obj0)) SWIG_fail;
13086  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13087  if (!SWIG_IsOK(res1)) {
13088  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSymmetryElements" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13089  }
13090  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13091  result = (arg1)->getSymmetryElements();
13092  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13093  return resultobj;
13094 fail:
13095  return NULL;
13096 }
13097 
13098 
13099 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100  PyObject *resultobj = 0;
13101  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13102  std::string arg2 ;
13103  int arg3 ;
13104  void *argp1 = 0 ;
13105  int res1 = 0 ;
13106  int val3 ;
13107  int ecode3 = 0 ;
13108  PyObject * obj0 = 0 ;
13109  PyObject * obj1 = 0 ;
13110  PyObject * obj2 = 0 ;
13111  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13112 
13113  if (!PyArg_ParseTuple(args,(char *)"OOO:ProSHADE_getSpecificSymmetryElements",&obj0,&obj1,&obj2)) SWIG_fail;
13114  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13115  if (!SWIG_IsOK(res1)) {
13116  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSpecificSymmetryElements" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13117  }
13118  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13119  {
13120  std::string *ptr = (std::string *)0;
13121  int res = SWIG_AsPtr_std_string(obj1, &ptr);
13122  if (!SWIG_IsOK(res) || !ptr) {
13123  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ProSHADE_getSpecificSymmetryElements" "', argument " "2"" of type '" "std::string""'");
13124  }
13125  arg2 = *ptr;
13126  if (SWIG_IsNewObj(res)) delete ptr;
13127  }
13128  ecode3 = SWIG_AsVal_int(obj2, &val3);
13129  if (!SWIG_IsOK(ecode3)) {
13130  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProSHADE_getSpecificSymmetryElements" "', argument " "3"" of type '" "int""'");
13131  }
13132  arg3 = static_cast< int >(val3);
13133  result = (arg1)->getSpecificSymmetryElements(arg2,arg3);
13134  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13135  return resultobj;
13136 fail:
13137  return NULL;
13138 }
13139 
13140 
13141 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElements__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142  PyObject *resultobj = 0;
13143  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13144  std::string arg2 ;
13145  void *argp1 = 0 ;
13146  int res1 = 0 ;
13147  PyObject * obj0 = 0 ;
13148  PyObject * obj1 = 0 ;
13149  SwigValueWrapper< std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > > result;
13150 
13151  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_getSpecificSymmetryElements",&obj0,&obj1)) SWIG_fail;
13152  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13153  if (!SWIG_IsOK(res1)) {
13154  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSpecificSymmetryElements" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13155  }
13156  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13157  {
13158  std::string *ptr = (std::string *)0;
13159  int res = SWIG_AsPtr_std_string(obj1, &ptr);
13160  if (!SWIG_IsOK(res) || !ptr) {
13161  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ProSHADE_getSpecificSymmetryElements" "', argument " "2"" of type '" "std::string""'");
13162  }
13163  arg2 = *ptr;
13164  if (SWIG_IsNewObj(res)) delete ptr;
13165  }
13166  result = (arg1)->getSpecificSymmetryElements(arg2);
13167  resultobj = SWIG_NewPointerObj((new std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >(static_cast< const std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > >& >(result))), SWIGTYPE_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, SWIG_POINTER_OWN | 0 );
13168  return resultobj;
13169 fail:
13170  return NULL;
13171 }
13172 
13173 
13174 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElements(PyObject *self, PyObject *args) {
13175  Py_ssize_t argc;
13176  PyObject *argv[4] = {
13177  0
13178  };
13179  Py_ssize_t ii;
13180 
13181  if (!PyTuple_Check(args)) SWIG_fail;
13182  argc = PyObject_Length(args);
13183  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13184  argv[ii] = PyTuple_GET_ITEM(args,ii);
13185  }
13186  if (argc == 2) {
13187  int _v;
13188  void *vptr = 0;
13189  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ProSHADE__ProSHADE, 0);
13190  _v = SWIG_CheckState(res);
13191  if (_v) {
13192  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13193  _v = SWIG_CheckState(res);
13194  if (_v) {
13195  return _wrap_ProSHADE_getSpecificSymmetryElements__SWIG_1(self, args);
13196  }
13197  }
13198  }
13199  if (argc == 3) {
13200  int _v;
13201  void *vptr = 0;
13202  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ProSHADE__ProSHADE, 0);
13203  _v = SWIG_CheckState(res);
13204  if (_v) {
13205  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13206  _v = SWIG_CheckState(res);
13207  if (_v) {
13208  {
13209  int res = SWIG_AsVal_int(argv[2], NULL);
13210  _v = SWIG_CheckState(res);
13211  }
13212  if (_v) {
13213  return _wrap_ProSHADE_getSpecificSymmetryElements__SWIG_0(self, args);
13214  }
13215  }
13216  }
13217  }
13218 
13219 fail:
13220  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProSHADE_getSpecificSymmetryElements'.\n"
13221  " Possible C/C++ prototypes are:\n"
13222  " ProSHADE::ProSHADE::getSpecificSymmetryElements(std::string,int)\n"
13223  " ProSHADE::ProSHADE::getSpecificSymmetryElements(std::string)\n");
13224  return 0;
13225 }
13226 
13227 
13228 SWIGINTERN PyObject *_wrap_ProSHADE_getCyclicSymmetriesPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13229  PyObject *resultobj = 0;
13230  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13231  void *argp1 = 0 ;
13232  int res1 = 0 ;
13233  PyObject * obj0 = 0 ;
13234  std::vector< double,std::allocator< double > > result;
13235 
13236  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getCyclicSymmetriesPy",&obj0)) SWIG_fail;
13237  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13238  if (!SWIG_IsOK(res1)) {
13239  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getCyclicSymmetriesPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13240  }
13241  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13242  result = (arg1)->getCyclicSymmetriesPy();
13243  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13244  return resultobj;
13245 fail:
13246  return NULL;
13247 }
13248 
13249 
13250 SWIGINTERN PyObject *_wrap_ProSHADE_getDihedralSymmetriesPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13251  PyObject *resultobj = 0;
13252  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13253  void *argp1 = 0 ;
13254  int res1 = 0 ;
13255  PyObject * obj0 = 0 ;
13256  std::vector< double,std::allocator< double > > result;
13257 
13258  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getDihedralSymmetriesPy",&obj0)) SWIG_fail;
13259  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13260  if (!SWIG_IsOK(res1)) {
13261  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getDihedralSymmetriesPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13262  }
13263  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13264  result = (arg1)->getDihedralSymmetriesPy();
13265  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13266  return resultobj;
13267 fail:
13268  return NULL;
13269 }
13270 
13271 
13272 SWIGINTERN PyObject *_wrap_ProSHADE_getTetrahedralSymmetriesPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13273  PyObject *resultobj = 0;
13274  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13275  void *argp1 = 0 ;
13276  int res1 = 0 ;
13277  PyObject * obj0 = 0 ;
13278  std::vector< double,std::allocator< double > > result;
13279 
13280  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getTetrahedralSymmetriesPy",&obj0)) SWIG_fail;
13281  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13282  if (!SWIG_IsOK(res1)) {
13283  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getTetrahedralSymmetriesPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13284  }
13285  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13286  result = (arg1)->getTetrahedralSymmetriesPy();
13287  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13288  return resultobj;
13289 fail:
13290  return NULL;
13291 }
13292 
13293 
13294 SWIGINTERN PyObject *_wrap_ProSHADE_getOctahedralSymmetriesPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13295  PyObject *resultobj = 0;
13296  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13297  void *argp1 = 0 ;
13298  int res1 = 0 ;
13299  PyObject * obj0 = 0 ;
13300  std::vector< double,std::allocator< double > > result;
13301 
13302  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getOctahedralSymmetriesPy",&obj0)) SWIG_fail;
13303  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13304  if (!SWIG_IsOK(res1)) {
13305  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getOctahedralSymmetriesPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13306  }
13307  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13308  result = (arg1)->getOctahedralSymmetriesPy();
13309  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13310  return resultobj;
13311 fail:
13312  return NULL;
13313 }
13314 
13315 
13316 SWIGINTERN PyObject *_wrap_ProSHADE_getIcosahedralSymmetriesPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13317  PyObject *resultobj = 0;
13318  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13319  void *argp1 = 0 ;
13320  int res1 = 0 ;
13321  PyObject * obj0 = 0 ;
13322  std::vector< double,std::allocator< double > > result;
13323 
13324  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getIcosahedralSymmetriesPy",&obj0)) SWIG_fail;
13325  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13326  if (!SWIG_IsOK(res1)) {
13327  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getIcosahedralSymmetriesPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13328  }
13329  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13330  result = (arg1)->getIcosahedralSymmetriesPy();
13331  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13332  return resultobj;
13333 fail:
13334  return NULL;
13335 }
13336 
13337 
13338 SWIGINTERN PyObject *_wrap_ProSHADE_getSymmetryElementsPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13339  PyObject *resultobj = 0;
13340  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13341  void *argp1 = 0 ;
13342  int res1 = 0 ;
13343  PyObject * obj0 = 0 ;
13344  std::vector< double,std::allocator< double > > result;
13345 
13346  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getSymmetryElementsPy",&obj0)) SWIG_fail;
13347  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13348  if (!SWIG_IsOK(res1)) {
13349  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSymmetryElementsPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13350  }
13351  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13352  result = (arg1)->getSymmetryElementsPy();
13353  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13354  return resultobj;
13355 fail:
13356  return NULL;
13357 }
13358 
13359 
13360 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElementsPy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13361  PyObject *resultobj = 0;
13362  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13363  std::string arg2 ;
13364  int arg3 ;
13365  void *argp1 = 0 ;
13366  int res1 = 0 ;
13367  int val3 ;
13368  int ecode3 = 0 ;
13369  PyObject * obj0 = 0 ;
13370  PyObject * obj1 = 0 ;
13371  PyObject * obj2 = 0 ;
13372  std::vector< double,std::allocator< double > > result;
13373 
13374  if (!PyArg_ParseTuple(args,(char *)"OOO:ProSHADE_getSpecificSymmetryElementsPy",&obj0,&obj1,&obj2)) SWIG_fail;
13375  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13376  if (!SWIG_IsOK(res1)) {
13377  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSpecificSymmetryElementsPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13378  }
13379  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13380  {
13381  std::string *ptr = (std::string *)0;
13382  int res = SWIG_AsPtr_std_string(obj1, &ptr);
13383  if (!SWIG_IsOK(res) || !ptr) {
13384  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ProSHADE_getSpecificSymmetryElementsPy" "', argument " "2"" of type '" "std::string""'");
13385  }
13386  arg2 = *ptr;
13387  if (SWIG_IsNewObj(res)) delete ptr;
13388  }
13389  ecode3 = SWIG_AsVal_int(obj2, &val3);
13390  if (!SWIG_IsOK(ecode3)) {
13391  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProSHADE_getSpecificSymmetryElementsPy" "', argument " "3"" of type '" "int""'");
13392  }
13393  arg3 = static_cast< int >(val3);
13394  result = (arg1)->getSpecificSymmetryElementsPy(arg2,arg3);
13395  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13396  return resultobj;
13397 fail:
13398  return NULL;
13399 }
13400 
13401 
13402 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElementsPy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13403  PyObject *resultobj = 0;
13404  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13405  std::string arg2 ;
13406  void *argp1 = 0 ;
13407  int res1 = 0 ;
13408  PyObject * obj0 = 0 ;
13409  PyObject * obj1 = 0 ;
13410  std::vector< double,std::allocator< double > > result;
13411 
13412  if (!PyArg_ParseTuple(args,(char *)"OO:ProSHADE_getSpecificSymmetryElementsPy",&obj0,&obj1)) SWIG_fail;
13413  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13414  if (!SWIG_IsOK(res1)) {
13415  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getSpecificSymmetryElementsPy" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13416  }
13417  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13418  {
13419  std::string *ptr = (std::string *)0;
13420  int res = SWIG_AsPtr_std_string(obj1, &ptr);
13421  if (!SWIG_IsOK(res) || !ptr) {
13422  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ProSHADE_getSpecificSymmetryElementsPy" "', argument " "2"" of type '" "std::string""'");
13423  }
13424  arg2 = *ptr;
13425  if (SWIG_IsNewObj(res)) delete ptr;
13426  }
13427  result = (arg1)->getSpecificSymmetryElementsPy(arg2);
13428  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
13429  return resultobj;
13430 fail:
13431  return NULL;
13432 }
13433 
13434 
13435 SWIGINTERN PyObject *_wrap_ProSHADE_getSpecificSymmetryElementsPy(PyObject *self, PyObject *args) {
13436  Py_ssize_t argc;
13437  PyObject *argv[4] = {
13438  0
13439  };
13440  Py_ssize_t ii;
13441 
13442  if (!PyTuple_Check(args)) SWIG_fail;
13443  argc = PyObject_Length(args);
13444  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13445  argv[ii] = PyTuple_GET_ITEM(args,ii);
13446  }
13447  if (argc == 2) {
13448  int _v;
13449  void *vptr = 0;
13450  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ProSHADE__ProSHADE, 0);
13451  _v = SWIG_CheckState(res);
13452  if (_v) {
13453  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13454  _v = SWIG_CheckState(res);
13455  if (_v) {
13456  return _wrap_ProSHADE_getSpecificSymmetryElementsPy__SWIG_1(self, args);
13457  }
13458  }
13459  }
13460  if (argc == 3) {
13461  int _v;
13462  void *vptr = 0;
13463  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ProSHADE__ProSHADE, 0);
13464  _v = SWIG_CheckState(res);
13465  if (_v) {
13466  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13467  _v = SWIG_CheckState(res);
13468  if (_v) {
13469  {
13470  int res = SWIG_AsVal_int(argv[2], NULL);
13471  _v = SWIG_CheckState(res);
13472  }
13473  if (_v) {
13474  return _wrap_ProSHADE_getSpecificSymmetryElementsPy__SWIG_0(self, args);
13475  }
13476  }
13477  }
13478  }
13479 
13480 fail:
13481  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProSHADE_getSpecificSymmetryElementsPy'.\n"
13482  " Possible C/C++ prototypes are:\n"
13483  " ProSHADE::ProSHADE::getSpecificSymmetryElementsPy(std::string,int)\n"
13484  " ProSHADE::ProSHADE::getSpecificSymmetryElementsPy(std::string)\n");
13485  return 0;
13486 }
13487 
13488 
13489 SWIGINTERN PyObject *_wrap_ProSHADE_getProSHADEVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13490  PyObject *resultobj = 0;
13491  ProSHADE::ProSHADE *arg1 = (ProSHADE::ProSHADE *) 0 ;
13492  void *argp1 = 0 ;
13493  int res1 = 0 ;
13494  PyObject * obj0 = 0 ;
13495  std::string result;
13496 
13497  if (!PyArg_ParseTuple(args,(char *)"O:ProSHADE_getProSHADEVersion",&obj0)) SWIG_fail;
13498  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ProSHADE__ProSHADE, 0 | 0 );
13499  if (!SWIG_IsOK(res1)) {
13500  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProSHADE_getProSHADEVersion" "', argument " "1"" of type '" "ProSHADE::ProSHADE *""'");
13501  }
13502  arg1 = reinterpret_cast< ProSHADE::ProSHADE * >(argp1);
13503  result = (arg1)->getProSHADEVersion();
13504  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
13505  return resultobj;
13506 fail:
13507  return NULL;
13508 }
13509 
13510 
13511 SWIGINTERN PyObject *ProSHADE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13512  PyObject *obj;
13513  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
13514  SWIG_TypeNewClientData(SWIGTYPE_p_ProSHADE__ProSHADE, SWIG_NewClientData(obj));
13515  return SWIG_Py_Void();
13516 }
13517 
13518 static PyMethodDef SwigMethods[] = {
13519  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
13520  { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
13521  { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
13522  { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
13523  { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
13524  { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
13525  { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
13526  { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
13527  { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
13528  { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
13529  { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
13530  { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
13531  { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
13532  { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
13533  { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
13534  { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
13535  { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
13536  { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
13537  { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
13538  { (char *)"StringList_iterator", _wrap_StringList_iterator, METH_VARARGS, NULL},
13539  { (char *)"StringList___nonzero__", _wrap_StringList___nonzero__, METH_VARARGS, NULL},
13540  { (char *)"StringList___bool__", _wrap_StringList___bool__, METH_VARARGS, NULL},
13541  { (char *)"StringList___len__", _wrap_StringList___len__, METH_VARARGS, NULL},
13542  { (char *)"StringList___getslice__", _wrap_StringList___getslice__, METH_VARARGS, NULL},
13543  { (char *)"StringList___setslice__", _wrap_StringList___setslice__, METH_VARARGS, NULL},
13544  { (char *)"StringList___delslice__", _wrap_StringList___delslice__, METH_VARARGS, NULL},
13545  { (char *)"StringList___delitem__", _wrap_StringList___delitem__, METH_VARARGS, NULL},
13546  { (char *)"StringList___getitem__", _wrap_StringList___getitem__, METH_VARARGS, NULL},
13547  { (char *)"StringList___setitem__", _wrap_StringList___setitem__, METH_VARARGS, NULL},
13548  { (char *)"StringList_pop", _wrap_StringList_pop, METH_VARARGS, NULL},
13549  { (char *)"StringList_append", _wrap_StringList_append, METH_VARARGS, NULL},
13550  { (char *)"StringList_empty", _wrap_StringList_empty, METH_VARARGS, NULL},
13551  { (char *)"StringList_size", _wrap_StringList_size, METH_VARARGS, NULL},
13552  { (char *)"StringList_swap", _wrap_StringList_swap, METH_VARARGS, NULL},
13553  { (char *)"StringList_begin", _wrap_StringList_begin, METH_VARARGS, NULL},
13554  { (char *)"StringList_end", _wrap_StringList_end, METH_VARARGS, NULL},
13555  { (char *)"StringList_rbegin", _wrap_StringList_rbegin, METH_VARARGS, NULL},
13556  { (char *)"StringList_rend", _wrap_StringList_rend, METH_VARARGS, NULL},
13557  { (char *)"StringList_clear", _wrap_StringList_clear, METH_VARARGS, NULL},
13558  { (char *)"StringList_get_allocator", _wrap_StringList_get_allocator, METH_VARARGS, NULL},
13559  { (char *)"StringList_pop_back", _wrap_StringList_pop_back, METH_VARARGS, NULL},
13560  { (char *)"StringList_erase", _wrap_StringList_erase, METH_VARARGS, NULL},
13561  { (char *)"new_StringList", _wrap_new_StringList, METH_VARARGS, NULL},
13562  { (char *)"StringList_push_back", _wrap_StringList_push_back, METH_VARARGS, NULL},
13563  { (char *)"StringList_front", _wrap_StringList_front, METH_VARARGS, NULL},
13564  { (char *)"StringList_back", _wrap_StringList_back, METH_VARARGS, NULL},
13565  { (char *)"StringList_assign", _wrap_StringList_assign, METH_VARARGS, NULL},
13566  { (char *)"StringList_resize", _wrap_StringList_resize, METH_VARARGS, NULL},
13567  { (char *)"StringList_insert", _wrap_StringList_insert, METH_VARARGS, NULL},
13568  { (char *)"StringList_reserve", _wrap_StringList_reserve, METH_VARARGS, NULL},
13569  { (char *)"StringList_capacity", _wrap_StringList_capacity, METH_VARARGS, NULL},
13570  { (char *)"delete_StringList", _wrap_delete_StringList, METH_VARARGS, NULL},
13571  { (char *)"StringList_swigregister", StringList_swigregister, METH_VARARGS, NULL},
13572  { (char *)"VecDouble_iterator", _wrap_VecDouble_iterator, METH_VARARGS, NULL},
13573  { (char *)"VecDouble___nonzero__", _wrap_VecDouble___nonzero__, METH_VARARGS, NULL},
13574  { (char *)"VecDouble___bool__", _wrap_VecDouble___bool__, METH_VARARGS, NULL},
13575  { (char *)"VecDouble___len__", _wrap_VecDouble___len__, METH_VARARGS, NULL},
13576  { (char *)"VecDouble___getslice__", _wrap_VecDouble___getslice__, METH_VARARGS, NULL},
13577  { (char *)"VecDouble___setslice__", _wrap_VecDouble___setslice__, METH_VARARGS, NULL},
13578  { (char *)"VecDouble___delslice__", _wrap_VecDouble___delslice__, METH_VARARGS, NULL},
13579  { (char *)"VecDouble___delitem__", _wrap_VecDouble___delitem__, METH_VARARGS, NULL},
13580  { (char *)"VecDouble___getitem__", _wrap_VecDouble___getitem__, METH_VARARGS, NULL},
13581  { (char *)"VecDouble___setitem__", _wrap_VecDouble___setitem__, METH_VARARGS, NULL},
13582  { (char *)"VecDouble_pop", _wrap_VecDouble_pop, METH_VARARGS, NULL},
13583  { (char *)"VecDouble_append", _wrap_VecDouble_append, METH_VARARGS, NULL},
13584  { (char *)"VecDouble_empty", _wrap_VecDouble_empty, METH_VARARGS, NULL},
13585  { (char *)"VecDouble_size", _wrap_VecDouble_size, METH_VARARGS, NULL},
13586  { (char *)"VecDouble_swap", _wrap_VecDouble_swap, METH_VARARGS, NULL},
13587  { (char *)"VecDouble_begin", _wrap_VecDouble_begin, METH_VARARGS, NULL},
13588  { (char *)"VecDouble_end", _wrap_VecDouble_end, METH_VARARGS, NULL},
13589  { (char *)"VecDouble_rbegin", _wrap_VecDouble_rbegin, METH_VARARGS, NULL},
13590  { (char *)"VecDouble_rend", _wrap_VecDouble_rend, METH_VARARGS, NULL},
13591  { (char *)"VecDouble_clear", _wrap_VecDouble_clear, METH_VARARGS, NULL},
13592  { (char *)"VecDouble_get_allocator", _wrap_VecDouble_get_allocator, METH_VARARGS, NULL},
13593  { (char *)"VecDouble_pop_back", _wrap_VecDouble_pop_back, METH_VARARGS, NULL},
13594  { (char *)"VecDouble_erase", _wrap_VecDouble_erase, METH_VARARGS, NULL},
13595  { (char *)"new_VecDouble", _wrap_new_VecDouble, METH_VARARGS, NULL},
13596  { (char *)"VecDouble_push_back", _wrap_VecDouble_push_back, METH_VARARGS, NULL},
13597  { (char *)"VecDouble_front", _wrap_VecDouble_front, METH_VARARGS, NULL},
13598  { (char *)"VecDouble_back", _wrap_VecDouble_back, METH_VARARGS, NULL},
13599  { (char *)"VecDouble_assign", _wrap_VecDouble_assign, METH_VARARGS, NULL},
13600  { (char *)"VecDouble_resize", _wrap_VecDouble_resize, METH_VARARGS, NULL},
13601  { (char *)"VecDouble_insert", _wrap_VecDouble_insert, METH_VARARGS, NULL},
13602  { (char *)"VecDouble_reserve", _wrap_VecDouble_reserve, METH_VARARGS, NULL},
13603  { (char *)"VecDouble_capacity", _wrap_VecDouble_capacity, METH_VARARGS, NULL},
13604  { (char *)"delete_VecDouble", _wrap_delete_VecDouble, METH_VARARGS, NULL},
13605  { (char *)"VecDouble_swigregister", VecDouble_swigregister, METH_VARARGS, NULL},
13606  { (char *)"ProSHADE_settings_mapResolution_set", _wrap_ProSHADE_settings_mapResolution_set, METH_VARARGS, NULL},
13607  { (char *)"ProSHADE_settings_mapResolution_get", _wrap_ProSHADE_settings_mapResolution_get, METH_VARARGS, NULL},
13608  { (char *)"ProSHADE_settings_bandwidth_set", _wrap_ProSHADE_settings_bandwidth_set, METH_VARARGS, NULL},
13609  { (char *)"ProSHADE_settings_bandwidth_get", _wrap_ProSHADE_settings_bandwidth_get, METH_VARARGS, NULL},
13610  { (char *)"ProSHADE_settings_glIntegOrder_set", _wrap_ProSHADE_settings_glIntegOrder_set, METH_VARARGS, NULL},
13611  { (char *)"ProSHADE_settings_glIntegOrder_get", _wrap_ProSHADE_settings_glIntegOrder_get, METH_VARARGS, NULL},
13612  { (char *)"ProSHADE_settings_theta_set", _wrap_ProSHADE_settings_theta_set, METH_VARARGS, NULL},
13613  { (char *)"ProSHADE_settings_theta_get", _wrap_ProSHADE_settings_theta_get, METH_VARARGS, NULL},
13614  { (char *)"ProSHADE_settings_phi_set", _wrap_ProSHADE_settings_phi_set, METH_VARARGS, NULL},
13615  { (char *)"ProSHADE_settings_phi_get", _wrap_ProSHADE_settings_phi_get, METH_VARARGS, NULL},
13616  { (char *)"ProSHADE_settings_mapResDefault_set", _wrap_ProSHADE_settings_mapResDefault_set, METH_VARARGS, NULL},
13617  { (char *)"ProSHADE_settings_mapResDefault_get", _wrap_ProSHADE_settings_mapResDefault_get, METH_VARARGS, NULL},
13618  { (char *)"ProSHADE_settings_bFactorValue_set", _wrap_ProSHADE_settings_bFactorValue_set, METH_VARARGS, NULL},
13619  { (char *)"ProSHADE_settings_bFactorValue_get", _wrap_ProSHADE_settings_bFactorValue_get, METH_VARARGS, NULL},
13620  { (char *)"ProSHADE_settings_bFactorChange_set", _wrap_ProSHADE_settings_bFactorChange_set, METH_VARARGS, NULL},
13621  { (char *)"ProSHADE_settings_bFactorChange_get", _wrap_ProSHADE_settings_bFactorChange_get, METH_VARARGS, NULL},
13622  { (char *)"ProSHADE_settings_noIQRsFromMap_set", _wrap_ProSHADE_settings_noIQRsFromMap_set, METH_VARARGS, NULL},
13623  { (char *)"ProSHADE_settings_noIQRsFromMap_get", _wrap_ProSHADE_settings_noIQRsFromMap_get, METH_VARARGS, NULL},
13624  { (char *)"ProSHADE_settings_shellSpacing_set", _wrap_ProSHADE_settings_shellSpacing_set, METH_VARARGS, NULL},
13625  { (char *)"ProSHADE_settings_shellSpacing_get", _wrap_ProSHADE_settings_shellSpacing_get, METH_VARARGS, NULL},
13626  { (char *)"ProSHADE_settings_manualShells_set", _wrap_ProSHADE_settings_manualShells_set, METH_VARARGS, NULL},
13627  { (char *)"ProSHADE_settings_manualShells_get", _wrap_ProSHADE_settings_manualShells_get, METH_VARARGS, NULL},
13628  { (char *)"ProSHADE_settings_usePhase_set", _wrap_ProSHADE_settings_usePhase_set, METH_VARARGS, NULL},
13629  { (char *)"ProSHADE_settings_usePhase_get", _wrap_ProSHADE_settings_usePhase_get, METH_VARARGS, NULL},
13630  { (char *)"ProSHADE_settings_useCOM_set", _wrap_ProSHADE_settings_useCOM_set, METH_VARARGS, NULL},
13631  { (char *)"ProSHADE_settings_useCOM_get", _wrap_ProSHADE_settings_useCOM_get, METH_VARARGS, NULL},
13632  { (char *)"ProSHADE_settings_firstLineCOM_set", _wrap_ProSHADE_settings_firstLineCOM_set, METH_VARARGS, NULL},
13633  { (char *)"ProSHADE_settings_firstLineCOM_get", _wrap_ProSHADE_settings_firstLineCOM_get, METH_VARARGS, NULL},
13634  { (char *)"ProSHADE_settings_extraSpace_set", _wrap_ProSHADE_settings_extraSpace_set, METH_VARARGS, NULL},
13635  { (char *)"ProSHADE_settings_extraSpace_get", _wrap_ProSHADE_settings_extraSpace_get, METH_VARARGS, NULL},
13636  { (char *)"ProSHADE_settings_alpha_set", _wrap_ProSHADE_settings_alpha_set, METH_VARARGS, NULL},
13637  { (char *)"ProSHADE_settings_alpha_get", _wrap_ProSHADE_settings_alpha_get, METH_VARARGS, NULL},
13638  { (char *)"ProSHADE_settings_mPower_set", _wrap_ProSHADE_settings_mPower_set, METH_VARARGS, NULL},
13639  { (char *)"ProSHADE_settings_mPower_get", _wrap_ProSHADE_settings_mPower_get, METH_VARARGS, NULL},
13640  { (char *)"ProSHADE_settings_ignoreLs_set", _wrap_ProSHADE_settings_ignoreLs_set, METH_VARARGS, NULL},
13641  { (char *)"ProSHADE_settings_ignoreLs_get", _wrap_ProSHADE_settings_ignoreLs_get, METH_VARARGS, NULL},
13642  { (char *)"ProSHADE_settings_structFiles_set", _wrap_ProSHADE_settings_structFiles_set, METH_VARARGS, NULL},
13643  { (char *)"ProSHADE_settings_structFiles_get", _wrap_ProSHADE_settings_structFiles_get, METH_VARARGS, NULL},
13644  { (char *)"ProSHADE_settings_peakHeightNoIQRs_set", _wrap_ProSHADE_settings_peakHeightNoIQRs_set, METH_VARARGS, NULL},
13645  { (char *)"ProSHADE_settings_peakHeightNoIQRs_get", _wrap_ProSHADE_settings_peakHeightNoIQRs_get, METH_VARARGS, NULL},
13646  { (char *)"ProSHADE_settings_peakDistanceForReal_set", _wrap_ProSHADE_settings_peakDistanceForReal_set, METH_VARARGS, NULL},
13647  { (char *)"ProSHADE_settings_peakDistanceForReal_get", _wrap_ProSHADE_settings_peakDistanceForReal_get, METH_VARARGS, NULL},
13648  { (char *)"ProSHADE_settings_peakSurroundingPoints_set", _wrap_ProSHADE_settings_peakSurroundingPoints_set, METH_VARARGS, NULL},
13649  { (char *)"ProSHADE_settings_peakSurroundingPoints_get", _wrap_ProSHADE_settings_peakSurroundingPoints_get, METH_VARARGS, NULL},
13650  { (char *)"ProSHADE_settings_aaErrorTolerance_set", _wrap_ProSHADE_settings_aaErrorTolerance_set, METH_VARARGS, NULL},
13651  { (char *)"ProSHADE_settings_aaErrorTolerance_get", _wrap_ProSHADE_settings_aaErrorTolerance_get, METH_VARARGS, NULL},
13652  { (char *)"ProSHADE_settings_symGapTolerance_set", _wrap_ProSHADE_settings_symGapTolerance_set, METH_VARARGS, NULL},
13653  { (char *)"ProSHADE_settings_symGapTolerance_get", _wrap_ProSHADE_settings_symGapTolerance_get, METH_VARARGS, NULL},
13654  { (char *)"ProSHADE_settings_energyLevelDist_set", _wrap_ProSHADE_settings_energyLevelDist_set, METH_VARARGS, NULL},
13655  { (char *)"ProSHADE_settings_energyLevelDist_get", _wrap_ProSHADE_settings_energyLevelDist_get, METH_VARARGS, NULL},
13656  { (char *)"ProSHADE_settings_traceSigmaDist_set", _wrap_ProSHADE_settings_traceSigmaDist_set, METH_VARARGS, NULL},
13657  { (char *)"ProSHADE_settings_traceSigmaDist_get", _wrap_ProSHADE_settings_traceSigmaDist_get, METH_VARARGS, NULL},
13658  { (char *)"ProSHADE_settings_fullRotFnDist_set", _wrap_ProSHADE_settings_fullRotFnDist_set, METH_VARARGS, NULL},
13659  { (char *)"ProSHADE_settings_fullRotFnDist_get", _wrap_ProSHADE_settings_fullRotFnDist_get, METH_VARARGS, NULL},
13660  { (char *)"ProSHADE_settings_enLevelsThreshold_set", _wrap_ProSHADE_settings_enLevelsThreshold_set, METH_VARARGS, NULL},
13661  { (char *)"ProSHADE_settings_enLevelsThreshold_get", _wrap_ProSHADE_settings_enLevelsThreshold_get, METH_VARARGS, NULL},
13662  { (char *)"ProSHADE_settings_trSigmaThreshold_set", _wrap_ProSHADE_settings_trSigmaThreshold_set, METH_VARARGS, NULL},
13663  { (char *)"ProSHADE_settings_trSigmaThreshold_get", _wrap_ProSHADE_settings_trSigmaThreshold_get, METH_VARARGS, NULL},
13664  { (char *)"ProSHADE_settings_taskToPerform_set", _wrap_ProSHADE_settings_taskToPerform_set, METH_VARARGS, NULL},
13665  { (char *)"ProSHADE_settings_taskToPerform_get", _wrap_ProSHADE_settings_taskToPerform_get, METH_VARARGS, NULL},
13666  { (char *)"ProSHADE_settings_clearMapFile_set", _wrap_ProSHADE_settings_clearMapFile_set, METH_VARARGS, NULL},
13667  { (char *)"ProSHADE_settings_clearMapFile_get", _wrap_ProSHADE_settings_clearMapFile_get, METH_VARARGS, NULL},
13668  { (char *)"ProSHADE_settings_useCubicMaps_set", _wrap_ProSHADE_settings_useCubicMaps_set, METH_VARARGS, NULL},
13669  { (char *)"ProSHADE_settings_useCubicMaps_get", _wrap_ProSHADE_settings_useCubicMaps_get, METH_VARARGS, NULL},
13670  { (char *)"ProSHADE_settings_clearMapData_set", _wrap_ProSHADE_settings_clearMapData_set, METH_VARARGS, NULL},
13671  { (char *)"ProSHADE_settings_clearMapData_get", _wrap_ProSHADE_settings_clearMapData_get, METH_VARARGS, NULL},
13672  { (char *)"ProSHADE_settings_mapFragBoxSize_set", _wrap_ProSHADE_settings_mapFragBoxSize_set, METH_VARARGS, NULL},
13673  { (char *)"ProSHADE_settings_mapFragBoxSize_get", _wrap_ProSHADE_settings_mapFragBoxSize_get, METH_VARARGS, NULL},
13674  { (char *)"ProSHADE_settings_mapFragName_set", _wrap_ProSHADE_settings_mapFragName_set, METH_VARARGS, NULL},
13675  { (char *)"ProSHADE_settings_mapFragName_get", _wrap_ProSHADE_settings_mapFragName_get, METH_VARARGS, NULL},
13676  { (char *)"ProSHADE_settings_mapFragBoxFraction_set", _wrap_ProSHADE_settings_mapFragBoxFraction_set, METH_VARARGS, NULL},
13677  { (char *)"ProSHADE_settings_mapFragBoxFraction_get", _wrap_ProSHADE_settings_mapFragBoxFraction_get, METH_VARARGS, NULL},
13678  { (char *)"ProSHADE_settings_databaseName_set", _wrap_ProSHADE_settings_databaseName_set, METH_VARARGS, NULL},
13679  { (char *)"ProSHADE_settings_databaseName_get", _wrap_ProSHADE_settings_databaseName_get, METH_VARARGS, NULL},
13680  { (char *)"ProSHADE_settings_volumeTolerance_set", _wrap_ProSHADE_settings_volumeTolerance_set, METH_VARARGS, NULL},
13681  { (char *)"ProSHADE_settings_volumeTolerance_get", _wrap_ProSHADE_settings_volumeTolerance_get, METH_VARARGS, NULL},
13682  { (char *)"ProSHADE_settings_symmetryFold_set", _wrap_ProSHADE_settings_symmetryFold_set, METH_VARARGS, NULL},
13683  { (char *)"ProSHADE_settings_symmetryFold_get", _wrap_ProSHADE_settings_symmetryFold_get, METH_VARARGS, NULL},
13684  { (char *)"ProSHADE_settings_symmetryType_set", _wrap_ProSHADE_settings_symmetryType_set, METH_VARARGS, NULL},
13685  { (char *)"ProSHADE_settings_symmetryType_get", _wrap_ProSHADE_settings_symmetryType_get, METH_VARARGS, NULL},
13686  { (char *)"ProSHADE_settings_rotAngle_set", _wrap_ProSHADE_settings_rotAngle_set, METH_VARARGS, NULL},
13687  { (char *)"ProSHADE_settings_rotAngle_get", _wrap_ProSHADE_settings_rotAngle_get, METH_VARARGS, NULL},
13688  { (char *)"ProSHADE_settings_rotXAxis_set", _wrap_ProSHADE_settings_rotXAxis_set, METH_VARARGS, NULL},
13689  { (char *)"ProSHADE_settings_rotXAxis_get", _wrap_ProSHADE_settings_rotXAxis_get, METH_VARARGS, NULL},
13690  { (char *)"ProSHADE_settings_rotYAxis_set", _wrap_ProSHADE_settings_rotYAxis_set, METH_VARARGS, NULL},
13691  { (char *)"ProSHADE_settings_rotYAxis_get", _wrap_ProSHADE_settings_rotYAxis_get, METH_VARARGS, NULL},
13692  { (char *)"ProSHADE_settings_rotZAxis_set", _wrap_ProSHADE_settings_rotZAxis_set, METH_VARARGS, NULL},
13693  { (char *)"ProSHADE_settings_rotZAxis_get", _wrap_ProSHADE_settings_rotZAxis_get, METH_VARARGS, NULL},
13694  { (char *)"ProSHADE_settings_rotChangeDefault_set", _wrap_ProSHADE_settings_rotChangeDefault_set, METH_VARARGS, NULL},
13695  { (char *)"ProSHADE_settings_rotChangeDefault_get", _wrap_ProSHADE_settings_rotChangeDefault_get, METH_VARARGS, NULL},
13696  { (char *)"ProSHADE_settings_xTranslation_set", _wrap_ProSHADE_settings_xTranslation_set, METH_VARARGS, NULL},
13697  { (char *)"ProSHADE_settings_xTranslation_get", _wrap_ProSHADE_settings_xTranslation_get, METH_VARARGS, NULL},
13698  { (char *)"ProSHADE_settings_yTranslation_set", _wrap_ProSHADE_settings_yTranslation_set, METH_VARARGS, NULL},
13699  { (char *)"ProSHADE_settings_yTranslation_get", _wrap_ProSHADE_settings_yTranslation_get, METH_VARARGS, NULL},
13700  { (char *)"ProSHADE_settings_zTranslation_set", _wrap_ProSHADE_settings_zTranslation_set, METH_VARARGS, NULL},
13701  { (char *)"ProSHADE_settings_zTranslation_get", _wrap_ProSHADE_settings_zTranslation_get, METH_VARARGS, NULL},
13702  { (char *)"ProSHADE_settings_overlayDefaults_set", _wrap_ProSHADE_settings_overlayDefaults_set, METH_VARARGS, NULL},
13703  { (char *)"ProSHADE_settings_overlayDefaults_get", _wrap_ProSHADE_settings_overlayDefaults_get, METH_VARARGS, NULL},
13704  { (char *)"ProSHADE_settings_axisOrder_set", _wrap_ProSHADE_settings_axisOrder_set, METH_VARARGS, NULL},
13705  { (char *)"ProSHADE_settings_axisOrder_get", _wrap_ProSHADE_settings_axisOrder_get, METH_VARARGS, NULL},
13706  { (char *)"ProSHADE_settings_verbose_set", _wrap_ProSHADE_settings_verbose_set, METH_VARARGS, NULL},
13707  { (char *)"ProSHADE_settings_verbose_get", _wrap_ProSHADE_settings_verbose_get, METH_VARARGS, NULL},
13708  { (char *)"new_ProSHADE_settings", _wrap_new_ProSHADE_settings, METH_VARARGS, NULL},
13709  { (char *)"ProSHADE_settings_printSettings", _wrap_ProSHADE_settings_printSettings, METH_VARARGS, NULL},
13710  { (char *)"ProSHADE_settings_getCommandLineParams", _wrap_ProSHADE_settings_getCommandLineParams, METH_VARARGS, NULL},
13711  { (char *)"ProSHADE_settings_ignoreLsAddValuePy", _wrap_ProSHADE_settings_ignoreLsAddValuePy, METH_VARARGS, NULL},
13712  { (char *)"delete_ProSHADE_settings", _wrap_delete_ProSHADE_settings, METH_VARARGS, NULL},
13713  { (char *)"ProSHADE_settings_swigregister", ProSHADE_settings_swigregister, METH_VARARGS, NULL},
13714  { (char *)"new_ProSHADE", _wrap_new_ProSHADE, METH_VARARGS, NULL},
13715  { (char *)"delete_ProSHADE", _wrap_delete_ProSHADE, METH_VARARGS, NULL},
13716  { (char *)"ProSHADE_getCrossCorrDists", _wrap_ProSHADE_getCrossCorrDists, METH_VARARGS, NULL},
13717  { (char *)"ProSHADE_getTraceSigmaDists", _wrap_ProSHADE_getTraceSigmaDists, METH_VARARGS, NULL},
13718  { (char *)"ProSHADE_getRotFunctionDists", _wrap_ProSHADE_getRotFunctionDists, METH_VARARGS, NULL},
13719  { (char *)"ProSHADE_getCyclicSymmetries", _wrap_ProSHADE_getCyclicSymmetries, METH_VARARGS, NULL},
13720  { (char *)"ProSHADE_getDihedralSymmetries", _wrap_ProSHADE_getDihedralSymmetries, METH_VARARGS, NULL},
13721  { (char *)"ProSHADE_getTetrahedralSymmetries", _wrap_ProSHADE_getTetrahedralSymmetries, METH_VARARGS, NULL},
13722  { (char *)"ProSHADE_getOctahedralSymmetries", _wrap_ProSHADE_getOctahedralSymmetries, METH_VARARGS, NULL},
13723  { (char *)"ProSHADE_getIcosahedralSymmetries", _wrap_ProSHADE_getIcosahedralSymmetries, METH_VARARGS, NULL},
13724  { (char *)"ProSHADE_getSymmetryElements", _wrap_ProSHADE_getSymmetryElements, METH_VARARGS, NULL},
13725  { (char *)"ProSHADE_getSpecificSymmetryElements", _wrap_ProSHADE_getSpecificSymmetryElements, METH_VARARGS, NULL},
13726  { (char *)"ProSHADE_getCyclicSymmetriesPy", _wrap_ProSHADE_getCyclicSymmetriesPy, METH_VARARGS, NULL},
13727  { (char *)"ProSHADE_getDihedralSymmetriesPy", _wrap_ProSHADE_getDihedralSymmetriesPy, METH_VARARGS, NULL},
13728  { (char *)"ProSHADE_getTetrahedralSymmetriesPy", _wrap_ProSHADE_getTetrahedralSymmetriesPy, METH_VARARGS, NULL},
13729  { (char *)"ProSHADE_getOctahedralSymmetriesPy", _wrap_ProSHADE_getOctahedralSymmetriesPy, METH_VARARGS, NULL},
13730  { (char *)"ProSHADE_getIcosahedralSymmetriesPy", _wrap_ProSHADE_getIcosahedralSymmetriesPy, METH_VARARGS, NULL},
13731  { (char *)"ProSHADE_getSymmetryElementsPy", _wrap_ProSHADE_getSymmetryElementsPy, METH_VARARGS, NULL},
13732  { (char *)"ProSHADE_getSpecificSymmetryElementsPy", _wrap_ProSHADE_getSpecificSymmetryElementsPy, METH_VARARGS, NULL},
13733  { (char *)"ProSHADE_getProSHADEVersion", _wrap_ProSHADE_getProSHADEVersion, METH_VARARGS, NULL},
13734  { (char *)"ProSHADE_swigregister", ProSHADE_swigregister, METH_VARARGS, NULL},
13735  { NULL, NULL, 0, NULL }
13736 };
13737 
13738 
13739 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
13740 
13741 static swig_type_info _swigt__p_ProSHADE__ProSHADE = {"_p_ProSHADE__ProSHADE", "ProSHADE::ProSHADE *", 0, 0, (void*)0, 0};
13742 static swig_type_info _swigt__p_ProSHADE__ProSHADE_settings = {"_p_ProSHADE__ProSHADE_settings", "ProSHADE::ProSHADE_settings *", 0, 0, (void*)0, 0};
13743 static swig_type_info _swigt__p_a_2__double = {"_p_a_2__double", "double (*)[2]|fftw_complex *", 0, 0, (void*)0, 0};
13744 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
13745 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
13746 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
13747 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
13748 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
13749 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
13750 static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
13751 static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
13752 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
13753 static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
13754 static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *", 0, 0, (void*)0, 0};
13755 static swig_type_info _swigt__p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t = {"_p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t", "std::vector< std::array< double,5 >,std::allocator< std::array< double,5 > > > *", 0, 0, (void*)0, 0};
13756 static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
13757 static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t", "std::vector< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > >,std::allocator< std::vector< std::array< double,6 >,std::allocator< std::array< double,6 > > > > > *", 0, 0, (void*)0, 0};
13758 static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
13759 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
13760 
13761 static swig_type_info *swig_type_initial[] = {
13762  &_swigt__p_ProSHADE__ProSHADE,
13763  &_swigt__p_ProSHADE__ProSHADE_settings,
13764  &_swigt__p_a_2__double,
13765  &_swigt__p_allocator_type,
13766  &_swigt__p_char,
13767  &_swigt__p_difference_type,
13768  &_swigt__p_p_PyObject,
13769  &_swigt__p_p_char,
13770  &_swigt__p_size_type,
13771  &_swigt__p_std__allocatorT_double_t,
13772  &_swigt__p_std__allocatorT_std__string_t,
13773  &_swigt__p_std__invalid_argument,
13774  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
13775  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
13776  &_swigt__p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t,
13777  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
13778  &_swigt__p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t,
13779  &_swigt__p_swig__SwigPyIterator,
13780  &_swigt__p_value_type,
13781 };
13782 
13783 static swig_cast_info _swigc__p_ProSHADE__ProSHADE[] = { {&_swigt__p_ProSHADE__ProSHADE, 0, 0, 0},{0, 0, 0, 0}};
13784 static swig_cast_info _swigc__p_ProSHADE__ProSHADE_settings[] = { {&_swigt__p_ProSHADE__ProSHADE_settings, 0, 0, 0},{0, 0, 0, 0}};
13785 static swig_cast_info _swigc__p_a_2__double[] = { {&_swigt__p_a_2__double, 0, 0, 0},{0, 0, 0, 0}};
13786 static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
13787 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
13788 static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
13789 static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
13790 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
13791 static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
13792 static swig_cast_info _swigc__p_std__allocatorT_double_t[] = { {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
13793 static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
13794 static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
13795 static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
13796 static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
13797 static swig_cast_info _swigc__p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t[] = { {&_swigt__p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
13798 static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
13799 static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
13800 static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
13801 static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
13802 
13803 static swig_cast_info *swig_cast_initial[] = {
13804  _swigc__p_ProSHADE__ProSHADE,
13805  _swigc__p_ProSHADE__ProSHADE_settings,
13806  _swigc__p_a_2__double,
13807  _swigc__p_allocator_type,
13808  _swigc__p_char,
13809  _swigc__p_difference_type,
13810  _swigc__p_p_PyObject,
13811  _swigc__p_p_char,
13812  _swigc__p_size_type,
13813  _swigc__p_std__allocatorT_double_t,
13814  _swigc__p_std__allocatorT_std__string_t,
13815  _swigc__p_std__invalid_argument,
13816  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
13817  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
13818  _swigc__p_std__vectorT_std__arrayT_double_5_t_std__allocatorT_std__arrayT_double_5_t_t_t,
13819  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
13820  _swigc__p_std__vectorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_std__allocatorT_std__vectorT_std__arrayT_double_6_t_std__allocatorT_std__arrayT_double_6_t_t_t_t_t,
13821  _swigc__p_swig__SwigPyIterator,
13822  _swigc__p_value_type,
13823 };
13824 
13825 
13826 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
13827 
13828 static swig_const_info swig_const_table[] = {
13829 {0, 0, 0, 0.0, 0, 0}};
13830 
13831 #ifdef __cplusplus
13832 }
13833 #endif
13834 /* -----------------------------------------------------------------------------
13835  * Type initialization:
13836  * This problem is tough by the requirement that no dynamic
13837  * memory is used. Also, since swig_type_info structures store pointers to
13838  * swig_cast_info structures and swig_cast_info structures store pointers back
13839  * to swig_type_info structures, we need some lookup code at initialization.
13840  * The idea is that swig generates all the structures that are needed.
13841  * The runtime then collects these partially filled structures.
13842  * The SWIG_InitializeModule function takes these initial arrays out of
13843  * swig_module, and does all the lookup, filling in the swig_module.types
13844  * array with the correct data and linking the correct swig_cast_info
13845  * structures together.
13846  *
13847  * The generated swig_type_info structures are assigned statically to an initial
13848  * array. We just loop through that array, and handle each type individually.
13849  * First we lookup if this type has been already loaded, and if so, use the
13850  * loaded structure instead of the generated one. Then we have to fill in the
13851  * cast linked list. The cast data is initially stored in something like a
13852  * two-dimensional array. Each row corresponds to a type (there are the same
13853  * number of rows as there are in the swig_type_initial array). Each entry in
13854  * a column is one of the swig_cast_info structures for that type.
13855  * The cast_initial array is actually an array of arrays, because each row has
13856  * a variable number of columns. So to actually build the cast linked list,
13857  * we find the array of casts associated with the type, and loop through it
13858  * adding the casts to the list. The one last trick we need to do is making
13859  * sure the type pointer in the swig_cast_info struct is correct.
13860  *
13861  * First off, we lookup the cast->type name to see if it is already loaded.
13862  * There are three cases to handle:
13863  * 1) If the cast->type has already been loaded AND the type we are adding
13864  * casting info to has not been loaded (it is in this module), THEN we
13865  * replace the cast->type pointer with the type pointer that has already
13866  * been loaded.
13867  * 2) If BOTH types (the one we are adding casting info to, and the
13868  * cast->type) are loaded, THEN the cast info has already been loaded by
13869  * the previous module so we just ignore it.
13870  * 3) Finally, if cast->type has not already been loaded, then we add that
13871  * swig_cast_info to the linked list (because the cast->type) pointer will
13872  * be correct.
13873  * ----------------------------------------------------------------------------- */
13874 
13875 #ifdef __cplusplus
13876 extern "C" {
13877 #if 0
13878 } /* c-mode */
13879 #endif
13880 #endif
13881 
13882 #if 0
13883 #define SWIGRUNTIME_DEBUG
13884 #endif
13885 
13886 
13887 SWIGRUNTIME void
13888 SWIG_InitializeModule(void *clientdata) {
13889  size_t i;
13890  swig_module_info *module_head, *iter;
13891  int init;
13892 
13893  /* check to see if the circular list has been setup, if not, set it up */
13894  if (swig_module.next==0) {
13895  /* Initialize the swig_module */
13896  swig_module.type_initial = swig_type_initial;
13897  swig_module.cast_initial = swig_cast_initial;
13898  swig_module.next = &swig_module;
13899  init = 1;
13900  } else {
13901  init = 0;
13902  }
13903 
13904  /* Try and load any already created modules */
13905  module_head = SWIG_GetModule(clientdata);
13906  if (!module_head) {
13907  /* This is the first module loaded for this interpreter */
13908  /* so set the swig module into the interpreter */
13909  SWIG_SetModule(clientdata, &swig_module);
13910  } else {
13911  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
13912  iter=module_head;
13913  do {
13914  if (iter==&swig_module) {
13915  /* Our module is already in the list, so there's nothing more to do. */
13916  return;
13917  }
13918  iter=iter->next;
13919  } while (iter!= module_head);
13920 
13921  /* otherwise we must add our module into the list */
13922  swig_module.next = module_head->next;
13923  module_head->next = &swig_module;
13924  }
13925 
13926  /* When multiple interpreters are used, a module could have already been initialized in
13927  a different interpreter, but not yet have a pointer in this interpreter.
13928  In this case, we do not want to continue adding types... everything should be
13929  set up already */
13930  if (init == 0) return;
13931 
13932  /* Now work on filling in swig_module.types */
13933 #ifdef SWIGRUNTIME_DEBUG
13934  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
13935 #endif
13936  for (i = 0; i < swig_module.size; ++i) {
13937  swig_type_info *type = 0;
13938  swig_type_info *ret;
13939  swig_cast_info *cast;
13940 
13941 #ifdef SWIGRUNTIME_DEBUG
13942  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
13943 #endif
13944 
13945  /* if there is another module already loaded */
13946  if (swig_module.next != &swig_module) {
13947  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
13948  }
13949  if (type) {
13950  /* Overwrite clientdata field */
13951 #ifdef SWIGRUNTIME_DEBUG
13952  printf("SWIG_InitializeModule: found type %s\n", type->name);
13953 #endif
13954  if (swig_module.type_initial[i]->clientdata) {
13955  type->clientdata = swig_module.type_initial[i]->clientdata;
13956 #ifdef SWIGRUNTIME_DEBUG
13957  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
13958 #endif
13959  }
13960  } else {
13961  type = swig_module.type_initial[i];
13962  }
13963 
13964  /* Insert casting types */
13965  cast = swig_module.cast_initial[i];
13966  while (cast->type) {
13967  /* Don't need to add information already in the list */
13968  ret = 0;
13969 #ifdef SWIGRUNTIME_DEBUG
13970  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
13971 #endif
13972  if (swig_module.next != &swig_module) {
13973  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
13974 #ifdef SWIGRUNTIME_DEBUG
13975  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
13976 #endif
13977  }
13978  if (ret) {
13979  if (type == swig_module.type_initial[i]) {
13980 #ifdef SWIGRUNTIME_DEBUG
13981  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
13982 #endif
13983  cast->type = ret;
13984  ret = 0;
13985  } else {
13986  /* Check for casting already in the list */
13987  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
13988 #ifdef SWIGRUNTIME_DEBUG
13989  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
13990 #endif
13991  if (!ocast) ret = 0;
13992  }
13993  }
13994 
13995  if (!ret) {
13996 #ifdef SWIGRUNTIME_DEBUG
13997  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
13998 #endif
13999  if (type->cast) {
14000  type->cast->prev = cast;
14001  cast->next = type->cast;
14002  }
14003  type->cast = cast;
14004  }
14005  cast++;
14006  }
14007  /* Set entry in modules->types array equal to the type */
14008  swig_module.types[i] = type;
14009  }
14010  swig_module.types[i] = 0;
14011 
14012 #ifdef SWIGRUNTIME_DEBUG
14013  printf("**** SWIG_InitializeModule: Cast List ******\n");
14014  for (i = 0; i < swig_module.size; ++i) {
14015  int j = 0;
14016  swig_cast_info *cast = swig_module.cast_initial[i];
14017  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
14018  while (cast->type) {
14019  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
14020  cast++;
14021  ++j;
14022  }
14023  printf("---- Total casts: %d\n",j);
14024  }
14025  printf("**** SWIG_InitializeModule: Cast List ******\n");
14026 #endif
14027 }
14028 
14029 /* This function will propagate the clientdata field of type to
14030 * any new swig_type_info structures that have been added into the list
14031 * of equivalent types. It is like calling
14032 * SWIG_TypeClientData(type, clientdata) a second time.
14033 */
14034 SWIGRUNTIME void
14035 SWIG_PropagateClientData(void) {
14036  size_t i;
14037  swig_cast_info *equiv;
14038  static int init_run = 0;
14039 
14040  if (init_run) return;
14041  init_run = 1;
14042 
14043  for (i = 0; i < swig_module.size; i++) {
14044  if (swig_module.types[i]->clientdata) {
14045  equiv = swig_module.types[i]->cast;
14046  while (equiv) {
14047  if (!equiv->converter) {
14048  if (equiv->type && !equiv->type->clientdata)
14049  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
14050  }
14051  equiv = equiv->next;
14052  }
14053  }
14054  }
14055 }
14056 
14057 #ifdef __cplusplus
14058 #if 0
14059 {
14060  /* c-mode */
14061 #endif
14062 }
14063 #endif
14064 
14065 
14066 
14067 #ifdef __cplusplus
14068 extern "C" {
14069 #endif
14070 
14071  /* Python-specific SWIG API */
14072 #define SWIG_newvarlink() SWIG_Python_newvarlink()
14073 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
14074 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
14075 
14076  /* -----------------------------------------------------------------------------
14077  * global variable support code.
14078  * ----------------------------------------------------------------------------- */
14079 
14080  typedef struct swig_globalvar {
14081  char *name; /* Name of global variable */
14082  PyObject *(*get_attr)(void); /* Return the current value */
14083  int (*set_attr)(PyObject *); /* Set the value */
14084  struct swig_globalvar *next;
14085  } swig_globalvar;
14086 
14087  typedef struct swig_varlinkobject {
14088  PyObject_HEAD
14089  swig_globalvar *vars;
14091 
14092  SWIGINTERN PyObject *
14093  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
14094 #if PY_VERSION_HEX >= 0x03000000
14095  return PyUnicode_InternFromString("<Swig global variables>");
14096 #else
14097  return PyString_FromString("<Swig global variables>");
14098 #endif
14099  }
14100 
14101  SWIGINTERN PyObject *
14102  swig_varlink_str(swig_varlinkobject *v) {
14103 #if PY_VERSION_HEX >= 0x03000000
14104  PyObject *str = PyUnicode_InternFromString("(");
14105  PyObject *tail;
14106  PyObject *joined;
14107  swig_globalvar *var;
14108  for (var = v->vars; var; var=var->next) {
14109  tail = PyUnicode_FromString(var->name);
14110  joined = PyUnicode_Concat(str, tail);
14111  Py_DecRef(str);
14112  Py_DecRef(tail);
14113  str = joined;
14114  if (var->next) {
14115  tail = PyUnicode_InternFromString(", ");
14116  joined = PyUnicode_Concat(str, tail);
14117  Py_DecRef(str);
14118  Py_DecRef(tail);
14119  str = joined;
14120  }
14121  }
14122  tail = PyUnicode_InternFromString(")");
14123  joined = PyUnicode_Concat(str, tail);
14124  Py_DecRef(str);
14125  Py_DecRef(tail);
14126  str = joined;
14127 #else
14128  PyObject *str = PyString_FromString("(");
14129  swig_globalvar *var;
14130  for (var = v->vars; var; var=var->next) {
14131  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
14132  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
14133  }
14134  PyString_ConcatAndDel(&str,PyString_FromString(")"));
14135 #endif
14136  return str;
14137  }
14138 
14139  SWIGINTERN int
14140  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
14141  PyObject *str = swig_varlink_str(v);
14142  const char *tmp = SWIG_Python_str_AsChar(str);
14143  fprintf(fp,"Swig global variables ");
14144  fprintf(fp,"%s\n", tmp ? tmp : "Invalid global variable");
14145  SWIG_Python_str_DelForPy3(tmp);
14146  Py_DECREF(str);
14147  return 0;
14148  }
14149 
14150  SWIGINTERN void
14151  swig_varlink_dealloc(swig_varlinkobject *v) {
14152  swig_globalvar *var = v->vars;
14153  while (var) {
14154  swig_globalvar *n = var->next;
14155  free(var->name);
14156  free(var);
14157  var = n;
14158  }
14159  }
14160 
14161  SWIGINTERN PyObject *
14162  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
14163  PyObject *res = NULL;
14164  swig_globalvar *var = v->vars;
14165  while (var) {
14166  if (strcmp(var->name,n) == 0) {
14167  res = (*var->get_attr)();
14168  break;
14169  }
14170  var = var->next;
14171  }
14172  if (res == NULL && !PyErr_Occurred()) {
14173  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
14174  }
14175  return res;
14176  }
14177 
14178  SWIGINTERN int
14179  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
14180  int res = 1;
14181  swig_globalvar *var = v->vars;
14182  while (var) {
14183  if (strcmp(var->name,n) == 0) {
14184  res = (*var->set_attr)(p);
14185  break;
14186  }
14187  var = var->next;
14188  }
14189  if (res == 1 && !PyErr_Occurred()) {
14190  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
14191  }
14192  return res;
14193  }
14194 
14195  SWIGINTERN PyTypeObject*
14196  swig_varlink_type(void) {
14197  static char varlink__doc__[] = "Swig var link object";
14198  static PyTypeObject varlink_type;
14199  static int type_init = 0;
14200  if (!type_init) {
14201  const PyTypeObject tmp = {
14202 #if PY_VERSION_HEX >= 0x03000000
14203  PyVarObject_HEAD_INIT(NULL, 0)
14204 #else
14205  PyObject_HEAD_INIT(NULL)
14206  0, /* ob_size */
14207 #endif
14208  (char *)"swigvarlink", /* tp_name */
14209  sizeof(swig_varlinkobject), /* tp_basicsize */
14210  0, /* tp_itemsize */
14211  (destructor) swig_varlink_dealloc, /* tp_dealloc */
14212  (printfunc) swig_varlink_print, /* tp_print */
14213  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
14214  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
14215  0, /* tp_compare */
14216  (reprfunc) swig_varlink_repr, /* tp_repr */
14217  0, /* tp_as_number */
14218  0, /* tp_as_sequence */
14219  0, /* tp_as_mapping */
14220  0, /* tp_hash */
14221  0, /* tp_call */
14222  (reprfunc) swig_varlink_str, /* tp_str */
14223  0, /* tp_getattro */
14224  0, /* tp_setattro */
14225  0, /* tp_as_buffer */
14226  0, /* tp_flags */
14227  varlink__doc__, /* tp_doc */
14228  0, /* tp_traverse */
14229  0, /* tp_clear */
14230  0, /* tp_richcompare */
14231  0, /* tp_weaklistoffset */
14232 #if PY_VERSION_HEX >= 0x02020000
14233  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
14234 #endif
14235 #if PY_VERSION_HEX >= 0x02030000
14236  0, /* tp_del */
14237 #endif
14238 #if PY_VERSION_HEX >= 0x02060000
14239  0, /* tp_version_tag */
14240 #endif
14241 #if PY_VERSION_HEX >= 0x03040000
14242  0, /* tp_finalize */
14243 #endif
14244 #ifdef COUNT_ALLOCS
14245  0, /* tp_allocs */
14246  0, /* tp_frees */
14247  0, /* tp_maxalloc */
14248 #if PY_VERSION_HEX >= 0x02050000
14249  0, /* tp_prev */
14250 #endif
14251  0 /* tp_next */
14252 #endif
14253  };
14254  varlink_type = tmp;
14255  type_init = 1;
14256 #if PY_VERSION_HEX < 0x02020000
14257  varlink_type.ob_type = &PyType_Type;
14258 #else
14259  if (PyType_Ready(&varlink_type) < 0)
14260  return NULL;
14261 #endif
14262  }
14263  return &varlink_type;
14264  }
14265 
14266  /* Create a variable linking object for use later */
14267  SWIGINTERN PyObject *
14268  SWIG_Python_newvarlink(void) {
14269  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
14270  if (result) {
14271  result->vars = 0;
14272  }
14273  return ((PyObject*) result);
14274  }
14275 
14276  SWIGINTERN void
14277  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
14279  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
14280  if (gv) {
14281  size_t size = strlen(name)+1;
14282  gv->name = (char *)malloc(size);
14283  if (gv->name) {
14284  strncpy(gv->name,name,size);
14285  gv->get_attr = get_attr;
14286  gv->set_attr = set_attr;
14287  gv->next = v->vars;
14288  }
14289  }
14290  v->vars = gv;
14291  }
14292 
14293  SWIGINTERN PyObject *
14294  SWIG_globals(void) {
14295  static PyObject *_SWIG_globals = 0;
14296  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
14297  return _SWIG_globals;
14298  }
14299 
14300  /* -----------------------------------------------------------------------------
14301  * constants/methods manipulation
14302  * ----------------------------------------------------------------------------- */
14303 
14304  /* Install Constants */
14305  SWIGINTERN void
14306  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
14307  PyObject *obj = 0;
14308  size_t i;
14309  for (i = 0; constants[i].type; ++i) {
14310  switch(constants[i].type) {
14311  case SWIG_PY_POINTER:
14312  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
14313  break;
14314  case SWIG_PY_BINARY:
14315  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
14316  break;
14317  default:
14318  obj = 0;
14319  break;
14320  }
14321  if (obj) {
14322  PyDict_SetItemString(d, constants[i].name, obj);
14323  Py_DECREF(obj);
14324  }
14325  }
14326  }
14327 
14328  /* -----------------------------------------------------------------------------*/
14329  /* Fix SwigMethods to carry the callback ptrs when needed */
14330  /* -----------------------------------------------------------------------------*/
14331 
14332  SWIGINTERN void
14333  SWIG_Python_FixMethods(PyMethodDef *methods,
14334  swig_const_info *const_table,
14335  swig_type_info **types,
14336  swig_type_info **types_initial) {
14337  size_t i;
14338  for (i = 0; methods[i].ml_name; ++i) {
14339  const char *c = methods[i].ml_doc;
14340  if (!c) continue;
14341  c = strstr(c, "swig_ptr: ");
14342  if (c) {
14343  int j;
14344  swig_const_info *ci = 0;
14345  const char *name = c + 10;
14346  for (j = 0; const_table[j].type; ++j) {
14347  if (strncmp(const_table[j].name, name,
14348  strlen(const_table[j].name)) == 0) {
14349  ci = &(const_table[j]);
14350  break;
14351  }
14352  }
14353  if (ci) {
14354  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
14355  if (ptr) {
14356  size_t shift = (ci->ptype) - types;
14357  swig_type_info *ty = types_initial[shift];
14358  size_t ldoc = (c - methods[i].ml_doc);
14359  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
14360  char *ndoc = (char*)malloc(ldoc + lptr + 10);
14361  if (ndoc) {
14362  char *buff = ndoc;
14363  memcpy(buff, methods[i].ml_doc, ldoc);
14364  buff += ldoc;
14365  memcpy(buff, "swig_ptr: ", 10);
14366  buff += 10;
14367  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
14368  methods[i].ml_doc = ndoc;
14369  }
14370  }
14371  }
14372  }
14373  }
14374  }
14375 
14376 #ifdef __cplusplus
14377 }
14378 #endif
14379 
14380 /* -----------------------------------------------------------------------------*
14381  * Partial Init method
14382  * -----------------------------------------------------------------------------*/
14383 
14384 #ifdef __cplusplus
14385 extern "C"
14386 #endif
14387 
14388 SWIGEXPORT
14389 #if PY_VERSION_HEX >= 0x03000000
14390 PyObject*
14391 #else
14392 void
14393 #endif
14394 SWIG_init(void) {
14395  PyObject *m, *d, *md;
14396 #if PY_VERSION_HEX >= 0x03000000
14397  static struct PyModuleDef SWIG_module = {
14398 # if PY_VERSION_HEX >= 0x03020000
14399  PyModuleDef_HEAD_INIT,
14400 # else
14401  {
14402  PyObject_HEAD_INIT(NULL)
14403  NULL, /* m_init */
14404  0, /* m_index */
14405  NULL, /* m_copy */
14406  },
14407 # endif
14408  (char *) SWIG_name,
14409  NULL,
14410  -1,
14411  SwigMethods,
14412  NULL,
14413  NULL,
14414  NULL,
14415  NULL
14416  };
14417 #endif
14418 
14419 #if defined(SWIGPYTHON_BUILTIN)
14420  static SwigPyClientData SwigPyObject_clientdata = {
14421  0, 0, 0, 0, 0, 0, 0
14422  };
14423  static PyGetSetDef this_getset_def = {
14424  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
14425  };
14426  static SwigPyGetSet thisown_getset_closure = {
14427  (PyCFunction) SwigPyObject_own,
14428  (PyCFunction) SwigPyObject_own
14429  };
14430  static PyGetSetDef thisown_getset_def = {
14431  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
14432  };
14433  PyTypeObject *builtin_pytype;
14434  int builtin_base_count;
14435  swig_type_info *builtin_basetype;
14436  PyObject *tuple;
14437  PyGetSetDescrObject *static_getset;
14438  PyTypeObject *metatype;
14439  PyTypeObject *swigpyobject;
14440  SwigPyClientData *cd;
14441  PyObject *public_interface, *public_symbol;
14442  PyObject *this_descr;
14443  PyObject *thisown_descr;
14444  PyObject *self = 0;
14445  int i;
14446 
14447  (void)builtin_pytype;
14448  (void)builtin_base_count;
14449  (void)builtin_basetype;
14450  (void)tuple;
14451  (void)static_getset;
14452  (void)self;
14453 
14454  /* Metaclass is used to implement static member variables */
14455  metatype = SwigPyObjectType();
14456  assert(metatype);
14457 #endif
14458 
14459  /* Fix SwigMethods to carry the callback ptrs when needed */
14460  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
14461 
14462 #if PY_VERSION_HEX >= 0x03000000
14463  m = PyModule_Create(&SWIG_module);
14464 #else
14465  m = Py_InitModule((char *) SWIG_name, SwigMethods);
14466 #endif
14467 
14468  md = d = PyModule_GetDict(m);
14469  (void)md;
14470 
14471  SWIG_InitializeModule(0);
14472 
14473 #ifdef SWIGPYTHON_BUILTIN
14474  swigpyobject = SwigPyObject_TypeOnce();
14475 
14476  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
14477  assert(SwigPyObject_stype);
14478  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
14479  if (!cd) {
14480  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
14481  SwigPyObject_clientdata.pytype = swigpyobject;
14482  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
14483  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
14484 # if PY_VERSION_HEX >= 0x03000000
14485  return NULL;
14486 # else
14487  return;
14488 # endif
14489  }
14490 
14491  /* All objects have a 'this' attribute */
14492  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
14493  (void)this_descr;
14494 
14495  /* All objects have a 'thisown' attribute */
14496  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
14497  (void)thisown_descr;
14498 
14499  public_interface = PyList_New(0);
14500  public_symbol = 0;
14501  (void)public_symbol;
14502 
14503  PyDict_SetItemString(md, "__all__", public_interface);
14504  Py_DECREF(public_interface);
14505  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
14506  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
14507  for (i = 0; swig_const_table[i].name != 0; ++i)
14508  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
14509 #endif
14510 
14511  SWIG_InstallConstants(d,swig_const_table);
14512 
14513  SWIG_Python_SetConstant(d, "SHARED_PTR_DISOWN",SWIG_From_int(static_cast< int >(0)));
14514  SWIG_Python_SetConstant(d, "Symmetry",SWIG_From_int(static_cast< int >(ProSHADE::Symmetry)));
14515  SWIG_Python_SetConstant(d, "Distances",SWIG_From_int(static_cast< int >(ProSHADE::Distances)));
14516  SWIG_Python_SetConstant(d, "DistancesFrag",SWIG_From_int(static_cast< int >(ProSHADE::DistancesFrag)));
14517  SWIG_Python_SetConstant(d, "Features",SWIG_From_int(static_cast< int >(ProSHADE::Features)));
14518  SWIG_Python_SetConstant(d, "BuildDB",SWIG_From_int(static_cast< int >(ProSHADE::BuildDB)));
14519  SWIG_Python_SetConstant(d, "HalfMaps",SWIG_From_int(static_cast< int >(ProSHADE::HalfMaps)));
14520  SWIG_Python_SetConstant(d, "RotateMap",SWIG_From_int(static_cast< int >(ProSHADE::RotateMap)));
14521  SWIG_Python_SetConstant(d, "OverlayMap",SWIG_From_int(static_cast< int >(ProSHADE::OverlayMap)));
14522 #if PY_VERSION_HEX >= 0x03000000
14523  return m;
14524 #else
14525  return;
14526 #endif
14527 }
14528 
This class stores all the settings and is passed to the executive classes instead of multitude of par...
Definition: ProSHADE.h:74