1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
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 * ----------------------------------------------------------------------------- */
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
15 template<class T> class SwigValueWrapper {
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
41 # define SWIGTEMPLATEDISAMBIGUATOR
44 # define SWIGTEMPLATEDISAMBIGUATOR
48 /* inline attribute */
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
66 # define SWIGUNUSED __attribute__ ((__unused__))
72 #ifndef SWIGUNUSEDPARM
74 # define SWIGUNUSEDPARM(p)
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
80 /* internal SWIG method */
82 # define SWIGINTERN static SWIGUNUSED
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
102 # define SWIGEXPORT __declspec(dllexport)
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
113 /* calling conventions for Windows */
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
124 # define _CRT_SECURE_NO_DEPRECATE
128 /* Python.h has to appear first */
131 /* -----------------------------------------------------------------------------
134 * This file contains generic CAPI SWIG runtime support for pointer
136 * ----------------------------------------------------------------------------- */
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "3"
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
148 # define SWIG_TYPE_TABLE_NAME
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
161 # define SWIGRUNTIME SWIGINTERN
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
181 Flags/methods for returning states.
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
187 Use the following macros/flags to set or process the returning
190 In old swig versions, you usually write code as:
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
198 Now you can be more explicit as:
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
207 that seems to be the same, but now you can also do
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
213 if (SWIG_IsNewObj(res) {
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
227 int SWIG_ConvertPtr(obj, ptr,...) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
233 *ptr = <ptr to old object>;
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
256 just use the SWIG_AddCast()/SWIG_CheckState()
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
363 return (l1 - f1) - (l2 - f2);
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
373 const char* te = tb + strlen(tb);
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
390 SWIG_TypeCompare(const char *nb, const char *tb) {
392 const char* te = tb + strlen(tb);
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
408 swig_cast_info *iter = ty->cast; \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
418 if (ty->cast) ty->cast->prev = iter; \
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
442 Cast a pointer up an inheritance hierarchy
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
450 Dynamic pointer casting. Down an inheritance hierarchy
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
464 Return the name associated with this type
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
494 Set the clientdata field for a type
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
530 swig_module_info *iter = start;
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
540 register int compare = strcmp(name, iname);
542 return iter->types[i];
543 } else if (compare < 0) {
549 } else if (compare > 0) {
553 break; /* should never happen */
558 } while (iter != end);
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
590 } while (iter != end);
593 /* neither found a match */
598 Pack binary data into a string
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
614 Unpack binary data from a string
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
630 if ((d >= '0') && (d <= '9'))
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
642 Pack 'void *' into a string buffer.
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
658 if (strcmp(c,"NULL") == 0) {
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
674 r = SWIG_PackData(r,ptr,sz);
676 strncpy(r,name,lname+1);
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
686 if (strcmp(c,"NULL") == 0) {
693 return SWIG_UnpackData(++c,ptr,sz);
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
718 /* Add PyOS_snprintf for old Pythons */
719 #if PY_VERSION_HEX < 0x02020000
720 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
721 # define PyOS_snprintf _snprintf
723 # define PyOS_snprintf snprintf
727 /* A crude PyString_FromFormat implementation for old Pythons */
728 #if PY_VERSION_HEX < 0x02020000
730 #ifndef SWIG_PYBUFFER_SIZE
731 # define SWIG_PYBUFFER_SIZE 1024
735 PyString_FromFormat(const char *fmt, ...) {
737 char buf[SWIG_PYBUFFER_SIZE * 2];
740 res = vsnprintf(buf, sizeof(buf), fmt, ap);
742 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
746 /* Add PyObject_Del for old Pythons */
747 #if PY_VERSION_HEX < 0x01060000
748 # define PyObject_Del(op) PyMem_DEL((op))
751 # define PyObject_DEL PyObject_Del
754 /* A crude PyExc_StopIteration exception for old Pythons */
755 #if PY_VERSION_HEX < 0x02020000
756 # ifndef PyExc_StopIteration
757 # define PyExc_StopIteration PyExc_RuntimeError
759 # ifndef PyObject_GenericGetAttr
760 # define PyObject_GenericGetAttr 0
763 /* Py_NotImplemented is defined in 2.1 and up. */
764 #if PY_VERSION_HEX < 0x02010000
765 # ifndef Py_NotImplemented
766 # define Py_NotImplemented PyExc_RuntimeError
771 /* A crude PyString_AsStringAndSize implementation for old Pythons */
772 #if PY_VERSION_HEX < 0x02010000
773 # ifndef PyString_AsStringAndSize
774 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
778 /* PySequence_Size for old Pythons */
779 #if PY_VERSION_HEX < 0x02000000
780 # ifndef PySequence_Size
781 # define PySequence_Size PySequence_Length
786 /* PyBool_FromLong for old Pythons */
787 #if PY_VERSION_HEX < 0x02030000
789 PyObject *PyBool_FromLong(long ok)
791 PyObject *result = ok ? Py_True : Py_False;
797 /* Py_ssize_t for old Pythons */
798 /* This code is as recommended by: */
799 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
800 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
801 typedef int Py_ssize_t;
802 # define PY_SSIZE_T_MAX INT_MAX
803 # define PY_SSIZE_T_MIN INT_MIN
806 /* -----------------------------------------------------------------------------
808 * ----------------------------------------------------------------------------- */
810 SWIGRUNTIME PyObject*
811 SWIG_Python_ErrorType(int code) {
814 case SWIG_MemoryError:
815 type = PyExc_MemoryError;
818 type = PyExc_IOError;
820 case SWIG_RuntimeError:
821 type = PyExc_RuntimeError;
823 case SWIG_IndexError:
824 type = PyExc_IndexError;
827 type = PyExc_TypeError;
829 case SWIG_DivisionByZero:
830 type = PyExc_ZeroDivisionError;
832 case SWIG_OverflowError:
833 type = PyExc_OverflowError;
835 case SWIG_SyntaxError:
836 type = PyExc_SyntaxError;
838 case SWIG_ValueError:
839 type = PyExc_ValueError;
841 case SWIG_SystemError:
842 type = PyExc_SystemError;
844 case SWIG_AttributeError:
845 type = PyExc_AttributeError;
848 type = PyExc_RuntimeError;
855 SWIG_Python_AddErrorMsg(const char* mesg)
859 PyObject *traceback = 0;
861 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
863 PyObject *old_str = PyObject_Str(value);
866 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
870 PyErr_Format(PyExc_RuntimeError, mesg);
876 #if defined(SWIG_PYTHON_NO_THREADS)
877 # if defined(SWIG_PYTHON_THREADS)
878 # undef SWIG_PYTHON_THREADS
881 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
882 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
883 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
884 # define SWIG_PYTHON_USE_GIL
887 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
888 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
889 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
891 # ifdef __cplusplus /* C++ code */
892 class SWIG_Python_Thread_Block {
894 PyGILState_STATE state;
896 void end() { if (status) { PyGILState_Release(state); status = false;} }
897 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
898 ~SWIG_Python_Thread_Block() { end(); }
900 class SWIG_Python_Thread_Allow {
904 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
905 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
906 ~SWIG_Python_Thread_Allow() { end(); }
908 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
909 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
910 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
911 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
913 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
914 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
915 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
916 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
918 # else /* Old thread way, not implemented, user must provide it */
919 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
920 # define SWIG_PYTHON_INITIALIZE_THREADS
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
923 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
925 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
926 # define SWIG_PYTHON_THREAD_END_BLOCK
928 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
929 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
931 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
932 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #else /* No thread support */
936 # define SWIG_PYTHON_INITIALIZE_THREADS
937 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
938 # define SWIG_PYTHON_THREAD_END_BLOCK
939 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
940 # define SWIG_PYTHON_THREAD_END_ALLOW
943 /* -----------------------------------------------------------------------------
944 * Python API portion that goes into the runtime
945 * ----------------------------------------------------------------------------- */
954 /* -----------------------------------------------------------------------------
955 * Constant declarations
956 * ----------------------------------------------------------------------------- */
959 #define SWIG_PY_POINTER 4
960 #define SWIG_PY_BINARY 5
962 /* Constant information structure */
963 typedef struct swig_const_info {
969 swig_type_info **ptype;
980 /* -----------------------------------------------------------------------------
981 * See the LICENSE file for information on copyright, usage and redistribution
982 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
986 * This file contains the runtime support for Python modules
987 * and includes code for managing global variables and pointer
990 * ----------------------------------------------------------------------------- */
992 /* Common SWIG API */
994 /* for raw pointers */
995 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
996 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
997 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
998 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
999 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1000 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1001 #define swig_owntype int
1003 /* for raw packed data */
1004 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1005 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1007 /* for class or struct pointers */
1008 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1009 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1011 /* for C or C++ function pointers */
1012 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1013 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1015 /* for C++ member pointers, ie, member methods */
1016 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1017 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1022 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1023 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1024 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1026 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1027 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1028 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1029 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1030 #define SWIG_fail goto fail
1033 /* Runtime API implementation */
1035 /* Error manipulation */
1038 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1039 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1040 PyErr_SetObject(errtype, obj);
1042 SWIG_PYTHON_THREAD_END_BLOCK;
1046 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1047 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1048 PyErr_SetString(errtype, (char *) msg);
1049 SWIG_PYTHON_THREAD_END_BLOCK;
1052 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1054 /* Set a constant value */
1057 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1058 PyDict_SetItemString(d, (char*) name, obj);
1062 /* Append a value to the result obj */
1064 SWIGINTERN PyObject*
1065 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1066 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1069 } else if (result == Py_None) {
1073 if (!PyList_Check(result)) {
1074 PyObject *o2 = result;
1075 result = PyList_New(1);
1076 PyList_SetItem(result, 0, o2);
1078 PyList_Append(result,obj);
1087 } else if (result == Py_None) {
1091 if (!PyTuple_Check(result)) {
1093 result = PyTuple_New(1);
1094 PyTuple_SET_ITEM(result, 0, o2);
1096 o3 = PyTuple_New(1);
1097 PyTuple_SET_ITEM(o3, 0, obj);
1099 result = PySequence_Concat(o2, o3);
1107 /* Unpack the argument tuple */
1110 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1116 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1117 name, (min == max ? "" : "at least "), min);
1121 if (!PyTuple_Check(args)) {
1122 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1125 register int l = PyTuple_GET_SIZE(args);
1127 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1128 name, (min == max ? "" : "at least "), min, l);
1130 } else if (l > max) {
1131 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1132 name, (min == max ? "" : "at most "), max, l);
1136 for (i = 0; i < l; ++i) {
1137 objs[i] = PyTuple_GET_ITEM(args, i);
1139 for (; l < max; ++l) {
1147 /* A functor is a function object with one single object argument */
1148 #if PY_VERSION_HEX >= 0x02020000
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1151 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1155 Helper for static pointer initialization for both C and C++ code, for example
1156 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1159 #define SWIG_STATIC_POINTER(var) var
1161 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1164 /* -----------------------------------------------------------------------------
1165 * Pointer declarations
1166 * ----------------------------------------------------------------------------- */
1168 /* Flags for new pointer objects */
1169 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1170 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1172 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1181 /* How to access Py_None */
1182 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1183 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1184 # ifndef SWIG_PYTHON_BUILD_NONE
1185 # define SWIG_PYTHON_BUILD_NONE
1190 #ifdef SWIG_PYTHON_BUILD_NONE
1193 # define Py_None SWIG_Py_None()
1195 SWIGRUNTIMEINLINE PyObject *
1198 PyObject *none = Py_BuildValue((char*)"");
1202 SWIGRUNTIME PyObject *
1205 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1210 /* The python void return value */
1212 SWIGRUNTIMEINLINE PyObject *
1215 PyObject *none = Py_None;
1220 /* PySwigClientData */
1231 SWIGRUNTIMEINLINE int
1232 SWIG_Python_CheckImplicit(swig_type_info *ty)
1234 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1235 return data ? data->implicitconv : 0;
1238 SWIGRUNTIMEINLINE PyObject *
1239 SWIG_Python_ExceptionType(swig_type_info *desc) {
1240 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1241 PyObject *klass = data ? data->klass : 0;
1242 return (klass ? klass : PyExc_RuntimeError);
1246 SWIGRUNTIME PySwigClientData *
1247 PySwigClientData_New(PyObject* obj)
1252 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1253 /* the klass element */
1255 Py_INCREF(data->klass);
1256 /* the newraw method and newargs arguments used to create a new raw instance */
1257 if (PyClass_Check(obj)) {
1259 data->newargs = obj;
1262 #if (PY_VERSION_HEX < 0x02020000)
1265 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1268 Py_INCREF(data->newraw);
1269 data->newargs = PyTuple_New(1);
1270 PyTuple_SetItem(data->newargs, 0, obj);
1272 data->newargs = obj;
1274 Py_INCREF(data->newargs);
1276 /* the destroy method, aka as the C++ delete method */
1277 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1278 if (PyErr_Occurred()) {
1282 if (data->destroy) {
1284 Py_INCREF(data->destroy);
1285 flags = PyCFunction_GET_FLAGS(data->destroy);
1287 data->delargs = !(flags & (METH_O));
1294 data->implicitconv = 0;
1300 PySwigClientData_Del(PySwigClientData* data)
1302 Py_XDECREF(data->newraw);
1303 Py_XDECREF(data->newargs);
1304 Py_XDECREF(data->destroy);
1307 /* =============== PySwigObject =====================*/
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_long(PySwigObject *v)
1320 return PyLong_FromVoidPtr(v->ptr);
1323 SWIGRUNTIME PyObject *
1324 PySwigObject_format(const char* fmt, PySwigObject *v)
1326 PyObject *res = NULL;
1327 PyObject *args = PyTuple_New(1);
1329 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1330 PyObject *ofmt = PyString_FromString(fmt);
1332 res = PyString_Format(ofmt,args);
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_oct(PySwigObject *v)
1344 return PySwigObject_format("%o",v);
1347 SWIGRUNTIME PyObject *
1348 PySwigObject_hex(PySwigObject *v)
1350 return PySwigObject_format("%x",v);
1353 SWIGRUNTIME PyObject *
1355 PySwigObject_repr(PySwigObject *v)
1357 PySwigObject_repr(PySwigObject *v, PyObject *args)
1360 const char *name = SWIG_TypePrettyName(v->ty);
1361 PyObject *hex = PySwigObject_hex(v);
1362 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1368 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1370 PyString_ConcatAndDel(&repr,nrep);
1376 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1379 PyObject *repr = PySwigObject_repr(v);
1381 PyObject *repr = PySwigObject_repr(v, NULL);
1384 fputs(PyString_AsString(repr), fp);
1392 SWIGRUNTIME PyObject *
1393 PySwigObject_str(PySwigObject *v)
1395 char result[SWIG_BUFFER_SIZE];
1396 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1397 PyString_FromString(result) : 0;
1401 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1405 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1408 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1410 SWIGRUNTIME PyTypeObject*
1411 PySwigObject_type(void) {
1412 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1416 SWIGRUNTIMEINLINE int
1417 PySwigObject_Check(PyObject *op) {
1418 return ((op)->ob_type == PySwigObject_type())
1419 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1422 SWIGRUNTIME PyObject *
1423 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1426 PySwigObject_dealloc(PyObject *v)
1428 PySwigObject *sobj = (PySwigObject *) v;
1429 PyObject *next = sobj->next;
1431 swig_type_info *ty = sobj->ty;
1432 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1433 PyObject *destroy = data ? data->destroy : 0;
1435 /* destroy is always a VARARGS method */
1437 if (data->delargs) {
1438 /* we need to create a temporal object to carry the destroy operation */
1439 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1440 res = SWIG_Python_CallFunctor(destroy, tmp);
1443 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1444 PyObject *mself = PyCFunction_GET_SELF(destroy);
1445 res = ((*meth)(mself, v));
1449 const char *name = SWIG_TypePrettyName(ty);
1450 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1451 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1459 SWIGRUNTIME PyObject*
1460 PySwigObject_append(PyObject* v, PyObject* next)
1462 PySwigObject *sobj = (PySwigObject *) v;
1465 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1468 if (!PySwigObject_Check(next)) {
1473 return SWIG_Py_Void();
1476 SWIGRUNTIME PyObject*
1478 PySwigObject_next(PyObject* v)
1480 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1483 PySwigObject *sobj = (PySwigObject *) v;
1485 Py_INCREF(sobj->next);
1488 return SWIG_Py_Void();
1492 SWIGINTERN PyObject*
1494 PySwigObject_disown(PyObject *v)
1496 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1499 PySwigObject *sobj = (PySwigObject *)v;
1501 return SWIG_Py_Void();
1504 SWIGINTERN PyObject*
1506 PySwigObject_acquire(PyObject *v)
1508 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1511 PySwigObject *sobj = (PySwigObject *)v;
1512 sobj->own = SWIG_POINTER_OWN;
1513 return SWIG_Py_Void();
1516 SWIGINTERN PyObject*
1517 PySwigObject_own(PyObject *v, PyObject *args)
1520 #if (PY_VERSION_HEX < 0x02020000)
1521 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1523 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1530 PySwigObject *sobj = (PySwigObject *)v;
1531 PyObject *obj = PyBool_FromLong(sobj->own);
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v);
1537 PySwigObject_disown(v);
1540 if (PyObject_IsTrue(val)) {
1541 PySwigObject_acquire(v,args);
1543 PySwigObject_disown(v,args);
1553 swigobject_methods[] = {
1554 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1555 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1556 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1557 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1558 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1559 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1564 swigobject_methods[] = {
1565 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1566 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1567 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1568 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1569 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1570 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1575 #if PY_VERSION_HEX < 0x02020000
1576 SWIGINTERN PyObject *
1577 PySwigObject_getattr(PySwigObject *sobj,char *name)
1579 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1583 SWIGRUNTIME PyTypeObject*
1584 _PySwigObject_type(void) {
1585 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1587 static PyNumberMethods PySwigObject_as_number = {
1588 (binaryfunc)0, /*nb_add*/
1589 (binaryfunc)0, /*nb_subtract*/
1590 (binaryfunc)0, /*nb_multiply*/
1591 (binaryfunc)0, /*nb_divide*/
1592 (binaryfunc)0, /*nb_remainder*/
1593 (binaryfunc)0, /*nb_divmod*/
1594 (ternaryfunc)0,/*nb_power*/
1595 (unaryfunc)0, /*nb_negative*/
1596 (unaryfunc)0, /*nb_positive*/
1597 (unaryfunc)0, /*nb_absolute*/
1598 (inquiry)0, /*nb_nonzero*/
1605 (coercion)0, /*nb_coerce*/
1606 (unaryfunc)PySwigObject_long, /*nb_int*/
1607 (unaryfunc)PySwigObject_long, /*nb_long*/
1608 (unaryfunc)0, /*nb_float*/
1609 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1610 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1611 #if PY_VERSION_HEX >= 0x02020000
1612 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1613 #elif PY_VERSION_HEX >= 0x02000000
1614 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1618 static PyTypeObject pyswigobject_type;
1619 static int type_init = 0;
1621 const PyTypeObject tmp
1623 PyObject_HEAD_INIT(NULL)
1625 (char *)"PySwigObject", /* tp_name */
1626 sizeof(PySwigObject), /* tp_basicsize */
1627 0, /* tp_itemsize */
1628 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1629 (printfunc)PySwigObject_print, /* tp_print */
1630 #if PY_VERSION_HEX < 0x02020000
1631 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1633 (getattrfunc)0, /* tp_getattr */
1635 (setattrfunc)0, /* tp_setattr */
1636 (cmpfunc)PySwigObject_compare, /* tp_compare */
1637 (reprfunc)PySwigObject_repr, /* tp_repr */
1638 &PySwigObject_as_number, /* tp_as_number */
1639 0, /* tp_as_sequence */
1640 0, /* tp_as_mapping */
1641 (hashfunc)0, /* tp_hash */
1642 (ternaryfunc)0, /* tp_call */
1643 (reprfunc)PySwigObject_str, /* tp_str */
1644 PyObject_GenericGetAttr, /* tp_getattro */
1645 0, /* tp_setattro */
1646 0, /* tp_as_buffer */
1647 Py_TPFLAGS_DEFAULT, /* tp_flags */
1648 swigobject_doc, /* tp_doc */
1649 0, /* tp_traverse */
1651 0, /* tp_richcompare */
1652 0, /* tp_weaklistoffset */
1653 #if PY_VERSION_HEX >= 0x02020000
1655 0, /* tp_iternext */
1656 swigobject_methods, /* tp_methods */
1661 0, /* tp_descr_get */
1662 0, /* tp_descr_set */
1663 0, /* tp_dictoffset */
1672 0, /* tp_subclasses */
1673 0, /* tp_weaklist */
1675 #if PY_VERSION_HEX >= 0x02030000
1679 0,0,0,0 /* tp_alloc -> tp_next */
1682 pyswigobject_type = tmp;
1683 pyswigobject_type.ob_type = &PyType_Type;
1686 return &pyswigobject_type;
1689 SWIGRUNTIME PyObject *
1690 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1692 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1699 return (PyObject *)sobj;
1702 /* -----------------------------------------------------------------------------
1703 * Implements a simple Swig Packed type, and use it instead of string
1704 * ----------------------------------------------------------------------------- */
1714 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1716 char result[SWIG_BUFFER_SIZE];
1717 fputs("<Swig Packed ", fp);
1718 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1722 fputs(v->ty->name,fp);
1727 SWIGRUNTIME PyObject *
1728 PySwigPacked_repr(PySwigPacked *v)
1730 char result[SWIG_BUFFER_SIZE];
1731 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1732 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1734 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1738 SWIGRUNTIME PyObject *
1739 PySwigPacked_str(PySwigPacked *v)
1741 char result[SWIG_BUFFER_SIZE];
1742 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1743 return PyString_FromFormat("%s%s", result, v->ty->name);
1745 return PyString_FromString(v->ty->name);
1750 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1754 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1755 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1758 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1760 SWIGRUNTIME PyTypeObject*
1761 PySwigPacked_type(void) {
1762 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1766 SWIGRUNTIMEINLINE int
1767 PySwigPacked_Check(PyObject *op) {
1768 return ((op)->ob_type == _PySwigPacked_type())
1769 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1773 PySwigPacked_dealloc(PyObject *v)
1775 if (PySwigPacked_Check(v)) {
1776 PySwigPacked *sobj = (PySwigPacked *) v;
1782 SWIGRUNTIME PyTypeObject*
1783 _PySwigPacked_type(void) {
1784 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1785 static PyTypeObject pyswigpacked_type;
1786 static int type_init = 0;
1788 const PyTypeObject tmp
1790 PyObject_HEAD_INIT(NULL)
1792 (char *)"PySwigPacked", /* tp_name */
1793 sizeof(PySwigPacked), /* tp_basicsize */
1794 0, /* tp_itemsize */
1795 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1796 (printfunc)PySwigPacked_print, /* tp_print */
1797 (getattrfunc)0, /* tp_getattr */
1798 (setattrfunc)0, /* tp_setattr */
1799 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1800 (reprfunc)PySwigPacked_repr, /* tp_repr */
1801 0, /* tp_as_number */
1802 0, /* tp_as_sequence */
1803 0, /* tp_as_mapping */
1804 (hashfunc)0, /* tp_hash */
1805 (ternaryfunc)0, /* tp_call */
1806 (reprfunc)PySwigPacked_str, /* tp_str */
1807 PyObject_GenericGetAttr, /* tp_getattro */
1808 0, /* tp_setattro */
1809 0, /* tp_as_buffer */
1810 Py_TPFLAGS_DEFAULT, /* tp_flags */
1811 swigpacked_doc, /* tp_doc */
1812 0, /* tp_traverse */
1814 0, /* tp_richcompare */
1815 0, /* tp_weaklistoffset */
1816 #if PY_VERSION_HEX >= 0x02020000
1818 0, /* tp_iternext */
1824 0, /* tp_descr_get */
1825 0, /* tp_descr_set */
1826 0, /* tp_dictoffset */
1835 0, /* tp_subclasses */
1836 0, /* tp_weaklist */
1838 #if PY_VERSION_HEX >= 0x02030000
1842 0,0,0,0 /* tp_alloc -> tp_next */
1845 pyswigpacked_type = tmp;
1846 pyswigpacked_type.ob_type = &PyType_Type;
1849 return &pyswigpacked_type;
1852 SWIGRUNTIME PyObject *
1853 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1855 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1857 void *pack = malloc(size);
1859 memcpy(pack, ptr, size);
1864 PyObject_DEL((PyObject *) sobj);
1868 return (PyObject *) sobj;
1871 SWIGRUNTIME swig_type_info *
1872 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1874 if (PySwigPacked_Check(obj)) {
1875 PySwigPacked *sobj = (PySwigPacked *)obj;
1876 if (sobj->size != size) return 0;
1877 memcpy(ptr, sobj->pack, size);
1884 /* -----------------------------------------------------------------------------
1885 * pointers/data manipulation
1886 * ----------------------------------------------------------------------------- */
1888 SWIGRUNTIMEINLINE PyObject *
1891 return PyString_FromString("this");
1894 SWIGRUNTIME PyObject *
1897 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1901 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1903 SWIGRUNTIME PySwigObject *
1904 SWIG_Python_GetSwigThis(PyObject *pyobj)
1906 if (PySwigObject_Check(pyobj)) {
1907 return (PySwigObject *) pyobj;
1910 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1911 if (PyInstance_Check(pyobj)) {
1912 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1914 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1915 if (dictptr != NULL) {
1916 PyObject *dict = *dictptr;
1917 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1919 #ifdef PyWeakref_CheckProxy
1920 if (PyWeakref_CheckProxy(pyobj)) {
1921 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1922 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1925 obj = PyObject_GetAttr(pyobj,SWIG_This());
1929 if (PyErr_Occurred()) PyErr_Clear();
1935 obj = PyObject_GetAttr(pyobj,SWIG_This());
1939 if (PyErr_Occurred()) PyErr_Clear();
1943 if (obj && !PySwigObject_Check(obj)) {
1944 /* a PyObject is called 'this', try to get the 'real this'
1945 PySwigObject from it */
1946 return SWIG_Python_GetSwigThis(obj);
1948 return (PySwigObject *)obj;
1952 /* Acquire a pointer value */
1955 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1957 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1959 int oldown = sobj->own;
1967 /* Convert a pointer value */
1970 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1971 if (!obj) return SWIG_ERROR;
1972 if (obj == Py_None) {
1976 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1978 void *vptr = sobj->ptr;
1980 swig_type_info *to = sobj->ty;
1982 /* no type cast needed */
1983 if (ptr) *ptr = vptr;
1986 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1988 sobj = (PySwigObject *)sobj->next;
1990 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1995 if (ptr) *ptr = vptr;
2000 if (own) *own = sobj->own;
2001 if (flags & SWIG_POINTER_DISOWN) {
2006 int res = SWIG_ERROR;
2007 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2008 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2009 if (data && !data->implicitconv) {
2010 PyObject *klass = data->klass;
2013 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2014 impconv = SWIG_Python_CallFunctor(klass, obj);
2015 data->implicitconv = 0;
2016 if (PyErr_Occurred()) {
2021 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2024 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2025 if (SWIG_IsOK(res)) {
2028 /* transfer the ownership to 'ptr' */
2030 res = SWIG_AddCast(res);
2031 res = SWIG_AddNewMask(res);
2033 res = SWIG_AddCast(res);
2047 /* Convert a function ptr value */
2050 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2051 if (!PyCFunction_Check(obj)) {
2052 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2056 /* here we get the method pointer for callbacks */
2057 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2058 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2060 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2061 if (!desc) return SWIG_ERROR;
2064 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2065 if (!tc) return SWIG_ERROR;
2066 *ptr = SWIG_TypeCast(tc,vptr);
2074 /* Convert a packed value value */
2077 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2078 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2079 if (!to) return SWIG_ERROR;
2082 /* check type cast? */
2083 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2084 if (!tc) return SWIG_ERROR;
2090 /* -----------------------------------------------------------------------------
2091 * Create a new pointer object
2092 * ----------------------------------------------------------------------------- */
2095 Create a new instance object, whitout calling __init__, and set the
2099 SWIGRUNTIME PyObject*
2100 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2102 #if (PY_VERSION_HEX >= 0x02020000)
2104 PyObject *newraw = data->newraw;
2106 inst = PyObject_Call(newraw, data->newargs, NULL);
2108 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2109 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2110 if (dictptr != NULL) {
2111 PyObject *dict = *dictptr;
2113 dict = PyDict_New();
2115 PyDict_SetItem(dict, SWIG_This(), swig_this);
2119 PyObject *key = SWIG_This();
2120 PyObject_SetAttr(inst, key, swig_this);
2124 PyObject *dict = PyDict_New();
2125 PyDict_SetItem(dict, SWIG_This(), swig_this);
2126 inst = PyInstance_NewRaw(data->newargs, dict);
2131 #if (PY_VERSION_HEX >= 0x02010000)
2133 PyObject *dict = PyDict_New();
2134 PyDict_SetItem(dict, SWIG_This(), swig_this);
2135 inst = PyInstance_NewRaw(data->newargs, dict);
2137 return (PyObject *) inst;
2139 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2143 inst->in_class = (PyClassObject *)data->newargs;
2144 Py_INCREF(inst->in_class);
2145 inst->in_dict = PyDict_New();
2146 if (inst->in_dict == NULL) {
2150 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2151 inst->in_weakreflist = NULL;
2153 #ifdef Py_TPFLAGS_GC
2154 PyObject_GC_Init(inst);
2156 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2157 return (PyObject *) inst;
2163 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2166 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2167 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2168 if (dictptr != NULL) {
2171 dict = PyDict_New();
2174 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2179 PyDict_SetItem(dict, SWIG_This(), swig_this);
2184 SWIGINTERN PyObject *
2185 SWIG_Python_InitShadowInstance(PyObject *args) {
2187 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2190 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2192 PySwigObject_append((PyObject*) sthis, obj[1]);
2194 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2196 return SWIG_Py_Void();
2200 /* Create a new pointer object */
2202 SWIGRUNTIME PyObject *
2203 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2205 return SWIG_Py_Void();
2207 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2208 PyObject *robj = PySwigObject_New(ptr, type, own);
2209 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2210 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2211 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2221 /* Create a new packed object */
2223 SWIGRUNTIMEINLINE PyObject *
2224 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2225 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2228 /* -----------------------------------------------------------------------------*
2230 * -----------------------------------------------------------------------------*/
2232 #ifdef SWIG_LINK_RUNTIME
2233 void *SWIG_ReturnGlobalTypeList(void *);
2236 SWIGRUNTIME swig_module_info *
2237 SWIG_Python_GetModule(void) {
2238 static void *type_pointer = (void *)0;
2239 /* first check if module already created */
2240 if (!type_pointer) {
2241 #ifdef SWIG_LINK_RUNTIME
2242 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2244 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2245 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2246 if (PyErr_Occurred()) {
2248 type_pointer = (void *)0;
2252 return (swig_module_info *) type_pointer;
2255 #if PY_MAJOR_VERSION < 2
2256 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2257 is copied out of Python/modsupport.c in python version 2.3.4 */
2259 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2262 if (!PyModule_Check(m)) {
2263 PyErr_SetString(PyExc_TypeError,
2264 "PyModule_AddObject() needs module as first arg");
2268 PyErr_SetString(PyExc_TypeError,
2269 "PyModule_AddObject() needs non-NULL value");
2273 dict = PyModule_GetDict(m);
2275 /* Internal error -- modules must have a dict! */
2276 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2277 PyModule_GetName(m));
2280 if (PyDict_SetItemString(dict, name, o))
2288 SWIG_Python_DestroyModule(void *vptr)
2290 swig_module_info *swig_module = (swig_module_info *) vptr;
2291 swig_type_info **types = swig_module->types;
2293 for (i =0; i < swig_module->size; ++i) {
2294 swig_type_info *ty = types[i];
2296 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2297 if (data) PySwigClientData_Del(data);
2300 Py_DECREF(SWIG_This());
2304 SWIG_Python_SetModule(swig_module_info *swig_module) {
2305 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2307 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2308 swig_empty_runtime_method_table);
2309 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2310 if (pointer && module) {
2311 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2313 Py_XDECREF(pointer);
2317 /* The python cached type query */
2318 SWIGRUNTIME PyObject *
2319 SWIG_Python_TypeCache(void) {
2320 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2324 SWIGRUNTIME swig_type_info *
2325 SWIG_Python_TypeQuery(const char *type)
2327 PyObject *cache = SWIG_Python_TypeCache();
2328 PyObject *key = PyString_FromString(type);
2329 PyObject *obj = PyDict_GetItem(cache, key);
2330 swig_type_info *descriptor;
2332 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2334 swig_module_info *swig_module = SWIG_Python_GetModule();
2335 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2337 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2338 PyDict_SetItem(cache, key, obj);
2347 For backward compatibility only
2349 #define SWIG_POINTER_EXCEPTION 0
2350 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2351 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2354 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2356 if (PyErr_Occurred()) {
2358 PyObject *value = 0;
2359 PyObject *traceback = 0;
2360 PyErr_Fetch(&type, &value, &traceback);
2362 PyObject *old_str = PyObject_Str(value);
2366 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2368 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2379 SWIG_Python_ArgFail(int argnum)
2381 if (PyErr_Occurred()) {
2382 /* add information about failing argument */
2384 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2385 return SWIG_Python_AddErrMesg(mesg, 1);
2391 SWIGRUNTIMEINLINE const char *
2392 PySwigObject_GetDesc(PyObject *self)
2394 PySwigObject *v = (PySwigObject *)self;
2395 swig_type_info *ty = v ? v->ty : 0;
2396 return ty ? ty->str : (char*)"";
2400 SWIG_Python_TypeError(const char *type, PyObject *obj)
2403 #if defined(SWIG_COBJECT_TYPES)
2404 if (obj && PySwigObject_Check(obj)) {
2405 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2407 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2414 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2416 PyObject *str = PyObject_Str(obj);
2417 const char *cstr = str ? PyString_AsString(str) : 0;
2419 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2422 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2429 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2431 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2436 /* Convert a pointer value, signal an exception on a type mismatch */
2438 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2440 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2442 if (flags & SWIG_POINTER_EXCEPTION) {
2443 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2444 SWIG_Python_ArgFail(argnum);
2460 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2462 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2466 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2469 /* -------- TYPES TABLE (BEGIN) -------- */
2471 #define SWIGTYPE_p_FILE swig_types[0]
2472 #define SWIGTYPE_p_Hex__BiCylinder swig_types[1]
2473 #define SWIGTYPE_p_Hex__Document swig_types[2]
2474 #define SWIGTYPE_p_Hex__Edge swig_types[3]
2475 #define SWIGTYPE_p_Hex__Elements swig_types[4]
2476 #define SWIGTYPE_p_Hex__EltBase swig_types[5]
2477 #define SWIGTYPE_p_Hex__Group swig_types[6]
2478 #define SWIGTYPE_p_Hex__Hex swig_types[7]
2479 #define SWIGTYPE_p_Hex__Hex__EltBase swig_types[8]
2480 #define SWIGTYPE_p_Hex__Hexa swig_types[9]
2481 #define SWIGTYPE_p_Hex__Law swig_types[10]
2482 #define SWIGTYPE_p_Hex__NewShape swig_types[11]
2483 #define SWIGTYPE_p_Hex__Propagation swig_types[12]
2484 #define SWIGTYPE_p_Hex__Quad swig_types[13]
2485 #define SWIGTYPE_p_Hex__Shape swig_types[14]
2486 #define SWIGTYPE_p_Hex__Vector swig_types[15]
2487 #define SWIGTYPE_p_Hex__Vertex swig_types[16]
2488 #define SWIGTYPE_p_Hex__XmlWriter swig_types[17]
2489 #define SWIGTYPE_p_a_Hex__DIM3__double swig_types[18]
2490 #define SWIGTYPE_p_allocator_type swig_types[19]
2491 #define SWIGTYPE_p_char swig_types[20]
2492 #define SWIGTYPE_p_const_reference swig_types[21]
2493 #define SWIGTYPE_p_difference_type swig_types[22]
2494 #define SWIGTYPE_p_double swig_types[23]
2495 #define SWIGTYPE_p_int swig_types[24]
2496 #define SWIGTYPE_p_p_PyObject swig_types[25]
2497 #define SWIGTYPE_p_reference swig_types[26]
2498 #define SWIGTYPE_p_size_type swig_types[27]
2499 #define SWIGTYPE_p_std__invalid_argument swig_types[28]
2500 #define SWIGTYPE_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t swig_types[29]
2501 #define SWIGTYPE_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t swig_types[30]
2502 #define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t swig_types[31]
2503 #define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type swig_types[32]
2504 #define SWIGTYPE_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t swig_types[33]
2505 #define SWIGTYPE_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t swig_types[34]
2506 #define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t swig_types[35]
2507 #define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type swig_types[36]
2508 #define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t swig_types[37]
2509 #define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type swig_types[38]
2510 #define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t swig_types[39]
2511 #define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type swig_types[40]
2512 #define SWIGTYPE_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t swig_types[41]
2513 #define SWIGTYPE_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t swig_types[42]
2514 #define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t swig_types[43]
2515 #define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type swig_types[44]
2516 #define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t swig_types[45]
2517 #define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type swig_types[46]
2518 #define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[47]
2519 #define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[48]
2520 #define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t swig_types[49]
2521 #define SWIGTYPE_p_string swig_types[50]
2522 #define SWIGTYPE_p_swig__PySwigIterator swig_types[51]
2523 #define SWIGTYPE_p_value_type swig_types[52]
2524 #define SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type swig_types[53]
2525 #define SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type swig_types[54]
2526 #define SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type swig_types[55]
2527 #define SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type swig_types[56]
2528 #define SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type swig_types[57]
2529 static swig_type_info *swig_types[59];
2530 static swig_module_info swig_module = {swig_types, 58, 0, 0, 0, 0};
2531 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2532 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2534 /* -------- TYPES TABLE (END) -------- */
2536 #if (PY_VERSION_HEX <= 0x02000000)
2537 # if !defined(SWIG_PYTHON_CLASSIC)
2538 # error "This python version requires swig to be run with the '-classic' option"
2542 /*-----------------------------------------------
2543 @(target):= _hexablock_swig.so
2544 ------------------------------------------------*/
2545 #define SWIG_init init_hexablock_swig
2547 #define SWIG_name "_hexablock_swig"
2549 #define SWIGVERSION 0x010331
2550 #define SWIG_VERSION SWIGVERSION
2553 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2554 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2557 #include <stdexcept>
2561 class PyObject_ptr {
2566 PyObject_ptr() :_obj(0)
2570 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2575 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2577 if (initial_ref) Py_XINCREF(_obj);
2580 PyObject_ptr & operator=(const PyObject_ptr& item)
2582 Py_XINCREF(item._obj);
2593 operator PyObject *() const
2598 PyObject *operator->() const
2607 struct PyObject_var : PyObject_ptr {
2608 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2610 PyObject_var & operator = (PyObject* obj)
2621 #include "HexDocument.hxx"
2622 #include "HexPropagation.hxx"
2623 #include "HexElements.hxx"
2624 #include "HexQuad.hxx"
2625 #include "HexVertex.hxx"
2626 #include "HexHexa.hxx"
2627 #include "HexEdge.hxx"
2628 #include "HexVector.hxx"
2629 #include "HexBiCylinder.hxx"
2630 #include "HexNewShape.hxx"
2631 #include "HexGroup.hxx"
2637 #include <stdexcept>
2641 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
2642 # define SWIG_STD_NOASSIGN_STL
2643 # define SWIG_STD_NOINSERT_TEMPLATE_STL
2644 # define SWIG_STD_NOITERATOR_TRAITS_STL
2647 #if defined(__GNUC__)
2648 # if __GNUC__ == 2 && __GNUC_MINOR <= 96
2649 # define SWIG_STD_NOMODERN_STL
2657 #include <stdexcept>
2661 struct stop_iteration {
2664 struct PySwigIterator {
2669 PySwigIterator(PyObject *seq) : _seq(seq)
2674 virtual ~PySwigIterator() {}
2676 // Access iterator method, required by Python
2677 virtual PyObject *value() const = 0;
2679 // Forward iterator method, required by Python
2680 virtual PySwigIterator *incr(size_t n = 1) = 0;
2682 // Backward iterator method, very common in C++, but not required in Python
2683 virtual PySwigIterator *decr(size_t n = 1)
2685 throw stop_iteration();
2688 // Random access iterator methods, but not required in Python
2689 virtual ptrdiff_t distance(const PySwigIterator &x) const
2691 throw std::invalid_argument("operation not supported");
2694 virtual bool equal (const PySwigIterator &x) const
2696 throw std::invalid_argument("operation not supported");
2699 // C++ common/needed methods
2700 virtual PySwigIterator *copy() const = 0;
2704 PyObject *obj = value();
2709 PyObject *previous()
2715 PySwigIterator *advance(ptrdiff_t n)
2717 return (n > 0) ? incr(n) : decr(-n);
2720 bool operator == (const PySwigIterator& x) const
2725 bool operator != (const PySwigIterator& x) const
2727 return ! operator==(x);
2730 PySwigIterator& operator += (ptrdiff_t n)
2735 PySwigIterator& operator -= (ptrdiff_t n)
2737 return *advance(-n);
2740 PySwigIterator* operator + (ptrdiff_t n) const
2742 return copy()->advance(n);
2745 PySwigIterator* operator - (ptrdiff_t n) const
2747 return copy()->advance(-n);
2750 ptrdiff_t operator - (const PySwigIterator& x) const
2752 return x.distance(*this);
2755 static swig_type_info* descriptor() {
2756 static int init = 0;
2757 static swig_type_info* desc = 0;
2759 desc = SWIG_TypeQuery("swig::PySwigIterator *");
2769 SWIG_AsVal_double (PyObject *obj, double *val)
2771 int res = SWIG_TypeError;
2772 if (PyFloat_Check(obj)) {
2773 if (val) *val = PyFloat_AsDouble(obj);
2775 } else if (PyInt_Check(obj)) {
2776 if (val) *val = PyInt_AsLong(obj);
2778 } else if (PyLong_Check(obj)) {
2779 double v = PyLong_AsDouble(obj);
2780 if (!PyErr_Occurred()) {
2787 #ifdef SWIG_PYTHON_CAST_MODE
2790 double d = PyFloat_AsDouble(obj);
2791 if (!PyErr_Occurred()) {
2793 return SWIG_AddCast(SWIG_OK);
2798 long v = PyLong_AsLong(obj);
2799 if (!PyErr_Occurred()) {
2801 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2818 SWIGINTERNINLINE int
2819 SWIG_CanCastAsInteger(double *d, double min, double max) {
2821 if ((min <= x && x <= max)) {
2822 double fx = floor(x);
2823 double cx = ceil(x);
2824 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2825 if ((errno == EDOM) || (errno == ERANGE)) {
2828 double summ, reps, diff;
2831 } else if (rd > x) {
2838 if (reps < 8*DBL_EPSILON) {
2849 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2851 if (PyInt_Check(obj)) {
2852 long v = PyInt_AsLong(obj);
2857 return SWIG_OverflowError;
2859 } else if (PyLong_Check(obj)) {
2860 unsigned long v = PyLong_AsUnsignedLong(obj);
2861 if (!PyErr_Occurred()) {
2868 #ifdef SWIG_PYTHON_CAST_MODE
2871 unsigned long v = PyLong_AsUnsignedLong(obj);
2872 if (!PyErr_Occurred()) {
2874 return SWIG_AddCast(SWIG_OK);
2880 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2881 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2882 if (val) *val = (unsigned long)(d);
2888 return SWIG_TypeError;
2892 SWIGINTERNINLINE int
2893 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2896 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2897 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2902 #define SWIG_From_long PyInt_FromLong
2905 SWIGINTERNINLINE PyObject *
2906 SWIG_From_ptrdiff_t (ptrdiff_t value)
2908 return SWIG_From_long (static_cast< long >(value));
2912 SWIGINTERNINLINE PyObject*
2913 SWIG_From_bool (bool value)
2915 return PyBool_FromLong(value ? 1 : 0);
2920 SWIG_AsVal_long (PyObject *obj, long* val)
2922 if (PyInt_Check(obj)) {
2923 if (val) *val = PyInt_AsLong(obj);
2925 } else if (PyLong_Check(obj)) {
2926 long v = PyLong_AsLong(obj);
2927 if (!PyErr_Occurred()) {
2934 #ifdef SWIG_PYTHON_CAST_MODE
2937 long v = PyInt_AsLong(obj);
2938 if (!PyErr_Occurred()) {
2940 return SWIG_AddCast(SWIG_OK);
2946 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2947 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2948 if (val) *val = (long)(d);
2954 return SWIG_TypeError;
2958 SWIGINTERNINLINE int
2959 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
2962 int res = SWIG_AsVal_long (obj, val ? &v : 0);
2963 if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
2968 #include <stdexcept>
2971 #include <algorithm>
2978 template <class Type>
2979 struct noconst_traits {
2980 typedef Type noconst_type;
2983 template <class Type>
2984 struct noconst_traits<const Type> {
2985 typedef Type noconst_type;
2991 struct pointer_category { };
2992 struct value_category { };
2995 General traits that provides type_name and type_info
2997 template <class Type> struct traits { };
2999 template <class Type>
3000 inline const char* type_name() {
3001 return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3004 template <class Type>
3005 struct traits_info {
3006 static swig_type_info *type_query(std::string name) {
3008 return SWIG_TypeQuery(name.c_str());
3010 static swig_type_info *type_info() {
3011 static swig_type_info *info = type_query(type_name<Type>());
3016 template <class Type>
3017 inline swig_type_info *type_info() {
3018 return traits_info<Type>::type_info();
3022 Partial specialization for pointers
3024 template <class Type> struct traits <Type *> {
3025 typedef pointer_category category;
3026 static std::string make_ptr_name(const char* name) {
3027 std::string ptrname = name;
3031 static const char* type_name() {
3032 static std::string name = make_ptr_name(swig::type_name<Type>());
3033 return name.c_str();
3037 template <class Type, class Category>
3038 struct traits_as { };
3040 template <class Type, class Category>
3041 struct traits_check { };
3048 Traits that provides the from method
3050 template <class Type> struct traits_from_ptr {
3051 static PyObject *from(Type *val, int owner = 0) {
3052 return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3056 template <class Type> struct traits_from {
3057 static PyObject *from(const Type& val) {
3058 return traits_from_ptr<Type>::from(new Type(val), 1);
3062 template <class Type> struct traits_from<Type *> {
3063 static PyObject *from(Type* val) {
3064 return traits_from_ptr<Type>::from(val, 0);
3068 template <class Type> struct traits_from<const Type *> {
3069 static PyObject *from(const Type* val) {
3070 return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3075 template <class Type>
3076 inline PyObject *from(const Type& val) {
3077 return traits_from<Type>::from(val);
3080 template <class Type>
3081 inline PyObject *from_ptr(Type* val, int owner) {
3082 return traits_from_ptr<Type>::from(val, owner);
3086 Traits that provides the asval/as/check method
3088 template <class Type>
3089 struct traits_asptr {
3090 static int asptr(PyObject *obj, Type **val) {
3092 int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3093 if (SWIG_IsOK(res)) {
3100 template <class Type>
3101 inline int asptr(PyObject *obj, Type **vptr) {
3102 return traits_asptr<Type>::asptr(obj, vptr);
3105 template <class Type>
3106 struct traits_asval {
3107 static int asval(PyObject *obj, Type *val) {
3110 int res = traits_asptr<Type>::asptr(obj, &p);
3111 if (!SWIG_IsOK(res)) return res;
3113 typedef typename noconst_traits<Type>::noconst_type noconst_type;
3114 *(const_cast<noconst_type*>(val)) = *p;
3115 if (SWIG_IsNewObj(res)){
3117 res = SWIG_DelNewMask(res);
3124 return traits_asptr<Type>::asptr(obj, (Type **)(0));
3129 template <class Type> struct traits_asval<Type*> {
3130 static int asval(PyObject *obj, Type **val) {
3132 typedef typename noconst_traits<Type>::noconst_type noconst_type;
3133 noconst_type *p = 0;
3134 int res = traits_asptr<noconst_type>::asptr(obj, &p);
3135 if (SWIG_IsOK(res)) {
3136 *(const_cast<noconst_type**>(val)) = p;
3140 return traits_asptr<Type>::asptr(obj, (Type **)(0));
3145 template <class Type>
3146 inline int asval(PyObject *obj, Type *val) {
3147 return traits_asval<Type>::asval(obj, val);
3150 template <class Type>
3151 struct traits_as<Type, value_category> {
3152 static Type as(PyObject *obj, bool throw_error) {
3154 int res = asval(obj, &v);
3155 if (!obj || !SWIG_IsOK(res)) {
3156 if (!PyErr_Occurred()) {
3157 SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3159 if (throw_error) throw std::invalid_argument("bad type");
3165 template <class Type>
3166 struct traits_as<Type, pointer_category> {
3167 static Type as(PyObject *obj, bool throw_error) {
3169 int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3170 if (SWIG_IsOK(res) && v) {
3171 if (SWIG_IsNewObj(res)) {
3179 // Uninitialized return value, no Type() constructor required.
3180 static Type *v_def = (Type*) malloc(sizeof(Type));
3181 if (!PyErr_Occurred()) {
3182 SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3184 if (throw_error) throw std::invalid_argument("bad type");
3185 memset(v_def,0,sizeof(Type));
3191 template <class Type>
3192 struct traits_as<Type*, pointer_category> {
3193 static Type* as(PyObject *obj, bool throw_error) {
3195 int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3196 if (SWIG_IsOK(res)) {
3199 if (!PyErr_Occurred()) {
3200 SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3202 if (throw_error) throw std::invalid_argument("bad type");
3208 template <class Type>
3209 inline Type as(PyObject *obj, bool te = false) {
3210 return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3213 template <class Type>
3214 struct traits_check<Type, value_category> {
3215 static bool check(PyObject *obj) {
3216 int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3217 return SWIG_IsOK(res) ? true : false;
3221 template <class Type>
3222 struct traits_check<Type, pointer_category> {
3223 static bool check(PyObject *obj) {
3224 int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3225 return SWIG_IsOK(res) ? true : false;
3229 template <class Type>
3230 inline bool check(PyObject *obj) {
3231 return traits_check<Type, typename traits<Type>::category>::check(obj);
3236 #include <functional>
3240 struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3243 operator()(PyObject * v, PyObject *w) const
3246 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3247 res = PyObject_Compare(v, w) < 0;
3248 SWIG_PYTHON_THREAD_END_BLOCK;
3254 struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3257 operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3259 return std::less<PyObject *>()(v, w);
3264 struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3267 operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3269 return std::less<PyObject *>()(v, w);
3276 template <> struct traits<PyObject *> {
3277 typedef value_category category;
3278 static const char* type_name() { return "PyObject *"; }
3281 template <> struct traits_asval<PyObject * > {
3282 typedef PyObject * value_type;
3283 static int asval(PyObject *obj, value_type *val) {
3284 if (val) *val = obj;
3290 struct traits_check<PyObject *, value_category> {
3291 static bool check(PyObject *) {
3296 template <> struct traits_from<PyObject *> {
3297 typedef PyObject * value_type;
3298 static PyObject *from(const value_type& val) {
3308 check_index(ptrdiff_t i, size_t size, bool insert = false) {
3310 if ((size_t) (-i) <= size)
3311 return (size_t) (i + size);
3312 } else if ( (size_t) i < size ) {
3314 } else if (insert && ((size_t) i == size)) {
3318 throw std::out_of_range("index out of range");
3322 slice_index(ptrdiff_t i, size_t size) {
3324 if ((size_t) (-i) <= size) {
3325 return (size_t) (i + size);
3327 throw std::out_of_range("index out of range");
3330 return ( (size_t) i < size ) ? ((size_t) i) : size;
3334 template <class Sequence, class Difference>
3335 inline typename Sequence::iterator
3336 getpos(Sequence* self, Difference i) {
3337 typename Sequence::iterator pos = self->begin();
3338 std::advance(pos, check_index(i,self->size()));
3342 template <class Sequence, class Difference>
3343 inline typename Sequence::const_iterator
3344 cgetpos(const Sequence* self, Difference i) {
3345 typename Sequence::const_iterator pos = self->begin();
3346 std::advance(pos, check_index(i,self->size()));
3350 template <class Sequence, class Difference>
3352 getslice(const Sequence* self, Difference i, Difference j) {
3353 typename Sequence::size_type size = self->size();
3354 typename Sequence::size_type ii = swig::check_index(i, size);
3355 typename Sequence::size_type jj = swig::slice_index(j, size);
3358 typename Sequence::const_iterator vb = self->begin();
3359 typename Sequence::const_iterator ve = self->begin();
3360 std::advance(vb,ii);
3361 std::advance(ve,jj);
3362 return new Sequence(vb, ve);
3364 return new Sequence();
3368 template <class Sequence, class Difference, class InputSeq>
3370 setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3371 typename Sequence::size_type size = self->size();
3372 typename Sequence::size_type ii = swig::check_index(i, size, true);
3373 typename Sequence::size_type jj = swig::slice_index(j, size);
3374 if (jj < ii) jj = ii;
3375 size_t ssize = jj - ii;
3376 if (ssize <= v.size()) {
3377 typename Sequence::iterator sb = self->begin();
3378 typename InputSeq::const_iterator vmid = v.begin();
3379 std::advance(sb,ii);
3380 std::advance(vmid, jj - ii);
3381 self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3383 typename Sequence::iterator sb = self->begin();
3384 typename Sequence::iterator se = self->begin();
3385 std::advance(sb,ii);
3386 std::advance(se,jj);
3388 self->insert(sb, v.begin(), v.end());
3392 template <class Sequence, class Difference>
3394 delslice(Sequence* self, Difference i, Difference j) {
3395 typename Sequence::size_type size = self->size();
3396 typename Sequence::size_type ii = swig::check_index(i, size, true);
3397 typename Sequence::size_type jj = swig::slice_index(j, size);
3399 typename Sequence::iterator sb = self->begin();
3400 typename Sequence::iterator se = self->begin();
3401 std::advance(sb,ii);
3402 std::advance(se,jj);
3409 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3413 template <class Iterator>
3414 struct iterator_traits {
3415 typedef ptrdiff_t difference_type;
3416 typedef typename Iterator::value_type value_type;
3419 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3420 template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3421 struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3422 typedef Distance difference_type;
3423 typedef T value_type;
3428 struct iterator_traits<T*> {
3429 typedef T value_type;
3430 typedef ptrdiff_t difference_type;
3433 template<typename _InputIterator>
3434 inline typename iterator_traits<_InputIterator>::difference_type
3435 distance(_InputIterator __first, _InputIterator __last)
3437 typename iterator_traits<_InputIterator>::difference_type __n = 0;
3438 while (__first != __last) {
3449 template<typename OutIterator>
3450 class PySwigIterator_T : public PySwigIterator
3453 typedef OutIterator out_iterator;
3454 typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3455 typedef PySwigIterator_T<out_iterator> self_type;
3457 PySwigIterator_T(out_iterator curr, PyObject *seq)
3458 : PySwigIterator(seq), current(curr)
3462 const out_iterator& get_current() const
3468 bool equal (const PySwigIterator &iter) const
3470 const self_type *iters = dynamic_cast<const self_type *>(&iter);
3472 return (current == iters->get_current());
3474 throw std::invalid_argument("bad iterator type");
3478 ptrdiff_t distance(const PySwigIterator &iter) const
3480 const self_type *iters = dynamic_cast<const self_type *>(&iter);
3482 return std::distance(current, iters->get_current());
3484 throw std::invalid_argument("bad iterator type");
3489 out_iterator current;
3492 template <class ValueType>
3495 typedef const ValueType& argument_type;
3496 typedef PyObject *result_type;
3497 result_type operator()(argument_type v) const
3499 return swig::from(v);
3503 template<typename OutIterator,
3504 typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3505 typename FromOper = from_oper<ValueType> >
3506 class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
3510 typedef OutIterator out_iterator;
3511 typedef ValueType value_type;
3512 typedef PySwigIterator_T<out_iterator> base;
3513 typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3515 PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
3516 : PySwigIterator_T<OutIterator>(curr, seq)
3520 PyObject *value() const {
3521 return from(static_cast<const value_type&>(*(base::current)));
3524 PySwigIterator *copy() const
3526 return new self_type(*this);
3529 PySwigIterator *incr(size_t n = 1)
3537 PySwigIterator *decr(size_t n = 1)
3546 template<typename OutIterator,
3547 typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3548 typename FromOper = from_oper<ValueType> >
3549 class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
3553 typedef OutIterator out_iterator;
3554 typedef ValueType value_type;
3555 typedef PySwigIterator_T<out_iterator> base;
3556 typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3558 PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3559 : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3563 PyObject *value() const {
3564 if (base::current == end) {
3565 throw stop_iteration();
3567 return from(static_cast<const value_type&>(*(base::current)));
3571 PySwigIterator *copy() const
3573 return new self_type(*this);
3576 PySwigIterator *incr(size_t n = 1)
3579 if (base::current == end) {
3580 throw stop_iteration();
3588 PySwigIterator *decr(size_t n = 1)
3591 if (base::current == begin) {
3592 throw stop_iteration();
3605 template<typename OutIter>
3606 inline PySwigIterator*
3607 make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
3609 return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
3612 template<typename OutIter>
3613 inline PySwigIterator*
3614 make_output_iterator(const OutIter& current, PyObject *seq = 0)
3616 return new PySwigIteratorOpen_T<OutIter>(current, seq);
3624 struct PySequence_Ref
3626 PySequence_Ref(PyObject* seq, int index)
3627 : _seq(seq), _index(index)
3633 swig::PyObject_var item = PySequence_GetItem(_seq, _index);
3635 return swig::as<T>(item, true);
3636 } catch (std::exception& e) {
3638 sprintf(msg, "in sequence element %d ", _index);
3639 if (!PyErr_Occurred()) {
3640 SWIG_Error(SWIG_TypeError, swig::type_name<T>());
3642 SWIG_Python_AddErrorMsg(msg);
3643 SWIG_Python_AddErrorMsg(e.what());
3648 PySequence_Ref& operator=(const T& v)
3650 PySequence_SetItem(_seq, _index, swig::from<T>(v));
3660 struct PySequence_ArrowProxy
3662 PySequence_ArrowProxy(const T& x): m_value(x) {}
3663 const T* operator->() const { return &m_value; }
3664 operator const T*() const { return &m_value; }
3668 template <class T, class Reference >
3669 struct PySequence_InputIterator
3671 typedef PySequence_InputIterator<T, Reference > self;
3673 typedef std::random_access_iterator_tag iterator_category;
3674 typedef Reference reference;
3675 typedef T value_type;
3677 typedef int difference_type;
3679 PySequence_InputIterator()
3683 PySequence_InputIterator(PyObject* seq, int index)
3684 : _seq(seq), _index(index)
3688 reference operator*() const
3690 return reference(_seq, _index);
3693 PySequence_ArrowProxy<T>
3694 operator->() const {
3695 return PySequence_ArrowProxy<T>(operator*());
3698 bool operator==(const self& ri) const
3700 return (_index == ri._index) && (_seq == ri._seq);
3703 bool operator!=(const self& ri) const
3705 return !(operator==(ri));
3708 self& operator ++ ()
3714 self& operator -- ()
3720 self& operator += (difference_type n)
3726 self operator +(difference_type n) const
3728 return self(_seq, _index + n);
3731 self& operator -= (difference_type n)
3737 self operator -(difference_type n) const
3739 return self(_seq, _index - n);
3742 difference_type operator - (const self& ri) const
3744 return _index - ri._index;
3747 bool operator < (const self& ri) const
3749 return _index < ri._index;
3753 operator[](difference_type n) const
3755 return reference(_seq, _index + n);
3760 difference_type _index;
3764 struct PySequence_Cont
3766 typedef PySequence_Ref<T> reference;
3767 typedef const PySequence_Ref<T> const_reference;
3768 typedef T value_type;
3770 typedef int difference_type;
3771 typedef int size_type;
3772 typedef const pointer const_pointer;
3773 typedef PySequence_InputIterator<T, reference> iterator;
3774 typedef PySequence_InputIterator<T, const_reference> const_iterator;
3776 PySequence_Cont(PyObject* seq) : _seq(0)
3778 if (!PySequence_Check(seq)) {
3779 throw std::invalid_argument("a sequence is expected");
3787 if (_seq) Py_DECREF(_seq);
3790 size_type size() const
3792 return PySequence_Size(_seq);
3802 return iterator(_seq, 0);
3805 const_iterator begin() const
3807 return const_iterator(_seq, 0);
3812 return iterator(_seq, size());
3815 const_iterator end() const
3817 return const_iterator(_seq, size());
3820 reference operator[](difference_type n)
3822 return reference(_seq, n);
3825 const_reference operator[](difference_type n) const
3827 return const_reference(_seq, n);
3830 bool check(bool set_err = true) const
3833 for (int i = 0; i < s; ++i) {
3834 swig::PyObject_var item = PySequence_GetItem(_seq, i);
3835 if (!swig::check<value_type>(item)) {
3838 sprintf(msg, "in sequence element %d", i);
3839 SWIG_Error(SWIG_RuntimeError, msg);
3855 template <> struct traits<Hex::Hexa > {
3856 typedef pointer_category category;
3857 static const char* type_name() { return"Hex::Hexa"; }
3863 template <class PySeq, class Seq>
3865 assign(const PySeq& pyseq, Seq* seq) {
3866 #ifdef SWIG_STD_NOASSIGN_STL
3867 typedef typename PySeq::value_type value_type;
3868 typename PySeq::const_iterator it = pyseq.begin();
3869 for (;it != pyseq.end(); ++it) {
3870 seq->insert(seq->end(),(value_type)(*it));
3873 seq->assign(pyseq.begin(), pyseq.end());
3877 template <class Seq, class T = typename Seq::value_type >
3878 struct traits_asptr_stdseq {
3879 typedef Seq sequence;
3880 typedef T value_type;
3882 static int asptr(PyObject *obj, sequence **seq) {
3883 if (PySequence_Check(obj)) {
3885 PySequence_Cont<value_type> pyseq(obj);
3887 sequence *pseq = new sequence();
3888 assign(pyseq, pseq);
3892 return pyseq.check() ? SWIG_OK : SWIG_ERROR;
3894 } catch (std::exception& e) {
3896 if (!PyErr_Occurred()) {
3897 PyErr_SetString(PyExc_TypeError, e.what());
3904 if (SWIG_ConvertPtr(obj,(void**)&p,
3905 swig::type_info<sequence>(),0) == SWIG_OK) {
3914 template <class Seq, class T = typename Seq::value_type >
3915 struct traits_from_stdseq {
3916 typedef Seq sequence;
3917 typedef T value_type;
3918 typedef typename Seq::size_type size_type;
3919 typedef typename sequence::const_iterator const_iterator;
3921 static PyObject *from(const sequence& seq) {
3928 size_type size = seq.size();
3929 if (size <= (size_type)INT_MAX) {
3930 PyObject *obj = PyTuple_New((int)size);
3932 for (const_iterator it = seq.begin();
3933 it != seq.end(); ++it, ++i) {
3934 PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
3938 PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
3948 struct traits_asptr<std::vector<T> > {
3949 static int asptr(PyObject *obj, std::vector<T> **vec) {
3950 return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
3955 struct traits_from<std::vector<T> > {
3956 static PyObject *from(const std::vector<T>& vec) {
3957 return traits_from_stdseq<std::vector<T> >::from(vec);
3964 template <> struct traits<std::vector<Hex::Hexa*, std::allocator<Hex::Hexa * > > > {
3965 typedef value_category category;
3966 static const char* type_name() {
3967 return "std::vector<" "Hex::Hexa" " *," "std::allocator<Hex::Hexa * >" " >";
3972 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector<Hex::Hexa * > *self,PyObject **PYTHON_SELF){
3973 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
3975 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector<Hex::Hexa * > const *self){
3976 return !(self->empty());
3978 SWIGINTERN std::vector<Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector<Hex::Hexa * > const *self){
3979 return self->size();
3982 SWIGINTERNINLINE PyObject*
3983 SWIG_From_unsigned_SS_long (unsigned long value)
3985 return (value > LONG_MAX) ?
3986 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3990 SWIGINTERNINLINE PyObject *
3991 SWIG_From_size_t (size_t value)
3993 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3996 SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector<Hex::Hexa * > *self){
3997 if (self->size() == 0)
3998 throw std::out_of_range("pop from empty container");
3999 std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >::value_type x = self->back();
4003 SWIGINTERN std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::difference_type j){
4004 return swig::getslice(self, i, j);
4006 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::difference_type j,std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &v){
4007 swig::setslice(self, i, j, v);
4009 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::difference_type j){
4010 swig::delslice(self, i, j);
4012 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
4013 self->erase(swig::getpos(self,i));
4015 SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
4016 return *(swig::cgetpos(self, i));
4018 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::value_type x){
4019 *(swig::getpos(self,i)) = x;
4021 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::value_type x){
4026 template <> struct traits<Hex::Quad > {
4027 typedef pointer_category category;
4028 static const char* type_name() { return"Hex::Quad"; }
4034 template <> struct traits<std::vector<Hex::Quad*, std::allocator<Hex::Quad * > > > {
4035 typedef value_category category;
4036 static const char* type_name() {
4037 return "std::vector<" "Hex::Quad" " *," "std::allocator<Hex::Quad * >" " >";
4042 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector<Hex::Quad * > *self,PyObject **PYTHON_SELF){
4043 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4045 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector<Hex::Quad * > const *self){
4046 return !(self->empty());
4048 SWIGINTERN std::vector<Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector<Hex::Quad * > const *self){
4049 return self->size();
4051 SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector<Hex::Quad * > *self){
4052 if (self->size() == 0)
4053 throw std::out_of_range("pop from empty container");
4054 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >::value_type x = self->back();
4058 SWIGINTERN std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::difference_type j){
4059 return swig::getslice(self, i, j);
4061 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::difference_type j,std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &v){
4062 swig::setslice(self, i, j, v);
4064 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::difference_type j){
4065 swig::delslice(self, i, j);
4067 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
4068 self->erase(swig::getpos(self,i));
4070 SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
4071 return *(swig::cgetpos(self, i));
4073 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::value_type x){
4074 *(swig::getpos(self,i)) = x;
4076 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::value_type x){
4081 template <> struct traits<Hex::Edge > {
4082 typedef pointer_category category;
4083 static const char* type_name() { return"Hex::Edge"; }
4089 template <> struct traits<std::vector<Hex::Edge*, std::allocator<Hex::Edge * > > > {
4090 typedef value_category category;
4091 static const char* type_name() {
4092 return "std::vector<" "Hex::Edge" " *," "std::allocator<Hex::Edge * >" " >";
4097 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector<Hex::Edge * > *self,PyObject **PYTHON_SELF){
4098 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4100 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector<Hex::Edge * > const *self){
4101 return !(self->empty());
4103 SWIGINTERN std::vector<Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector<Hex::Edge * > const *self){
4104 return self->size();
4106 SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector<Hex::Edge * > *self){
4107 if (self->size() == 0)
4108 throw std::out_of_range("pop from empty container");
4109 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >::value_type x = self->back();
4113 SWIGINTERN std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::difference_type j){
4114 return swig::getslice(self, i, j);
4116 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::difference_type j,std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &v){
4117 swig::setslice(self, i, j, v);
4119 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::difference_type j){
4120 swig::delslice(self, i, j);
4122 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
4123 self->erase(swig::getpos(self,i));
4125 SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
4126 return *(swig::cgetpos(self, i));
4128 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::value_type x){
4129 *(swig::getpos(self,i)) = x;
4131 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::value_type x){
4136 template <> struct traits<Hex::Vertex > {
4137 typedef pointer_category category;
4138 static const char* type_name() { return"Hex::Vertex"; }
4144 template <> struct traits<std::vector<Hex::Vertex*, std::allocator<Hex::Vertex * > > > {
4145 typedef value_category category;
4146 static const char* type_name() {
4147 return "std::vector<" "Hex::Vertex" " *," "std::allocator<Hex::Vertex * >" " >";
4152 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector<Hex::Vertex * > *self,PyObject **PYTHON_SELF){
4153 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4155 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector<Hex::Vertex * > const *self){
4156 return !(self->empty());
4158 SWIGINTERN std::vector<Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector<Hex::Vertex * > const *self){
4159 return self->size();
4161 SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector<Hex::Vertex * > *self){
4162 if (self->size() == 0)
4163 throw std::out_of_range("pop from empty container");
4164 std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >::value_type x = self->back();
4168 SWIGINTERN std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::difference_type j){
4169 return swig::getslice(self, i, j);
4171 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::difference_type j,std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &v){
4172 swig::setslice(self, i, j, v);
4174 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::difference_type j){
4175 swig::delslice(self, i, j);
4177 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
4178 self->erase(swig::getpos(self,i));
4180 SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
4181 return *(swig::cgetpos(self, i));
4183 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::value_type x){
4184 *(swig::getpos(self,i)) = x;
4186 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::value_type x){
4191 template <> struct traits<Hex::NewShape > {
4192 typedef pointer_category category;
4193 static const char* type_name() { return"Hex::NewShape"; }
4199 template <> struct traits<std::vector<Hex::NewShape*, std::allocator<Hex::NewShape * > > > {
4200 typedef value_category category;
4201 static const char* type_name() {
4202 return "std::vector<" "Hex::NewShape" " *," "std::allocator<Hex::NewShape * >" " >";
4207 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector<Hex::NewShape * > *self,PyObject **PYTHON_SELF){
4208 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4210 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector<Hex::NewShape * > const *self){
4211 return !(self->empty());
4213 SWIGINTERN std::vector<Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector<Hex::NewShape * > const *self){
4214 return self->size();
4216 SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector<Hex::NewShape * > *self){
4217 if (self->size() == 0)
4218 throw std::out_of_range("pop from empty container");
4219 std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >::value_type x = self->back();
4223 SWIGINTERN std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::difference_type j){
4224 return swig::getslice(self, i, j);
4226 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::difference_type j,std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &v){
4227 swig::setslice(self, i, j, v);
4229 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::difference_type j){
4230 swig::delslice(self, i, j);
4232 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
4233 self->erase(swig::getpos(self,i));
4235 SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
4236 return *(swig::cgetpos(self, i));
4238 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::value_type x){
4239 *(swig::getpos(self,i)) = x;
4241 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::value_type x){
4245 #define SWIG_From_double PyFloat_FromDouble
4249 template <> struct traits<double > {
4250 typedef value_category category;
4251 static const char* type_name() { return"double"; }
4253 template <> struct traits_asval<double > {
4254 typedef double value_type;
4255 static int asval(PyObject *obj, value_type *val) {
4256 return SWIG_AsVal_double (obj, val);
4259 template <> struct traits_from<double > {
4260 typedef double value_type;
4261 static PyObject *from(const value_type& val) {
4262 return SWIG_From_double (val);
4269 template <> struct traits<std::vector<double, std::allocator<double > > > {
4270 typedef pointer_category category;
4271 static const char* type_name() {
4272 return "std::vector<" "double" "," "std::allocator<double >" " >";
4277 SWIGINTERN swig::PySwigIterator *std_vector_Sl_double_Sg__iterator(std::vector<double > *self,PyObject **PYTHON_SELF){
4278 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4280 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector<double > const *self){
4281 return !(self->empty());
4283 SWIGINTERN std::vector<double >::size_type std_vector_Sl_double_Sg____len__(std::vector<double > const *self){
4284 return self->size();
4286 SWIGINTERN std::vector<double >::value_type std_vector_Sl_double_Sg__pop(std::vector<double > *self){
4287 if (self->size() == 0)
4288 throw std::out_of_range("pop from empty container");
4289 std::vector<double,std::allocator<double > >::value_type x = self->back();
4293 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){
4294 return swig::getslice(self, i, j);
4296 SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::difference_type j,std::vector<double,std::allocator<double > > const &v){
4297 swig::setslice(self, i, j, v);
4299 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::difference_type j){
4300 swig::delslice(self, i, j);
4302 SWIGINTERN void std_vector_Sl_double_Sg____delitem__(std::vector<double > *self,std::vector<double >::difference_type i){
4303 self->erase(swig::getpos(self,i));
4305 SWIGINTERN std::vector<double >::value_type const &std_vector_Sl_double_Sg____getitem__(std::vector<double > const *self,std::vector<double >::difference_type i){
4306 return *(swig::cgetpos(self, i));
4308 SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::value_type const &x){
4309 *(swig::getpos(self,i)) = x;
4311 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector<double > *self,std::vector<double >::value_type const &x){
4317 # define LLONG_MIN LONG_LONG_MIN
4320 # define LLONG_MAX LONG_LONG_MAX
4323 # define ULLONG_MAX ULONG_LONG_MAX
4328 SWIG_AsVal_int (PyObject * obj, int *val)
4331 int res = SWIG_AsVal_long (obj, &v);
4332 if (SWIG_IsOK(res)) {
4333 if ((v < INT_MIN || v > INT_MAX)) {
4334 return SWIG_OverflowError;
4336 if (val) *val = static_cast< int >(v);
4343 SWIGINTERNINLINE PyObject *
4344 SWIG_From_int (int value)
4346 return SWIG_From_long (value);
4351 template <> struct traits<int > {
4352 typedef value_category category;
4353 static const char* type_name() { return"int"; }
4355 template <> struct traits_asval<int > {
4356 typedef int value_type;
4357 static int asval(PyObject *obj, value_type *val) {
4358 return SWIG_AsVal_int (obj, val);
4361 template <> struct traits_from<int > {
4362 typedef int value_type;
4363 static PyObject *from(const value_type& val) {
4364 return SWIG_From_int (val);
4371 template <> struct traits<std::vector<int, std::allocator<int > > > {
4372 typedef pointer_category category;
4373 static const char* type_name() {
4374 return "std::vector<" "int" "," "std::allocator<int >" " >";
4379 SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector<int > *self,PyObject **PYTHON_SELF){
4380 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4382 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector<int > const *self){
4383 return !(self->empty());
4385 SWIGINTERN std::vector<int >::size_type std_vector_Sl_int_Sg____len__(std::vector<int > const *self){
4386 return self->size();
4388 SWIGINTERN std::vector<int >::value_type std_vector_Sl_int_Sg__pop(std::vector<int > *self){
4389 if (self->size() == 0)
4390 throw std::out_of_range("pop from empty container");
4391 std::vector<int,std::allocator<int > >::value_type x = self->back();
4395 SWIGINTERN std::vector<int,std::allocator<int > > *std_vector_Sl_int_Sg____getslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
4396 return swig::getslice(self, i, j);
4398 SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j,std::vector<int,std::allocator<int > > const &v){
4399 swig::setslice(self, i, j, v);
4401 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
4402 swig::delslice(self, i, j);
4404 SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector<int > *self,std::vector<int >::difference_type i){
4405 self->erase(swig::getpos(self,i));
4407 SWIGINTERN std::vector<int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector<int > const *self,std::vector<int >::difference_type i){
4408 return *(swig::cgetpos(self, i));
4410 SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::value_type const &x){
4411 *(swig::getpos(self,i)) = x;
4413 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector<int > *self,std::vector<int >::value_type const &x){
4417 SWIGINTERN swig_type_info*
4418 SWIG_pchar_descriptor(void)
4420 static int init = 0;
4421 static swig_type_info* info = 0;
4423 info = SWIG_TypeQuery("_p_char");
4430 SWIGINTERNINLINE PyObject *
4431 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4434 if (size > INT_MAX) {
4435 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4436 return pchar_descriptor ?
4437 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4439 return PyString_FromStringAndSize(carray, static_cast< int >(size));
4442 return SWIG_Py_Void();
4447 SWIGINTERNINLINE PyObject *
4448 SWIG_From_char (char c)
4450 return SWIG_FromCharPtrAndSize(&c,1);
4454 SWIGINTERNINLINE PyObject *
4455 SWIG_FromCharPtr(const char *cptr)
4457 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
4462 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4464 if (PyString_Check(obj)) {
4465 char *cstr; Py_ssize_t len;
4466 PyString_AsStringAndSize(obj, &cstr, &len);
4470 In python the user should not be able to modify the inner
4471 string representation. To warranty that, if you define
4472 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4473 buffer is always returned.
4475 The default behavior is just to return the pointer value,
4478 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4479 if (*alloc != SWIG_OLDOBJ)
4481 if (*alloc == SWIG_NEWOBJ)
4484 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4485 *alloc = SWIG_NEWOBJ;
4489 *alloc = SWIG_OLDOBJ;
4492 *cptr = PyString_AsString(obj);
4495 if (psize) *psize = len + 1;
4498 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4499 if (pchar_descriptor) {
4501 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4502 if (cptr) *cptr = (char *) vptr;
4503 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4504 if (alloc) *alloc = SWIG_OLDOBJ;
4509 return SWIG_TypeError;
4517 SWIG_AsVal_bool (PyObject *obj, bool *val)
4519 if (obj == Py_True) {
4520 if (val) *val = true;
4522 } else if (obj == Py_False) {
4523 if (val) *val = false;
4527 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
4528 if (SWIG_IsOK(res) && val) *val = v ? true : false;
4536 SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537 PyObject *resultobj = 0;
4538 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4541 PyObject * obj0 = 0 ;
4543 if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4548 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4551 resultobj = SWIG_Py_Void();
4558 SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4559 PyObject *resultobj = 0;
4560 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4561 PyObject *result = 0 ;
4564 PyObject * obj0 = 0 ;
4566 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
4567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4568 if (!SWIG_IsOK(res1)) {
4569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4571 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4573 result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
4575 catch(swig::stop_iteration &_e) {
4578 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4590 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4591 PyObject *resultobj = 0;
4592 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4594 swig::PySwigIterator *result = 0 ;
4599 PyObject * obj0 = 0 ;
4600 PyObject * obj1 = 0 ;
4602 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
4603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4607 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4608 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4609 if (!SWIG_IsOK(ecode2)) {
4610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
4612 arg2 = static_cast< size_t >(val2);
4614 result = (swig::PySwigIterator *)(arg1)->incr(arg2);
4616 catch(swig::stop_iteration &_e) {
4619 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4631 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632 PyObject *resultobj = 0;
4633 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4634 swig::PySwigIterator *result = 0 ;
4637 PyObject * obj0 = 0 ;
4639 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4644 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4646 result = (swig::PySwigIterator *)(arg1)->incr();
4648 catch(swig::stop_iteration &_e) {
4651 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4663 SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
4668 if (!PyTuple_Check(args)) SWIG_fail;
4669 argc = PyObject_Length(args);
4670 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4671 argv[ii] = PyTuple_GET_ITEM(args,ii);
4676 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4677 _v = SWIG_CheckState(res);
4679 return _wrap_PySwigIterator_incr__SWIG_1(self, args);
4685 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4686 _v = SWIG_CheckState(res);
4689 int res = SWIG_AsVal_size_t(argv[1], NULL);
4690 _v = SWIG_CheckState(res);
4693 return _wrap_PySwigIterator_incr__SWIG_0(self, args);
4699 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n Possible C/C++ prototypes are:\n incr(size_t)\n incr()\n");
4704 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705 PyObject *resultobj = 0;
4706 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4708 swig::PySwigIterator *result = 0 ;
4713 PyObject * obj0 = 0 ;
4714 PyObject * obj1 = 0 ;
4716 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
4717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4718 if (!SWIG_IsOK(res1)) {
4719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4721 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4722 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4723 if (!SWIG_IsOK(ecode2)) {
4724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
4726 arg2 = static_cast< size_t >(val2);
4728 result = (swig::PySwigIterator *)(arg1)->decr(arg2);
4730 catch(swig::stop_iteration &_e) {
4733 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4745 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4746 PyObject *resultobj = 0;
4747 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4748 swig::PySwigIterator *result = 0 ;
4751 PyObject * obj0 = 0 ;
4753 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
4754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4755 if (!SWIG_IsOK(res1)) {
4756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4758 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4760 result = (swig::PySwigIterator *)(arg1)->decr();
4762 catch(swig::stop_iteration &_e) {
4765 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4777 SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
4782 if (!PyTuple_Check(args)) SWIG_fail;
4783 argc = PyObject_Length(args);
4784 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4785 argv[ii] = PyTuple_GET_ITEM(args,ii);
4790 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4791 _v = SWIG_CheckState(res);
4793 return _wrap_PySwigIterator_decr__SWIG_1(self, args);
4799 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4800 _v = SWIG_CheckState(res);
4803 int res = SWIG_AsVal_size_t(argv[1], NULL);
4804 _v = SWIG_CheckState(res);
4807 return _wrap_PySwigIterator_decr__SWIG_0(self, args);
4813 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n Possible C/C++ prototypes are:\n decr(size_t)\n decr()\n");
4818 SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4819 PyObject *resultobj = 0;
4820 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4821 swig::PySwigIterator *arg2 = 0 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4830 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
4831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4832 if (!SWIG_IsOK(res1)) {
4833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4835 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4836 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
4837 if (!SWIG_IsOK(res2)) {
4838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4843 arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4845 result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
4847 catch(std::invalid_argument &_e) {
4848 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;
4851 resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4858 SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4859 PyObject *resultobj = 0;
4860 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4861 swig::PySwigIterator *arg2 = 0 ;
4867 PyObject * obj0 = 0 ;
4868 PyObject * obj1 = 0 ;
4870 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
4871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4872 if (!SWIG_IsOK(res1)) {
4873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4875 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
4877 if (!SWIG_IsOK(res2)) {
4878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4883 arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4885 result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
4887 catch(std::invalid_argument &_e) {
4888 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;
4891 resultobj = SWIG_From_bool(static_cast< bool >(result));
4898 SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4899 PyObject *resultobj = 0;
4900 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4901 swig::PySwigIterator *result = 0 ;
4904 PyObject * obj0 = 0 ;
4906 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
4907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4908 if (!SWIG_IsOK(res1)) {
4909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4911 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4912 result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
4913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
4920 SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4921 PyObject *resultobj = 0;
4922 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4923 PyObject *result = 0 ;
4926 PyObject * obj0 = 0 ;
4928 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
4929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4930 if (!SWIG_IsOK(res1)) {
4931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4933 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4935 result = (PyObject *)(arg1)->next();
4937 catch(swig::stop_iteration &_e) {
4940 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4952 SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953 PyObject *resultobj = 0;
4954 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4955 PyObject *result = 0 ;
4958 PyObject * obj0 = 0 ;
4960 if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
4961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4962 if (!SWIG_IsOK(res1)) {
4963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4965 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4967 result = (PyObject *)(arg1)->previous();
4969 catch(swig::stop_iteration &_e) {
4972 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4984 SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985 PyObject *resultobj = 0;
4986 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4988 swig::PySwigIterator *result = 0 ;
4993 PyObject * obj0 = 0 ;
4994 PyObject * obj1 = 0 ;
4996 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
4997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5001 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5002 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5003 if (!SWIG_IsOK(ecode2)) {
5004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5006 arg2 = static_cast< ptrdiff_t >(val2);
5008 result = (swig::PySwigIterator *)(arg1)->advance(arg2);
5010 catch(swig::stop_iteration &_e) {
5013 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5025 SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5028 swig::PySwigIterator *arg2 = 0 ;
5034 PyObject * obj0 = 0 ;
5035 PyObject * obj1 = 0 ;
5037 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5042 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5044 if (!SWIG_IsOK(res2)) {
5045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5050 arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5051 result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5052 resultobj = SWIG_From_bool(static_cast< bool >(result));
5059 SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060 PyObject *resultobj = 0;
5061 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5062 swig::PySwigIterator *arg2 = 0 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5071 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5076 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5078 if (!SWIG_IsOK(res2)) {
5079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5084 arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5085 result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5086 resultobj = SWIG_From_bool(static_cast< bool >(result));
5093 SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5094 PyObject *resultobj = 0;
5095 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5097 swig::PySwigIterator *result = 0 ;
5102 PyObject * obj0 = 0 ;
5103 PyObject * obj1 = 0 ;
5105 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5110 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5111 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5112 if (!SWIG_IsOK(ecode2)) {
5113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5115 arg2 = static_cast< ptrdiff_t >(val2);
5118 swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
5119 result = (swig::PySwigIterator *) &_result_ref;
5122 catch(swig::stop_iteration &_e) {
5125 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5137 SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138 PyObject *resultobj = 0;
5139 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5141 swig::PySwigIterator *result = 0 ;
5146 PyObject * obj0 = 0 ;
5147 PyObject * obj1 = 0 ;
5149 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
5150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
5151 if (!SWIG_IsOK(res1)) {
5152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5154 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5155 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5156 if (!SWIG_IsOK(ecode2)) {
5157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5159 arg2 = static_cast< ptrdiff_t >(val2);
5162 swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
5163 result = (swig::PySwigIterator *) &_result_ref;
5166 catch(swig::stop_iteration &_e) {
5169 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5181 SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 PyObject *resultobj = 0;
5183 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5185 swig::PySwigIterator *result = 0 ;
5190 PyObject * obj0 = 0 ;
5191 PyObject * obj1 = 0 ;
5193 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
5194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5195 if (!SWIG_IsOK(res1)) {
5196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5198 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5199 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5200 if (!SWIG_IsOK(ecode2)) {
5201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5203 arg2 = static_cast< ptrdiff_t >(val2);
5205 result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
5207 catch(swig::stop_iteration &_e) {
5210 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5222 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5223 PyObject *resultobj = 0;
5224 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5226 swig::PySwigIterator *result = 0 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5234 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5239 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5240 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5241 if (!SWIG_IsOK(ecode2)) {
5242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5244 arg2 = static_cast< ptrdiff_t >(val2);
5246 result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
5248 catch(swig::stop_iteration &_e) {
5251 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5263 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264 PyObject *resultobj = 0;
5265 swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5266 swig::PySwigIterator *arg2 = 0 ;
5272 PyObject * obj0 = 0 ;
5273 PyObject * obj1 = 0 ;
5275 if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5280 arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
5282 if (!SWIG_IsOK(res2)) {
5283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5288 arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5289 result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5290 resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5297 SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5302 if (!PyTuple_Check(args)) SWIG_fail;
5303 argc = PyObject_Length(args);
5304 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5305 argv[ii] = PyTuple_GET_ITEM(args,ii);
5310 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5311 _v = SWIG_CheckState(res);
5313 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5314 _v = SWIG_CheckState(res);
5316 return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5323 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5324 _v = SWIG_CheckState(res);
5327 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5328 _v = SWIG_CheckState(res);
5331 return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5337 Py_INCREF(Py_NotImplemented);
5338 return Py_NotImplemented;
5342 SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5345 SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5346 return SWIG_Py_Void();
5349 SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5352 PyObject **arg2 = (PyObject **) 0 ;
5353 swig::PySwigIterator *result = 0 ;
5356 PyObject * obj0 = 0 ;
5359 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5364 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5365 result = (swig::PySwigIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
5366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
5373 SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5374 PyObject *resultobj = 0;
5375 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5379 PyObject * obj0 = 0 ;
5381 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
5382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5383 if (!SWIG_IsOK(res1)) {
5384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5386 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5387 result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector<Hex::Hexa * > const *)arg1);
5388 resultobj = SWIG_From_bool(static_cast< bool >(result));
5395 SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396 PyObject *resultobj = 0;
5397 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5398 std::vector<Hex::Hexa * >::size_type result;
5401 PyObject * obj0 = 0 ;
5403 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
5404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5405 if (!SWIG_IsOK(res1)) {
5406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5408 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5409 result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector<Hex::Hexa * > const *)arg1);
5410 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5417 SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *resultobj = 0;
5419 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5420 std::vector<Hex::Hexa * >::value_type result;
5423 PyObject * obj0 = 0 ;
5425 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
5426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5427 if (!SWIG_IsOK(res1)) {
5428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5430 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5432 result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
5434 catch(std::out_of_range &_e) {
5435 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
5445 SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446 PyObject *resultobj = 0;
5447 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5448 std::vector<Hex::Hexa * >::difference_type arg2 ;
5449 std::vector<Hex::Hexa * >::difference_type arg3 ;
5450 std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *result = 0 ;
5457 PyObject * obj0 = 0 ;
5458 PyObject * obj1 = 0 ;
5459 PyObject * obj2 = 0 ;
5461 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
5462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5463 if (!SWIG_IsOK(res1)) {
5464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5466 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5467 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5468 if (!SWIG_IsOK(ecode2)) {
5469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5471 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5472 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5473 if (!SWIG_IsOK(ecode3)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5476 arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5478 result = (std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
5480 catch(std::out_of_range &_e) {
5481 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_OWN | 0 );
5491 SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5492 PyObject *resultobj = 0;
5493 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5494 std::vector<Hex::Hexa * >::difference_type arg2 ;
5495 std::vector<Hex::Hexa * >::difference_type arg3 ;
5496 std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *arg4 = 0 ;
5503 int res4 = SWIG_OLDOBJ ;
5504 PyObject * obj0 = 0 ;
5505 PyObject * obj1 = 0 ;
5506 PyObject * obj2 = 0 ;
5507 PyObject * obj3 = 0 ;
5509 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5511 if (!SWIG_IsOK(res1)) {
5512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5514 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5515 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5516 if (!SWIG_IsOK(ecode2)) {
5517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5519 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5520 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5521 if (!SWIG_IsOK(ecode3)) {
5522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5524 arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5526 std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
5527 res4 = swig::asptr(obj3, &ptr);
5528 if (!SWIG_IsOK(res4)) {
5529 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &""'");
5532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &""'");
5537 std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &)*arg4);
5539 catch(std::out_of_range &_e) {
5540 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5542 catch(std::invalid_argument &_e) {
5543 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
5546 resultobj = SWIG_Py_Void();
5547 if (SWIG_IsNewObj(res4)) delete arg4;
5550 if (SWIG_IsNewObj(res4)) delete arg4;
5555 SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5558 std::vector<Hex::Hexa * >::difference_type arg2 ;
5559 std::vector<Hex::Hexa * >::difference_type arg3 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 PyObject * obj2 = 0 ;
5570 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
5571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5572 if (!SWIG_IsOK(res1)) {
5573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5575 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5576 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5577 if (!SWIG_IsOK(ecode2)) {
5578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5580 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5581 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5582 if (!SWIG_IsOK(ecode3)) {
5583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5585 arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5587 std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
5589 catch(std::out_of_range &_e) {
5590 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5593 resultobj = SWIG_Py_Void();
5600 SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5603 std::vector<Hex::Hexa * >::difference_type arg2 ;
5608 PyObject * obj0 = 0 ;
5609 PyObject * obj1 = 0 ;
5611 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
5612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5613 if (!SWIG_IsOK(res1)) {
5614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5616 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5617 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5618 if (!SWIG_IsOK(ecode2)) {
5619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5621 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5623 std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(arg1,arg2);
5625 catch(std::out_of_range &_e) {
5626 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5629 resultobj = SWIG_Py_Void();
5636 SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5637 PyObject *resultobj = 0;
5638 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5639 std::vector<Hex::Hexa * >::difference_type arg2 ;
5640 std::vector<Hex::Hexa * >::value_type result;
5645 PyObject * obj0 = 0 ;
5646 PyObject * obj1 = 0 ;
5648 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
5649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5650 if (!SWIG_IsOK(res1)) {
5651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5653 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5654 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5655 if (!SWIG_IsOK(ecode2)) {
5656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5658 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5660 result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(arg1,arg2);
5662 catch(std::out_of_range &_e) {
5663 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
5673 SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5674 PyObject *resultobj = 0;
5675 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5676 std::vector<Hex::Hexa * >::difference_type arg2 ;
5677 std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 PyObject * obj2 = 0 ;
5688 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
5689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5690 if (!SWIG_IsOK(res1)) {
5691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5693 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5694 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5695 if (!SWIG_IsOK(ecode2)) {
5696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5698 arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5699 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
5700 if (!SWIG_IsOK(res3)) {
5701 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
5703 arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
5705 std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(arg1,arg2,arg3);
5707 catch(std::out_of_range &_e) {
5708 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5711 resultobj = SWIG_Py_Void();
5718 SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719 PyObject *resultobj = 0;
5720 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5721 std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
5726 PyObject * obj0 = 0 ;
5727 PyObject * obj1 = 0 ;
5729 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
5730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5734 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
5736 if (!SWIG_IsOK(res2)) {
5737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
5739 arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
5740 std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
5741 resultobj = SWIG_Py_Void();
5748 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5749 PyObject *resultobj = 0;
5750 std::vector<Hex::Hexa * > *result = 0 ;
5752 if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
5753 result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >();
5754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
5761 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5762 PyObject *resultobj = 0;
5763 std::vector<Hex::Hexa * > *arg1 = 0 ;
5764 std::vector<Hex::Hexa * > *result = 0 ;
5765 int res1 = SWIG_OLDOBJ ;
5766 PyObject * obj0 = 0 ;
5768 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
5770 std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
5771 res1 = swig::asptr(obj0, &ptr);
5772 if (!SWIG_IsOK(res1)) {
5773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
5776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
5780 result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >((std::vector<Hex::Hexa * > const &)*arg1);
5781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
5782 if (SWIG_IsNewObj(res1)) delete arg1;
5785 if (SWIG_IsNewObj(res1)) delete arg1;
5790 SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791 PyObject *resultobj = 0;
5792 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5796 PyObject * obj0 = 0 ;
5798 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
5799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5800 if (!SWIG_IsOK(res1)) {
5801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5803 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5804 result = (bool)((std::vector<Hex::Hexa * > const *)arg1)->empty();
5805 resultobj = SWIG_From_bool(static_cast< bool >(result));
5812 SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813 PyObject *resultobj = 0;
5814 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5815 std::vector<Hex::Hexa * >::size_type result;
5818 PyObject * obj0 = 0 ;
5820 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
5821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5822 if (!SWIG_IsOK(res1)) {
5823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5825 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5826 result = ((std::vector<Hex::Hexa * > const *)arg1)->size();
5827 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5834 SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5835 PyObject *resultobj = 0;
5836 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5839 PyObject * obj0 = 0 ;
5841 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
5842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5846 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5848 resultobj = SWIG_Py_Void();
5855 SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5856 PyObject *resultobj = 0;
5857 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5858 std::vector<Hex::Hexa * > *arg2 = 0 ;
5863 PyObject * obj0 = 0 ;
5864 PyObject * obj1 = 0 ;
5866 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
5867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5868 if (!SWIG_IsOK(res1)) {
5869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5871 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 );
5873 if (!SWIG_IsOK(res2)) {
5874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
5877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
5879 arg2 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp2);
5880 (arg1)->swap(*arg2);
5881 resultobj = SWIG_Py_Void();
5888 SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889 PyObject *resultobj = 0;
5890 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5891 SwigValueWrapper<std::allocator<Hex::Hexa * > > result;
5894 PyObject * obj0 = 0 ;
5896 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
5897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5898 if (!SWIG_IsOK(res1)) {
5899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5901 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5902 result = ((std::vector<Hex::Hexa * > const *)arg1)->get_allocator();
5903 resultobj = SWIG_NewPointerObj((new std::vector<Hex::Hexa * >::allocator_type(static_cast< const std::vector<Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
5910 SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5911 PyObject *resultobj = 0;
5912 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5913 std::vector<Hex::Hexa * >::iterator result;
5916 PyObject * obj0 = 0 ;
5918 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
5919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5920 if (!SWIG_IsOK(res1)) {
5921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5923 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5924 result = (arg1)->begin();
5925 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
5926 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
5933 SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5934 PyObject *resultobj = 0;
5935 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5936 std::vector<Hex::Hexa * >::const_iterator result;
5939 PyObject * obj0 = 0 ;
5941 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5946 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5947 result = ((std::vector<Hex::Hexa * > const *)arg1)->begin();
5948 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
5949 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
5956 SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *self, PyObject *args) {
5961 if (!PyTuple_Check(args)) SWIG_fail;
5962 argc = PyObject_Length(args);
5963 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
5964 argv[ii] = PyTuple_GET_ITEM(args,ii);
5968 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
5969 _v = SWIG_CheckState(res);
5971 return _wrap_VectorHexas_begin__SWIG_0(self, args);
5976 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
5977 _v = SWIG_CheckState(res);
5979 return _wrap_VectorHexas_begin__SWIG_1(self, args);
5984 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
5989 SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 PyObject *resultobj = 0;
5991 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5992 std::vector<Hex::Hexa * >::iterator result;
5995 PyObject * obj0 = 0 ;
5997 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
5998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
5999 if (!SWIG_IsOK(res1)) {
6000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6002 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6003 result = (arg1)->end();
6004 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6005 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6012 SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6013 PyObject *resultobj = 0;
6014 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6015 std::vector<Hex::Hexa * >::const_iterator result;
6018 PyObject * obj0 = 0 ;
6020 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
6021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6022 if (!SWIG_IsOK(res1)) {
6023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6025 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6026 result = ((std::vector<Hex::Hexa * > const *)arg1)->end();
6027 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
6028 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6035 SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *self, PyObject *args) {
6040 if (!PyTuple_Check(args)) SWIG_fail;
6041 argc = PyObject_Length(args);
6042 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6043 argv[ii] = PyTuple_GET_ITEM(args,ii);
6047 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6048 _v = SWIG_CheckState(res);
6050 return _wrap_VectorHexas_end__SWIG_0(self, args);
6055 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6056 _v = SWIG_CheckState(res);
6058 return _wrap_VectorHexas_end__SWIG_1(self, args);
6063 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
6068 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6069 PyObject *resultobj = 0;
6070 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6071 std::vector<Hex::Hexa * >::reverse_iterator result;
6074 PyObject * obj0 = 0 ;
6076 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
6077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6078 if (!SWIG_IsOK(res1)) {
6079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6081 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6082 result = (arg1)->rbegin();
6083 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
6084 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6091 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6092 PyObject *resultobj = 0;
6093 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6094 std::vector<Hex::Hexa * >::const_reverse_iterator result;
6097 PyObject * obj0 = 0 ;
6099 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
6100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6101 if (!SWIG_IsOK(res1)) {
6102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6104 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6105 result = ((std::vector<Hex::Hexa * > const *)arg1)->rbegin();
6106 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
6107 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6114 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *self, PyObject *args) {
6119 if (!PyTuple_Check(args)) SWIG_fail;
6120 argc = PyObject_Length(args);
6121 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6122 argv[ii] = PyTuple_GET_ITEM(args,ii);
6126 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6127 _v = SWIG_CheckState(res);
6129 return _wrap_VectorHexas_rbegin__SWIG_0(self, args);
6134 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6135 _v = SWIG_CheckState(res);
6137 return _wrap_VectorHexas_rbegin__SWIG_1(self, args);
6142 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
6147 SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6148 PyObject *resultobj = 0;
6149 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6150 std::vector<Hex::Hexa * >::reverse_iterator result;
6153 PyObject * obj0 = 0 ;
6155 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
6156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6157 if (!SWIG_IsOK(res1)) {
6158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6160 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6161 result = (arg1)->rend();
6162 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
6163 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6170 SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *resultobj = 0;
6172 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6173 std::vector<Hex::Hexa * >::const_reverse_iterator result;
6176 PyObject * obj0 = 0 ;
6178 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
6179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6180 if (!SWIG_IsOK(res1)) {
6181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6183 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6184 result = ((std::vector<Hex::Hexa * > const *)arg1)->rend();
6185 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
6186 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6193 SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *self, PyObject *args) {
6198 if (!PyTuple_Check(args)) SWIG_fail;
6199 argc = PyObject_Length(args);
6200 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6201 argv[ii] = PyTuple_GET_ITEM(args,ii);
6205 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6206 _v = SWIG_CheckState(res);
6208 return _wrap_VectorHexas_rend__SWIG_0(self, args);
6213 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6214 _v = SWIG_CheckState(res);
6216 return _wrap_VectorHexas_rend__SWIG_1(self, args);
6221 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
6226 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6227 PyObject *resultobj = 0;
6228 std::vector<Hex::Hexa * >::size_type arg1 ;
6229 std::vector<Hex::Hexa * > *result = 0 ;
6232 PyObject * obj0 = 0 ;
6234 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
6235 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6236 if (!SWIG_IsOK(ecode1)) {
6237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6239 arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
6240 result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1);
6241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
6248 SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6249 PyObject *resultobj = 0;
6250 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6253 PyObject * obj0 = 0 ;
6255 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
6256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6257 if (!SWIG_IsOK(res1)) {
6258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6260 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6262 resultobj = SWIG_Py_Void();
6269 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6270 PyObject *resultobj = 0;
6271 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6272 std::vector<Hex::Hexa * >::size_type arg2 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6280 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
6281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6282 if (!SWIG_IsOK(res1)) {
6283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6285 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6286 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6287 if (!SWIG_IsOK(ecode2)) {
6288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6290 arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6291 (arg1)->resize(arg2);
6292 resultobj = SWIG_Py_Void();
6299 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6300 PyObject *resultobj = 0;
6301 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6302 std::vector<Hex::Hexa * >::iterator arg2 ;
6303 std::vector<Hex::Hexa * >::iterator result;
6306 swig::PySwigIterator *iter2 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6311 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
6312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6313 if (!SWIG_IsOK(res1)) {
6314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6316 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6317 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6318 if (!SWIG_IsOK(res2) || !iter2) {
6319 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6321 swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6323 arg2 = iter_t->get_current();
6325 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6328 result = (arg1)->erase(arg2);
6329 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6330 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6337 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6338 PyObject *resultobj = 0;
6339 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6340 std::vector<Hex::Hexa * >::iterator arg2 ;
6341 std::vector<Hex::Hexa * >::iterator arg3 ;
6342 std::vector<Hex::Hexa * >::iterator result;
6345 swig::PySwigIterator *iter2 = 0 ;
6347 swig::PySwigIterator *iter3 = 0 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 PyObject * obj2 = 0 ;
6353 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
6354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6358 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6359 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6360 if (!SWIG_IsOK(res2) || !iter2) {
6361 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6363 swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6365 arg2 = iter_t->get_current();
6367 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6370 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
6371 if (!SWIG_IsOK(res3) || !iter3) {
6372 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6374 swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter3);
6376 arg3 = iter_t->get_current();
6378 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6381 result = (arg1)->erase(arg2,arg3);
6382 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6383 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6390 SWIGINTERN PyObject *_wrap_VectorHexas_erase(PyObject *self, PyObject *args) {
6395 if (!PyTuple_Check(args)) SWIG_fail;
6396 argc = PyObject_Length(args);
6397 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6398 argv[ii] = PyTuple_GET_ITEM(args,ii);
6402 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6403 _v = SWIG_CheckState(res);
6405 swig::PySwigIterator *iter = 0;
6406 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6407 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6409 return _wrap_VectorHexas_erase__SWIG_0(self, args);
6415 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6416 _v = SWIG_CheckState(res);
6418 swig::PySwigIterator *iter = 0;
6419 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6420 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6422 swig::PySwigIterator *iter = 0;
6423 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6424 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6426 return _wrap_VectorHexas_erase__SWIG_1(self, args);
6433 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Hexa * >::iterator)\n erase(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::iterator)\n");
6438 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6439 PyObject *resultobj = 0;
6440 std::vector<Hex::Hexa * >::size_type arg1 ;
6441 std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6442 std::vector<Hex::Hexa * > *result = 0 ;
6447 PyObject * obj0 = 0 ;
6448 PyObject * obj1 = 0 ;
6450 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
6451 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6452 if (!SWIG_IsOK(ecode1)) {
6453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6455 arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
6456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6457 if (!SWIG_IsOK(res2)) {
6458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6460 arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
6461 result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1,arg2);
6462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
6469 SWIGINTERN PyObject *_wrap_new_VectorHexas(PyObject *self, PyObject *args) {
6474 if (!PyTuple_Check(args)) SWIG_fail;
6475 argc = PyObject_Length(args);
6476 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6477 argv[ii] = PyTuple_GET_ITEM(args,ii);
6480 return _wrap_new_VectorHexas__SWIG_0(self, args);
6485 int res = SWIG_AsVal_size_t(argv[0], NULL);
6486 _v = SWIG_CheckState(res);
6489 return _wrap_new_VectorHexas__SWIG_2(self, args);
6494 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6495 _v = SWIG_CheckState(res);
6497 return _wrap_new_VectorHexas__SWIG_1(self, args);
6503 int res = SWIG_AsVal_size_t(argv[0], NULL);
6504 _v = SWIG_CheckState(res);
6508 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6509 _v = SWIG_CheckState(res);
6511 return _wrap_new_VectorHexas__SWIG_3(self, args);
6517 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorHexas'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Hexa)>()\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * > const &)\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type)\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6522 SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 PyObject *resultobj = 0;
6524 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6525 std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6530 PyObject * obj0 = 0 ;
6531 PyObject * obj1 = 0 ;
6533 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
6534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6535 if (!SWIG_IsOK(res1)) {
6536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6538 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6540 if (!SWIG_IsOK(res2)) {
6541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6543 arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
6544 (arg1)->push_back(arg2);
6545 resultobj = SWIG_Py_Void();
6552 SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553 PyObject *resultobj = 0;
6554 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6555 std::vector<Hex::Hexa * >::value_type result;
6558 PyObject * obj0 = 0 ;
6560 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
6561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6562 if (!SWIG_IsOK(res1)) {
6563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6565 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6566 result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->front();
6567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6574 SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6577 std::vector<Hex::Hexa * >::value_type result;
6580 PyObject * obj0 = 0 ;
6582 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6587 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6588 result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->back();
6589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6596 SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6597 PyObject *resultobj = 0;
6598 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6599 std::vector<Hex::Hexa * >::size_type arg2 ;
6600 std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 PyObject * obj2 = 0 ;
6611 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
6612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6616 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6617 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6618 if (!SWIG_IsOK(ecode2)) {
6619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6621 arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6622 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6623 if (!SWIG_IsOK(res3)) {
6624 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6626 arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6627 (arg1)->assign(arg2,arg3);
6628 resultobj = SWIG_Py_Void();
6635 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6638 std::vector<Hex::Hexa * >::size_type arg2 ;
6639 std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6646 PyObject * obj0 = 0 ;
6647 PyObject * obj1 = 0 ;
6648 PyObject * obj2 = 0 ;
6650 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
6651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6652 if (!SWIG_IsOK(res1)) {
6653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6655 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6656 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6657 if (!SWIG_IsOK(ecode2)) {
6658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6660 arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6661 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6662 if (!SWIG_IsOK(res3)) {
6663 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6665 arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6666 (arg1)->resize(arg2,arg3);
6667 resultobj = SWIG_Py_Void();
6674 SWIGINTERN PyObject *_wrap_VectorHexas_resize(PyObject *self, PyObject *args) {
6679 if (!PyTuple_Check(args)) SWIG_fail;
6680 argc = PyObject_Length(args);
6681 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6682 argv[ii] = PyTuple_GET_ITEM(args,ii);
6686 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6687 _v = SWIG_CheckState(res);
6690 int res = SWIG_AsVal_size_t(argv[1], NULL);
6691 _v = SWIG_CheckState(res);
6694 return _wrap_VectorHexas_resize__SWIG_0(self, args);
6700 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6701 _v = SWIG_CheckState(res);
6704 int res = SWIG_AsVal_size_t(argv[1], NULL);
6705 _v = SWIG_CheckState(res);
6709 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6710 _v = SWIG_CheckState(res);
6712 return _wrap_VectorHexas_resize__SWIG_1(self, args);
6719 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Hexa * >::size_type)\n resize(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6724 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6725 PyObject *resultobj = 0;
6726 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6727 std::vector<Hex::Hexa * >::iterator arg2 ;
6728 std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6729 std::vector<Hex::Hexa * >::iterator result;
6732 swig::PySwigIterator *iter2 = 0 ;
6736 PyObject * obj0 = 0 ;
6737 PyObject * obj1 = 0 ;
6738 PyObject * obj2 = 0 ;
6740 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6745 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6746 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6747 if (!SWIG_IsOK(res2) || !iter2) {
6748 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6750 swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6752 arg2 = iter_t->get_current();
6754 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6757 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6758 if (!SWIG_IsOK(res3)) {
6759 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6761 arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6762 result = (arg1)->insert(arg2,arg3);
6763 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6764 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6771 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772 PyObject *resultobj = 0;
6773 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6774 std::vector<Hex::Hexa * >::iterator arg2 ;
6775 std::vector<Hex::Hexa * >::size_type arg3 ;
6776 std::vector<Hex::Hexa * >::value_type arg4 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6779 swig::PySwigIterator *iter2 = 0 ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 PyObject * obj2 = 0 ;
6788 PyObject * obj3 = 0 ;
6790 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6792 if (!SWIG_IsOK(res1)) {
6793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6795 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6796 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6797 if (!SWIG_IsOK(res2) || !iter2) {
6798 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6800 swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6802 arg2 = iter_t->get_current();
6804 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6807 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
6808 if (!SWIG_IsOK(ecode3)) {
6809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6811 arg3 = static_cast< std::vector<Hex::Hexa * >::size_type >(val3);
6812 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
6813 if (!SWIG_IsOK(res4)) {
6814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6816 arg4 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp4);
6817 (arg1)->insert(arg2,arg3,arg4);
6818 resultobj = SWIG_Py_Void();
6825 SWIGINTERN PyObject *_wrap_VectorHexas_insert(PyObject *self, PyObject *args) {
6830 if (!PyTuple_Check(args)) SWIG_fail;
6831 argc = PyObject_Length(args);
6832 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
6833 argv[ii] = PyTuple_GET_ITEM(args,ii);
6837 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6838 _v = SWIG_CheckState(res);
6840 swig::PySwigIterator *iter = 0;
6841 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6842 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6845 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6846 _v = SWIG_CheckState(res);
6848 return _wrap_VectorHexas_insert__SWIG_0(self, args);
6855 int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6856 _v = SWIG_CheckState(res);
6858 swig::PySwigIterator *iter = 0;
6859 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6860 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6863 int res = SWIG_AsVal_size_t(argv[2], NULL);
6864 _v = SWIG_CheckState(res);
6868 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6869 _v = SWIG_CheckState(res);
6871 return _wrap_VectorHexas_insert__SWIG_1(self, args);
6879 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::value_type)\n insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6884 SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6887 std::vector<Hex::Hexa * >::size_type arg2 ;
6892 PyObject * obj0 = 0 ;
6893 PyObject * obj1 = 0 ;
6895 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
6896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6897 if (!SWIG_IsOK(res1)) {
6898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6900 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6901 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6902 if (!SWIG_IsOK(ecode2)) {
6903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6905 arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6906 (arg1)->reserve(arg2);
6907 resultobj = SWIG_Py_Void();
6914 SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6915 PyObject *resultobj = 0;
6916 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6917 std::vector<Hex::Hexa * >::size_type result;
6920 PyObject * obj0 = 0 ;
6922 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
6923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
6924 if (!SWIG_IsOK(res1)) {
6925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6927 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6928 result = ((std::vector<Hex::Hexa * > const *)arg1)->capacity();
6929 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6936 SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937 PyObject *resultobj = 0;
6938 std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6941 PyObject * obj0 = 0 ;
6943 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_DISOWN | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6948 arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6951 resultobj = SWIG_Py_Void();
6958 SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6960 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
6961 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_NewClientData(obj));
6962 return SWIG_Py_Void();
6965 SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6966 PyObject *resultobj = 0;
6967 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
6968 PyObject **arg2 = (PyObject **) 0 ;
6969 swig::PySwigIterator *result = 0 ;
6972 PyObject * obj0 = 0 ;
6975 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
6976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
6977 if (!SWIG_IsOK(res1)) {
6978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
6980 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
6981 result = (swig::PySwigIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
6982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
6989 SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
6995 PyObject * obj0 = 0 ;
6997 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
6998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7002 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7003 result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector<Hex::Quad * > const *)arg1);
7004 resultobj = SWIG_From_bool(static_cast< bool >(result));
7011 SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7012 PyObject *resultobj = 0;
7013 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7014 std::vector<Hex::Quad * >::size_type result;
7017 PyObject * obj0 = 0 ;
7019 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
7020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7021 if (!SWIG_IsOK(res1)) {
7022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7024 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7025 result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector<Hex::Quad * > const *)arg1);
7026 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7033 SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7034 PyObject *resultobj = 0;
7035 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7036 std::vector<Hex::Quad * >::value_type result;
7039 PyObject * obj0 = 0 ;
7041 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
7042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7043 if (!SWIG_IsOK(res1)) {
7044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7046 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7048 result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
7050 catch(std::out_of_range &_e) {
7051 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
7061 SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7064 std::vector<Hex::Quad * >::difference_type arg2 ;
7065 std::vector<Hex::Quad * >::difference_type arg3 ;
7066 std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *result = 0 ;
7073 PyObject * obj0 = 0 ;
7074 PyObject * obj1 = 0 ;
7075 PyObject * obj2 = 0 ;
7077 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7079 if (!SWIG_IsOK(res1)) {
7080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7082 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7083 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7084 if (!SWIG_IsOK(ecode2)) {
7085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7087 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7088 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7089 if (!SWIG_IsOK(ecode3)) {
7090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7092 arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7094 result = (std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
7096 catch(std::out_of_range &_e) {
7097 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_OWN | 0 );
7107 SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7108 PyObject *resultobj = 0;
7109 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7110 std::vector<Hex::Quad * >::difference_type arg2 ;
7111 std::vector<Hex::Quad * >::difference_type arg3 ;
7112 std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *arg4 = 0 ;
7119 int res4 = SWIG_OLDOBJ ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 PyObject * obj2 = 0 ;
7123 PyObject * obj3 = 0 ;
7125 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7127 if (!SWIG_IsOK(res1)) {
7128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7130 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7131 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7132 if (!SWIG_IsOK(ecode2)) {
7133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7135 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7136 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7137 if (!SWIG_IsOK(ecode3)) {
7138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7140 arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7142 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
7143 res4 = swig::asptr(obj3, &ptr);
7144 if (!SWIG_IsOK(res4)) {
7145 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &""'");
7148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &""'");
7153 std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &)*arg4);
7155 catch(std::out_of_range &_e) {
7156 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7158 catch(std::invalid_argument &_e) {
7159 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7162 resultobj = SWIG_Py_Void();
7163 if (SWIG_IsNewObj(res4)) delete arg4;
7166 if (SWIG_IsNewObj(res4)) delete arg4;
7171 SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7172 PyObject *resultobj = 0;
7173 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7174 std::vector<Hex::Quad * >::difference_type arg2 ;
7175 std::vector<Hex::Quad * >::difference_type arg3 ;
7182 PyObject * obj0 = 0 ;
7183 PyObject * obj1 = 0 ;
7184 PyObject * obj2 = 0 ;
7186 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7188 if (!SWIG_IsOK(res1)) {
7189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7191 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7192 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7193 if (!SWIG_IsOK(ecode2)) {
7194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7196 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7197 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7198 if (!SWIG_IsOK(ecode3)) {
7199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7201 arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7203 std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
7205 catch(std::out_of_range &_e) {
7206 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7209 resultobj = SWIG_Py_Void();
7216 SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7217 PyObject *resultobj = 0;
7218 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7219 std::vector<Hex::Quad * >::difference_type arg2 ;
7224 PyObject * obj0 = 0 ;
7225 PyObject * obj1 = 0 ;
7227 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
7228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7229 if (!SWIG_IsOK(res1)) {
7230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7232 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7233 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7234 if (!SWIG_IsOK(ecode2)) {
7235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7237 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7239 std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(arg1,arg2);
7241 catch(std::out_of_range &_e) {
7242 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7245 resultobj = SWIG_Py_Void();
7252 SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253 PyObject *resultobj = 0;
7254 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7255 std::vector<Hex::Quad * >::difference_type arg2 ;
7256 std::vector<Hex::Quad * >::value_type result;
7261 PyObject * obj0 = 0 ;
7262 PyObject * obj1 = 0 ;
7264 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
7265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7266 if (!SWIG_IsOK(res1)) {
7267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7269 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7270 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7271 if (!SWIG_IsOK(ecode2)) {
7272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7274 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7276 result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(arg1,arg2);
7278 catch(std::out_of_range &_e) {
7279 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
7289 SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7290 PyObject *resultobj = 0;
7291 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7292 std::vector<Hex::Quad * >::difference_type arg2 ;
7293 std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
7300 PyObject * obj0 = 0 ;
7301 PyObject * obj1 = 0 ;
7302 PyObject * obj2 = 0 ;
7304 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7306 if (!SWIG_IsOK(res1)) {
7307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7309 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7310 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7311 if (!SWIG_IsOK(ecode2)) {
7312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7314 arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7315 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
7316 if (!SWIG_IsOK(res3)) {
7317 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
7319 arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
7321 std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(arg1,arg2,arg3);
7323 catch(std::out_of_range &_e) {
7324 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7327 resultobj = SWIG_Py_Void();
7334 SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7335 PyObject *resultobj = 0;
7336 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7337 std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7345 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7350 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
7352 if (!SWIG_IsOK(res2)) {
7353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
7355 arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
7356 std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
7357 resultobj = SWIG_Py_Void();
7364 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7365 PyObject *resultobj = 0;
7366 std::vector<Hex::Quad * > *result = 0 ;
7368 if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
7369 result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >();
7370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
7377 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7378 PyObject *resultobj = 0;
7379 std::vector<Hex::Quad * > *arg1 = 0 ;
7380 std::vector<Hex::Quad * > *result = 0 ;
7381 int res1 = SWIG_OLDOBJ ;
7382 PyObject * obj0 = 0 ;
7384 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
7386 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
7387 res1 = swig::asptr(obj0, &ptr);
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
7392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
7396 result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >((std::vector<Hex::Quad * > const &)*arg1);
7397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
7398 if (SWIG_IsNewObj(res1)) delete arg1;
7401 if (SWIG_IsNewObj(res1)) delete arg1;
7406 SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7412 PyObject * obj0 = 0 ;
7414 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
7415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7416 if (!SWIG_IsOK(res1)) {
7417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7419 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7420 result = (bool)((std::vector<Hex::Quad * > const *)arg1)->empty();
7421 resultobj = SWIG_From_bool(static_cast< bool >(result));
7428 SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7429 PyObject *resultobj = 0;
7430 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7431 std::vector<Hex::Quad * >::size_type result;
7434 PyObject * obj0 = 0 ;
7436 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7441 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7442 result = ((std::vector<Hex::Quad * > const *)arg1)->size();
7443 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7450 SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7451 PyObject *resultobj = 0;
7452 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7455 PyObject * obj0 = 0 ;
7457 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
7458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7459 if (!SWIG_IsOK(res1)) {
7460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7462 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7464 resultobj = SWIG_Py_Void();
7471 SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7472 PyObject *resultobj = 0;
7473 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7474 std::vector<Hex::Quad * > *arg2 = 0 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7482 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7487 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7488 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 );
7489 if (!SWIG_IsOK(res2)) {
7490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
7493 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
7495 arg2 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp2);
7496 (arg1)->swap(*arg2);
7497 resultobj = SWIG_Py_Void();
7504 SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7505 PyObject *resultobj = 0;
7506 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7507 SwigValueWrapper<std::allocator<Hex::Quad * > > result;
7510 PyObject * obj0 = 0 ;
7512 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7517 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7518 result = ((std::vector<Hex::Quad * > const *)arg1)->get_allocator();
7519 resultobj = SWIG_NewPointerObj((new std::vector<Hex::Quad * >::allocator_type(static_cast< const std::vector<Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
7526 SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527 PyObject *resultobj = 0;
7528 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7529 std::vector<Hex::Quad * >::iterator result;
7532 PyObject * obj0 = 0 ;
7534 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
7535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7539 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7540 result = (arg1)->begin();
7541 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7542 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7549 SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7550 PyObject *resultobj = 0;
7551 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7552 std::vector<Hex::Quad * >::const_iterator result;
7555 PyObject * obj0 = 0 ;
7557 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7562 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7563 result = ((std::vector<Hex::Quad * > const *)arg1)->begin();
7564 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
7565 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7572 SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *self, PyObject *args) {
7577 if (!PyTuple_Check(args)) SWIG_fail;
7578 argc = PyObject_Length(args);
7579 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7580 argv[ii] = PyTuple_GET_ITEM(args,ii);
7584 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7585 _v = SWIG_CheckState(res);
7587 return _wrap_VectorQuads_begin__SWIG_0(self, args);
7592 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7593 _v = SWIG_CheckState(res);
7595 return _wrap_VectorQuads_begin__SWIG_1(self, args);
7600 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
7605 SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7606 PyObject *resultobj = 0;
7607 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7608 std::vector<Hex::Quad * >::iterator result;
7611 PyObject * obj0 = 0 ;
7613 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
7614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7618 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7619 result = (arg1)->end();
7620 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7621 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7628 SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7629 PyObject *resultobj = 0;
7630 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7631 std::vector<Hex::Quad * >::const_iterator result;
7634 PyObject * obj0 = 0 ;
7636 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7641 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7642 result = ((std::vector<Hex::Quad * > const *)arg1)->end();
7643 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
7644 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7651 SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *self, PyObject *args) {
7656 if (!PyTuple_Check(args)) SWIG_fail;
7657 argc = PyObject_Length(args);
7658 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7659 argv[ii] = PyTuple_GET_ITEM(args,ii);
7663 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7664 _v = SWIG_CheckState(res);
7666 return _wrap_VectorQuads_end__SWIG_0(self, args);
7671 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7672 _v = SWIG_CheckState(res);
7674 return _wrap_VectorQuads_end__SWIG_1(self, args);
7679 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
7684 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685 PyObject *resultobj = 0;
7686 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7687 std::vector<Hex::Quad * >::reverse_iterator result;
7690 PyObject * obj0 = 0 ;
7692 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
7693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7694 if (!SWIG_IsOK(res1)) {
7695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7697 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7698 result = (arg1)->rbegin();
7699 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
7700 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7707 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7708 PyObject *resultobj = 0;
7709 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7710 std::vector<Hex::Quad * >::const_reverse_iterator result;
7713 PyObject * obj0 = 0 ;
7715 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7720 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7721 result = ((std::vector<Hex::Quad * > const *)arg1)->rbegin();
7722 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
7723 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7730 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *self, PyObject *args) {
7735 if (!PyTuple_Check(args)) SWIG_fail;
7736 argc = PyObject_Length(args);
7737 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7738 argv[ii] = PyTuple_GET_ITEM(args,ii);
7742 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7743 _v = SWIG_CheckState(res);
7745 return _wrap_VectorQuads_rbegin__SWIG_0(self, args);
7750 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7751 _v = SWIG_CheckState(res);
7753 return _wrap_VectorQuads_rbegin__SWIG_1(self, args);
7758 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
7763 SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764 PyObject *resultobj = 0;
7765 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7766 std::vector<Hex::Quad * >::reverse_iterator result;
7769 PyObject * obj0 = 0 ;
7771 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7776 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7777 result = (arg1)->rend();
7778 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
7779 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7786 SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 PyObject *resultobj = 0;
7788 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7789 std::vector<Hex::Quad * >::const_reverse_iterator result;
7792 PyObject * obj0 = 0 ;
7794 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7799 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7800 result = ((std::vector<Hex::Quad * > const *)arg1)->rend();
7801 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
7802 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7809 SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *self, PyObject *args) {
7814 if (!PyTuple_Check(args)) SWIG_fail;
7815 argc = PyObject_Length(args);
7816 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7817 argv[ii] = PyTuple_GET_ITEM(args,ii);
7821 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7822 _v = SWIG_CheckState(res);
7824 return _wrap_VectorQuads_rend__SWIG_0(self, args);
7829 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7830 _v = SWIG_CheckState(res);
7832 return _wrap_VectorQuads_rend__SWIG_1(self, args);
7837 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
7842 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843 PyObject *resultobj = 0;
7844 std::vector<Hex::Quad * >::size_type arg1 ;
7845 std::vector<Hex::Quad * > *result = 0 ;
7848 PyObject * obj0 = 0 ;
7850 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
7851 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7852 if (!SWIG_IsOK(ecode1)) {
7853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
7855 arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
7856 result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1);
7857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
7864 SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7865 PyObject *resultobj = 0;
7866 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7869 PyObject * obj0 = 0 ;
7871 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
7872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7876 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7878 resultobj = SWIG_Py_Void();
7885 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7886 PyObject *resultobj = 0;
7887 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7888 std::vector<Hex::Quad * >::size_type arg2 ;
7893 PyObject * obj0 = 0 ;
7894 PyObject * obj1 = 0 ;
7896 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
7897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7901 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7902 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7903 if (!SWIG_IsOK(ecode2)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
7906 arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
7907 (arg1)->resize(arg2);
7908 resultobj = SWIG_Py_Void();
7915 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7918 std::vector<Hex::Quad * >::iterator arg2 ;
7919 std::vector<Hex::Quad * >::iterator result;
7922 swig::PySwigIterator *iter2 = 0 ;
7924 PyObject * obj0 = 0 ;
7925 PyObject * obj1 = 0 ;
7927 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
7928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7929 if (!SWIG_IsOK(res1)) {
7930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7932 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7933 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7934 if (!SWIG_IsOK(res2) || !iter2) {
7935 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7937 swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
7939 arg2 = iter_t->get_current();
7941 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7944 result = (arg1)->erase(arg2);
7945 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7946 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7953 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7954 PyObject *resultobj = 0;
7955 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7956 std::vector<Hex::Quad * >::iterator arg2 ;
7957 std::vector<Hex::Quad * >::iterator arg3 ;
7958 std::vector<Hex::Quad * >::iterator result;
7961 swig::PySwigIterator *iter2 = 0 ;
7963 swig::PySwigIterator *iter3 = 0 ;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 PyObject * obj2 = 0 ;
7969 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
7970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
7971 if (!SWIG_IsOK(res1)) {
7972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7974 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7975 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7976 if (!SWIG_IsOK(res2) || !iter2) {
7977 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7979 swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
7981 arg2 = iter_t->get_current();
7983 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7986 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
7987 if (!SWIG_IsOK(res3) || !iter3) {
7988 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7990 swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter3);
7992 arg3 = iter_t->get_current();
7994 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7997 result = (arg1)->erase(arg2,arg3);
7998 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7999 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8006 SWIGINTERN PyObject *_wrap_VectorQuads_erase(PyObject *self, PyObject *args) {
8011 if (!PyTuple_Check(args)) SWIG_fail;
8012 argc = PyObject_Length(args);
8013 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8014 argv[ii] = PyTuple_GET_ITEM(args,ii);
8018 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8019 _v = SWIG_CheckState(res);
8021 swig::PySwigIterator *iter = 0;
8022 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8023 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8025 return _wrap_VectorQuads_erase__SWIG_0(self, args);
8031 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8032 _v = SWIG_CheckState(res);
8034 swig::PySwigIterator *iter = 0;
8035 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8036 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8038 swig::PySwigIterator *iter = 0;
8039 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8040 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8042 return _wrap_VectorQuads_erase__SWIG_1(self, args);
8049 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Quad * >::iterator)\n erase(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::iterator)\n");
8054 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 std::vector<Hex::Quad * >::size_type arg1 ;
8057 std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
8058 std::vector<Hex::Quad * > *result = 0 ;
8063 PyObject * obj0 = 0 ;
8064 PyObject * obj1 = 0 ;
8066 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
8067 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8068 if (!SWIG_IsOK(ecode1)) {
8069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8071 arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
8072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8073 if (!SWIG_IsOK(res2)) {
8074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8076 arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
8077 result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1,arg2);
8078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
8085 SWIGINTERN PyObject *_wrap_new_VectorQuads(PyObject *self, PyObject *args) {
8090 if (!PyTuple_Check(args)) SWIG_fail;
8091 argc = PyObject_Length(args);
8092 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8093 argv[ii] = PyTuple_GET_ITEM(args,ii);
8096 return _wrap_new_VectorQuads__SWIG_0(self, args);
8101 int res = SWIG_AsVal_size_t(argv[0], NULL);
8102 _v = SWIG_CheckState(res);
8105 return _wrap_new_VectorQuads__SWIG_2(self, args);
8110 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8111 _v = SWIG_CheckState(res);
8113 return _wrap_new_VectorQuads__SWIG_1(self, args);
8119 int res = SWIG_AsVal_size_t(argv[0], NULL);
8120 _v = SWIG_CheckState(res);
8124 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8125 _v = SWIG_CheckState(res);
8127 return _wrap_new_VectorQuads__SWIG_3(self, args);
8133 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorQuads'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Quad)>()\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * > const &)\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type)\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8138 SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139 PyObject *resultobj = 0;
8140 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8141 std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
8146 PyObject * obj0 = 0 ;
8147 PyObject * obj1 = 0 ;
8149 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
8150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8151 if (!SWIG_IsOK(res1)) {
8152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8154 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8156 if (!SWIG_IsOK(res2)) {
8157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8159 arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
8160 (arg1)->push_back(arg2);
8161 resultobj = SWIG_Py_Void();
8168 SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169 PyObject *resultobj = 0;
8170 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8171 std::vector<Hex::Quad * >::value_type result;
8174 PyObject * obj0 = 0 ;
8176 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
8177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8181 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8182 result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->front();
8183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8190 SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8191 PyObject *resultobj = 0;
8192 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8193 std::vector<Hex::Quad * >::value_type result;
8196 PyObject * obj0 = 0 ;
8198 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
8199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8200 if (!SWIG_IsOK(res1)) {
8201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8203 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8204 result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->back();
8205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8212 SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8213 PyObject *resultobj = 0;
8214 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8215 std::vector<Hex::Quad * >::size_type arg2 ;
8216 std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8223 PyObject * obj0 = 0 ;
8224 PyObject * obj1 = 0 ;
8225 PyObject * obj2 = 0 ;
8227 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8229 if (!SWIG_IsOK(res1)) {
8230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8232 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8233 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8234 if (!SWIG_IsOK(ecode2)) {
8235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8237 arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8238 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8239 if (!SWIG_IsOK(res3)) {
8240 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8242 arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8243 (arg1)->assign(arg2,arg3);
8244 resultobj = SWIG_Py_Void();
8251 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252 PyObject *resultobj = 0;
8253 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8254 std::vector<Hex::Quad * >::size_type arg2 ;
8255 std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 PyObject * obj2 = 0 ;
8266 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8268 if (!SWIG_IsOK(res1)) {
8269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8271 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8272 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8273 if (!SWIG_IsOK(ecode2)) {
8274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8276 arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8277 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8278 if (!SWIG_IsOK(res3)) {
8279 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8281 arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8282 (arg1)->resize(arg2,arg3);
8283 resultobj = SWIG_Py_Void();
8290 SWIGINTERN PyObject *_wrap_VectorQuads_resize(PyObject *self, PyObject *args) {
8295 if (!PyTuple_Check(args)) SWIG_fail;
8296 argc = PyObject_Length(args);
8297 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8298 argv[ii] = PyTuple_GET_ITEM(args,ii);
8302 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8303 _v = SWIG_CheckState(res);
8306 int res = SWIG_AsVal_size_t(argv[1], NULL);
8307 _v = SWIG_CheckState(res);
8310 return _wrap_VectorQuads_resize__SWIG_0(self, args);
8316 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8317 _v = SWIG_CheckState(res);
8320 int res = SWIG_AsVal_size_t(argv[1], NULL);
8321 _v = SWIG_CheckState(res);
8325 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8326 _v = SWIG_CheckState(res);
8328 return _wrap_VectorQuads_resize__SWIG_1(self, args);
8335 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Quad * >::size_type)\n resize(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8340 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8341 PyObject *resultobj = 0;
8342 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8343 std::vector<Hex::Quad * >::iterator arg2 ;
8344 std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8345 std::vector<Hex::Quad * >::iterator result;
8348 swig::PySwigIterator *iter2 = 0 ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 PyObject * obj2 = 0 ;
8356 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
8357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8358 if (!SWIG_IsOK(res1)) {
8359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8361 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8362 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8363 if (!SWIG_IsOK(res2) || !iter2) {
8364 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8366 swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
8368 arg2 = iter_t->get_current();
8370 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8373 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8374 if (!SWIG_IsOK(res3)) {
8375 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8377 arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8378 result = (arg1)->insert(arg2,arg3);
8379 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
8380 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8387 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8390 std::vector<Hex::Quad * >::iterator arg2 ;
8391 std::vector<Hex::Quad * >::size_type arg3 ;
8392 std::vector<Hex::Quad * >::value_type arg4 = (std::vector<Hex::Quad * >::value_type) 0 ;
8395 swig::PySwigIterator *iter2 = 0 ;
8401 PyObject * obj0 = 0 ;
8402 PyObject * obj1 = 0 ;
8403 PyObject * obj2 = 0 ;
8404 PyObject * obj3 = 0 ;
8406 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8408 if (!SWIG_IsOK(res1)) {
8409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8411 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8412 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8413 if (!SWIG_IsOK(res2) || !iter2) {
8414 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8416 swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
8418 arg2 = iter_t->get_current();
8420 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8423 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8424 if (!SWIG_IsOK(ecode3)) {
8425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8427 arg3 = static_cast< std::vector<Hex::Quad * >::size_type >(val3);
8428 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
8429 if (!SWIG_IsOK(res4)) {
8430 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8432 arg4 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp4);
8433 (arg1)->insert(arg2,arg3,arg4);
8434 resultobj = SWIG_Py_Void();
8441 SWIGINTERN PyObject *_wrap_VectorQuads_insert(PyObject *self, PyObject *args) {
8446 if (!PyTuple_Check(args)) SWIG_fail;
8447 argc = PyObject_Length(args);
8448 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
8449 argv[ii] = PyTuple_GET_ITEM(args,ii);
8453 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8454 _v = SWIG_CheckState(res);
8456 swig::PySwigIterator *iter = 0;
8457 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8458 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8461 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8462 _v = SWIG_CheckState(res);
8464 return _wrap_VectorQuads_insert__SWIG_0(self, args);
8471 int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8472 _v = SWIG_CheckState(res);
8474 swig::PySwigIterator *iter = 0;
8475 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8476 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8479 int res = SWIG_AsVal_size_t(argv[2], NULL);
8480 _v = SWIG_CheckState(res);
8484 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8485 _v = SWIG_CheckState(res);
8487 return _wrap_VectorQuads_insert__SWIG_1(self, args);
8495 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::value_type)\n insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8500 SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8501 PyObject *resultobj = 0;
8502 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8503 std::vector<Hex::Quad * >::size_type arg2 ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8511 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
8512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8516 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8517 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8518 if (!SWIG_IsOK(ecode2)) {
8519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8521 arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8522 (arg1)->reserve(arg2);
8523 resultobj = SWIG_Py_Void();
8530 SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8533 std::vector<Hex::Quad * >::size_type result;
8536 PyObject * obj0 = 0 ;
8538 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
8539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
8540 if (!SWIG_IsOK(res1)) {
8541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8543 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8544 result = ((std::vector<Hex::Quad * > const *)arg1)->capacity();
8545 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8552 SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8557 PyObject * obj0 = 0 ;
8559 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
8560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_DISOWN | 0 );
8561 if (!SWIG_IsOK(res1)) {
8562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8564 arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8567 resultobj = SWIG_Py_Void();
8574 SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8576 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
8577 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_NewClientData(obj));
8578 return SWIG_Py_Void();
8581 SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8582 PyObject *resultobj = 0;
8583 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8584 PyObject **arg2 = (PyObject **) 0 ;
8585 swig::PySwigIterator *result = 0 ;
8588 PyObject * obj0 = 0 ;
8591 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8596 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8597 result = (swig::PySwigIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
8598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
8605 SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8606 PyObject *resultobj = 0;
8607 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8611 PyObject * obj0 = 0 ;
8613 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
8618 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8619 result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector<Hex::Edge * > const *)arg1);
8620 resultobj = SWIG_From_bool(static_cast< bool >(result));
8627 SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8628 PyObject *resultobj = 0;
8629 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8630 std::vector<Hex::Edge * >::size_type result;
8633 PyObject * obj0 = 0 ;
8635 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
8636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8637 if (!SWIG_IsOK(res1)) {
8638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
8640 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8641 result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector<Hex::Edge * > const *)arg1);
8642 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8649 SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650 PyObject *resultobj = 0;
8651 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8652 std::vector<Hex::Edge * >::value_type result;
8655 PyObject * obj0 = 0 ;
8657 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
8658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8659 if (!SWIG_IsOK(res1)) {
8660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8662 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8664 result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
8666 catch(std::out_of_range &_e) {
8667 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
8677 SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8680 std::vector<Hex::Edge * >::difference_type arg2 ;
8681 std::vector<Hex::Edge * >::difference_type arg3 ;
8682 std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *result = 0 ;
8689 PyObject * obj0 = 0 ;
8690 PyObject * obj1 = 0 ;
8691 PyObject * obj2 = 0 ;
8693 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8698 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8699 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8700 if (!SWIG_IsOK(ecode2)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8703 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8704 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8705 if (!SWIG_IsOK(ecode3)) {
8706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8708 arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8710 result = (std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
8712 catch(std::out_of_range &_e) {
8713 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_OWN | 0 );
8723 SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8724 PyObject *resultobj = 0;
8725 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8726 std::vector<Hex::Edge * >::difference_type arg2 ;
8727 std::vector<Hex::Edge * >::difference_type arg3 ;
8728 std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *arg4 = 0 ;
8735 int res4 = SWIG_OLDOBJ ;
8736 PyObject * obj0 = 0 ;
8737 PyObject * obj1 = 0 ;
8738 PyObject * obj2 = 0 ;
8739 PyObject * obj3 = 0 ;
8741 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8746 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8747 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8751 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8752 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8753 if (!SWIG_IsOK(ecode3)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8756 arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8758 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
8759 res4 = swig::asptr(obj3, &ptr);
8760 if (!SWIG_IsOK(res4)) {
8761 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &""'");
8764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &""'");
8769 std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &)*arg4);
8771 catch(std::out_of_range &_e) {
8772 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8774 catch(std::invalid_argument &_e) {
8775 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8778 resultobj = SWIG_Py_Void();
8779 if (SWIG_IsNewObj(res4)) delete arg4;
8782 if (SWIG_IsNewObj(res4)) delete arg4;
8787 SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8788 PyObject *resultobj = 0;
8789 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8790 std::vector<Hex::Edge * >::difference_type arg2 ;
8791 std::vector<Hex::Edge * >::difference_type arg3 ;
8798 PyObject * obj0 = 0 ;
8799 PyObject * obj1 = 0 ;
8800 PyObject * obj2 = 0 ;
8802 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8807 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8808 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8809 if (!SWIG_IsOK(ecode2)) {
8810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8812 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8813 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8814 if (!SWIG_IsOK(ecode3)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8817 arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8819 std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
8821 catch(std::out_of_range &_e) {
8822 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8825 resultobj = SWIG_Py_Void();
8832 SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8833 PyObject *resultobj = 0;
8834 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8835 std::vector<Hex::Edge * >::difference_type arg2 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8843 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8848 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8849 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8850 if (!SWIG_IsOK(ecode2)) {
8851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8853 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8855 std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(arg1,arg2);
8857 catch(std::out_of_range &_e) {
8858 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8861 resultobj = SWIG_Py_Void();
8868 SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *resultobj = 0;
8870 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8871 std::vector<Hex::Edge * >::difference_type arg2 ;
8872 std::vector<Hex::Edge * >::value_type result;
8877 PyObject * obj0 = 0 ;
8878 PyObject * obj1 = 0 ;
8880 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
8881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8882 if (!SWIG_IsOK(res1)) {
8883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8885 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8886 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8887 if (!SWIG_IsOK(ecode2)) {
8888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8890 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8892 result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(arg1,arg2);
8894 catch(std::out_of_range &_e) {
8895 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
8905 SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8906 PyObject *resultobj = 0;
8907 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8908 std::vector<Hex::Edge * >::difference_type arg2 ;
8909 std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8920 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8925 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8926 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8927 if (!SWIG_IsOK(ecode2)) {
8928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8930 arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8931 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
8932 if (!SWIG_IsOK(res3)) {
8933 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
8935 arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
8937 std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(arg1,arg2,arg3);
8939 catch(std::out_of_range &_e) {
8940 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8943 resultobj = SWIG_Py_Void();
8950 SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 PyObject *resultobj = 0;
8952 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8953 std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
8958 PyObject * obj0 = 0 ;
8959 PyObject * obj1 = 0 ;
8961 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
8962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
8963 if (!SWIG_IsOK(res1)) {
8964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8966 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
8968 if (!SWIG_IsOK(res2)) {
8969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
8971 arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
8972 std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
8973 resultobj = SWIG_Py_Void();
8980 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8981 PyObject *resultobj = 0;
8982 std::vector<Hex::Edge * > *result = 0 ;
8984 if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
8985 result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >();
8986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
8993 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 std::vector<Hex::Edge * > *arg1 = 0 ;
8996 std::vector<Hex::Edge * > *result = 0 ;
8997 int res1 = SWIG_OLDOBJ ;
8998 PyObject * obj0 = 0 ;
9000 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
9002 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
9003 res1 = swig::asptr(obj0, &ptr);
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
9008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
9012 result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >((std::vector<Hex::Edge * > const &)*arg1);
9013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
9014 if (SWIG_IsNewObj(res1)) delete arg1;
9017 if (SWIG_IsNewObj(res1)) delete arg1;
9022 SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9028 PyObject * obj0 = 0 ;
9030 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
9031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9035 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9036 result = (bool)((std::vector<Hex::Edge * > const *)arg1)->empty();
9037 resultobj = SWIG_From_bool(static_cast< bool >(result));
9044 SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9047 std::vector<Hex::Edge * >::size_type result;
9050 PyObject * obj0 = 0 ;
9052 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
9053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9054 if (!SWIG_IsOK(res1)) {
9055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9057 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9058 result = ((std::vector<Hex::Edge * > const *)arg1)->size();
9059 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9066 SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9071 PyObject * obj0 = 0 ;
9073 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9078 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9080 resultobj = SWIG_Py_Void();
9087 SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9090 std::vector<Hex::Edge * > *arg2 = 0 ;
9095 PyObject * obj0 = 0 ;
9096 PyObject * obj1 = 0 ;
9098 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
9099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9100 if (!SWIG_IsOK(res1)) {
9101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9103 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 );
9105 if (!SWIG_IsOK(res2)) {
9106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
9109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
9111 arg2 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp2);
9112 (arg1)->swap(*arg2);
9113 resultobj = SWIG_Py_Void();
9120 SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121 PyObject *resultobj = 0;
9122 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9123 SwigValueWrapper<std::allocator<Hex::Edge * > > result;
9126 PyObject * obj0 = 0 ;
9128 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
9129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9130 if (!SWIG_IsOK(res1)) {
9131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9133 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9134 result = ((std::vector<Hex::Edge * > const *)arg1)->get_allocator();
9135 resultobj = SWIG_NewPointerObj((new std::vector<Hex::Edge * >::allocator_type(static_cast< const std::vector<Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
9142 SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9145 std::vector<Hex::Edge * >::iterator result;
9148 PyObject * obj0 = 0 ;
9150 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
9151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9155 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9156 result = (arg1)->begin();
9157 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9158 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9165 SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 PyObject *resultobj = 0;
9167 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9168 std::vector<Hex::Edge * >::const_iterator result;
9171 PyObject * obj0 = 0 ;
9173 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
9174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9175 if (!SWIG_IsOK(res1)) {
9176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9178 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9179 result = ((std::vector<Hex::Edge * > const *)arg1)->begin();
9180 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
9181 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9188 SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *self, PyObject *args) {
9193 if (!PyTuple_Check(args)) SWIG_fail;
9194 argc = PyObject_Length(args);
9195 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9196 argv[ii] = PyTuple_GET_ITEM(args,ii);
9200 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9201 _v = SWIG_CheckState(res);
9203 return _wrap_VectorEdges_begin__SWIG_0(self, args);
9208 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9209 _v = SWIG_CheckState(res);
9211 return _wrap_VectorEdges_begin__SWIG_1(self, args);
9216 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
9221 SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *resultobj = 0;
9223 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9224 std::vector<Hex::Edge * >::iterator result;
9227 PyObject * obj0 = 0 ;
9229 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
9230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9231 if (!SWIG_IsOK(res1)) {
9232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9234 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9235 result = (arg1)->end();
9236 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9237 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9244 SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 PyObject *resultobj = 0;
9246 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9247 std::vector<Hex::Edge * >::const_iterator result;
9250 PyObject * obj0 = 0 ;
9252 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
9253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9254 if (!SWIG_IsOK(res1)) {
9255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9257 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9258 result = ((std::vector<Hex::Edge * > const *)arg1)->end();
9259 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
9260 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9267 SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *self, PyObject *args) {
9272 if (!PyTuple_Check(args)) SWIG_fail;
9273 argc = PyObject_Length(args);
9274 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9275 argv[ii] = PyTuple_GET_ITEM(args,ii);
9279 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9280 _v = SWIG_CheckState(res);
9282 return _wrap_VectorEdges_end__SWIG_0(self, args);
9287 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9288 _v = SWIG_CheckState(res);
9290 return _wrap_VectorEdges_end__SWIG_1(self, args);
9295 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
9300 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9303 std::vector<Hex::Edge * >::reverse_iterator result;
9306 PyObject * obj0 = 0 ;
9308 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
9309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9313 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9314 result = (arg1)->rbegin();
9315 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
9316 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9323 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 PyObject *resultobj = 0;
9325 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9326 std::vector<Hex::Edge * >::const_reverse_iterator result;
9329 PyObject * obj0 = 0 ;
9331 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
9332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9333 if (!SWIG_IsOK(res1)) {
9334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9336 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9337 result = ((std::vector<Hex::Edge * > const *)arg1)->rbegin();
9338 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
9339 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9346 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *self, PyObject *args) {
9351 if (!PyTuple_Check(args)) SWIG_fail;
9352 argc = PyObject_Length(args);
9353 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9354 argv[ii] = PyTuple_GET_ITEM(args,ii);
9358 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9359 _v = SWIG_CheckState(res);
9361 return _wrap_VectorEdges_rbegin__SWIG_0(self, args);
9366 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9367 _v = SWIG_CheckState(res);
9369 return _wrap_VectorEdges_rbegin__SWIG_1(self, args);
9374 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
9379 SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 PyObject *resultobj = 0;
9381 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9382 std::vector<Hex::Edge * >::reverse_iterator result;
9385 PyObject * obj0 = 0 ;
9387 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
9388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9392 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9393 result = (arg1)->rend();
9394 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
9395 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9402 SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9403 PyObject *resultobj = 0;
9404 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9405 std::vector<Hex::Edge * >::const_reverse_iterator result;
9408 PyObject * obj0 = 0 ;
9410 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
9411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9415 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9416 result = ((std::vector<Hex::Edge * > const *)arg1)->rend();
9417 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
9418 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9425 SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *self, PyObject *args) {
9430 if (!PyTuple_Check(args)) SWIG_fail;
9431 argc = PyObject_Length(args);
9432 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9433 argv[ii] = PyTuple_GET_ITEM(args,ii);
9437 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9438 _v = SWIG_CheckState(res);
9440 return _wrap_VectorEdges_rend__SWIG_0(self, args);
9445 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9446 _v = SWIG_CheckState(res);
9448 return _wrap_VectorEdges_rend__SWIG_1(self, args);
9453 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
9458 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459 PyObject *resultobj = 0;
9460 std::vector<Hex::Edge * >::size_type arg1 ;
9461 std::vector<Hex::Edge * > *result = 0 ;
9464 PyObject * obj0 = 0 ;
9466 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
9467 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9468 if (!SWIG_IsOK(ecode1)) {
9469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9471 arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
9472 result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1);
9473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
9480 SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9485 PyObject * obj0 = 0 ;
9487 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
9488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9492 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9494 resultobj = SWIG_Py_Void();
9501 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9502 PyObject *resultobj = 0;
9503 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9504 std::vector<Hex::Edge * >::size_type arg2 ;
9509 PyObject * obj0 = 0 ;
9510 PyObject * obj1 = 0 ;
9512 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
9513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9514 if (!SWIG_IsOK(res1)) {
9515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9517 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9518 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9519 if (!SWIG_IsOK(ecode2)) {
9520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9522 arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9523 (arg1)->resize(arg2);
9524 resultobj = SWIG_Py_Void();
9531 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9532 PyObject *resultobj = 0;
9533 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9534 std::vector<Hex::Edge * >::iterator arg2 ;
9535 std::vector<Hex::Edge * >::iterator result;
9538 swig::PySwigIterator *iter2 = 0 ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9543 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
9544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9545 if (!SWIG_IsOK(res1)) {
9546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9548 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9549 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9550 if (!SWIG_IsOK(res2) || !iter2) {
9551 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9553 swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9555 arg2 = iter_t->get_current();
9557 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9560 result = (arg1)->erase(arg2);
9561 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9562 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9569 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9570 PyObject *resultobj = 0;
9571 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9572 std::vector<Hex::Edge * >::iterator arg2 ;
9573 std::vector<Hex::Edge * >::iterator arg3 ;
9574 std::vector<Hex::Edge * >::iterator result;
9577 swig::PySwigIterator *iter2 = 0 ;
9579 swig::PySwigIterator *iter3 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 PyObject * obj2 = 0 ;
9585 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9587 if (!SWIG_IsOK(res1)) {
9588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9590 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9591 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9592 if (!SWIG_IsOK(res2) || !iter2) {
9593 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9595 swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9597 arg2 = iter_t->get_current();
9599 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9602 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
9603 if (!SWIG_IsOK(res3) || !iter3) {
9604 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9606 swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter3);
9608 arg3 = iter_t->get_current();
9610 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9613 result = (arg1)->erase(arg2,arg3);
9614 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9615 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9622 SWIGINTERN PyObject *_wrap_VectorEdges_erase(PyObject *self, PyObject *args) {
9627 if (!PyTuple_Check(args)) SWIG_fail;
9628 argc = PyObject_Length(args);
9629 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9630 argv[ii] = PyTuple_GET_ITEM(args,ii);
9634 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9635 _v = SWIG_CheckState(res);
9637 swig::PySwigIterator *iter = 0;
9638 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9639 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9641 return _wrap_VectorEdges_erase__SWIG_0(self, args);
9647 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9648 _v = SWIG_CheckState(res);
9650 swig::PySwigIterator *iter = 0;
9651 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9652 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9654 swig::PySwigIterator *iter = 0;
9655 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9656 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9658 return _wrap_VectorEdges_erase__SWIG_1(self, args);
9665 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Edge * >::iterator)\n erase(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::iterator)\n");
9670 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9671 PyObject *resultobj = 0;
9672 std::vector<Hex::Edge * >::size_type arg1 ;
9673 std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
9674 std::vector<Hex::Edge * > *result = 0 ;
9679 PyObject * obj0 = 0 ;
9680 PyObject * obj1 = 0 ;
9682 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
9683 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9684 if (!SWIG_IsOK(ecode1)) {
9685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9687 arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
9688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9689 if (!SWIG_IsOK(res2)) {
9690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9692 arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
9693 result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1,arg2);
9694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
9701 SWIGINTERN PyObject *_wrap_new_VectorEdges(PyObject *self, PyObject *args) {
9706 if (!PyTuple_Check(args)) SWIG_fail;
9707 argc = PyObject_Length(args);
9708 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9709 argv[ii] = PyTuple_GET_ITEM(args,ii);
9712 return _wrap_new_VectorEdges__SWIG_0(self, args);
9717 int res = SWIG_AsVal_size_t(argv[0], NULL);
9718 _v = SWIG_CheckState(res);
9721 return _wrap_new_VectorEdges__SWIG_2(self, args);
9726 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9727 _v = SWIG_CheckState(res);
9729 return _wrap_new_VectorEdges__SWIG_1(self, args);
9735 int res = SWIG_AsVal_size_t(argv[0], NULL);
9736 _v = SWIG_CheckState(res);
9740 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
9741 _v = SWIG_CheckState(res);
9743 return _wrap_new_VectorEdges__SWIG_3(self, args);
9749 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorEdges'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Edge)>()\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * > const &)\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type)\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
9754 SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755 PyObject *resultobj = 0;
9756 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9757 std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
9762 PyObject * obj0 = 0 ;
9763 PyObject * obj1 = 0 ;
9765 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
9766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9770 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9772 if (!SWIG_IsOK(res2)) {
9773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9775 arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
9776 (arg1)->push_back(arg2);
9777 resultobj = SWIG_Py_Void();
9784 SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9787 std::vector<Hex::Edge * >::value_type result;
9790 PyObject * obj0 = 0 ;
9792 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
9793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9794 if (!SWIG_IsOK(res1)) {
9795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9797 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9798 result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->front();
9799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9806 SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9809 std::vector<Hex::Edge * >::value_type result;
9812 PyObject * obj0 = 0 ;
9814 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
9815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9816 if (!SWIG_IsOK(res1)) {
9817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9819 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9820 result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->back();
9821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9828 SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829 PyObject *resultobj = 0;
9830 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9831 std::vector<Hex::Edge * >::size_type arg2 ;
9832 std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9839 PyObject * obj0 = 0 ;
9840 PyObject * obj1 = 0 ;
9841 PyObject * obj2 = 0 ;
9843 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
9844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9845 if (!SWIG_IsOK(res1)) {
9846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9848 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9849 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9850 if (!SWIG_IsOK(ecode2)) {
9851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9853 arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9854 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9855 if (!SWIG_IsOK(res3)) {
9856 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9858 arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9859 (arg1)->assign(arg2,arg3);
9860 resultobj = SWIG_Py_Void();
9867 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9868 PyObject *resultobj = 0;
9869 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9870 std::vector<Hex::Edge * >::size_type arg2 ;
9871 std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9878 PyObject * obj0 = 0 ;
9879 PyObject * obj1 = 0 ;
9880 PyObject * obj2 = 0 ;
9882 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
9883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9884 if (!SWIG_IsOK(res1)) {
9885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9887 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9889 if (!SWIG_IsOK(ecode2)) {
9890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9892 arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9893 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9894 if (!SWIG_IsOK(res3)) {
9895 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9897 arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9898 (arg1)->resize(arg2,arg3);
9899 resultobj = SWIG_Py_Void();
9906 SWIGINTERN PyObject *_wrap_VectorEdges_resize(PyObject *self, PyObject *args) {
9911 if (!PyTuple_Check(args)) SWIG_fail;
9912 argc = PyObject_Length(args);
9913 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9914 argv[ii] = PyTuple_GET_ITEM(args,ii);
9918 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9919 _v = SWIG_CheckState(res);
9922 int res = SWIG_AsVal_size_t(argv[1], NULL);
9923 _v = SWIG_CheckState(res);
9926 return _wrap_VectorEdges_resize__SWIG_0(self, args);
9932 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9933 _v = SWIG_CheckState(res);
9936 int res = SWIG_AsVal_size_t(argv[1], NULL);
9937 _v = SWIG_CheckState(res);
9941 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
9942 _v = SWIG_CheckState(res);
9944 return _wrap_VectorEdges_resize__SWIG_1(self, args);
9951 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Edge * >::size_type)\n resize(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
9956 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9957 PyObject *resultobj = 0;
9958 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9959 std::vector<Hex::Edge * >::iterator arg2 ;
9960 std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9961 std::vector<Hex::Edge * >::iterator result;
9964 swig::PySwigIterator *iter2 = 0 ;
9968 PyObject * obj0 = 0 ;
9969 PyObject * obj1 = 0 ;
9970 PyObject * obj2 = 0 ;
9972 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9977 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9978 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9979 if (!SWIG_IsOK(res2) || !iter2) {
9980 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9982 swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9984 arg2 = iter_t->get_current();
9986 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9989 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
9990 if (!SWIG_IsOK(res3)) {
9991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9993 arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9994 result = (arg1)->insert(arg2,arg3);
9995 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9996 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10003 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *resultobj = 0;
10005 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10006 std::vector<Hex::Edge * >::iterator arg2 ;
10007 std::vector<Hex::Edge * >::size_type arg3 ;
10008 std::vector<Hex::Edge * >::value_type arg4 = (std::vector<Hex::Edge * >::value_type) 0 ;
10011 swig::PySwigIterator *iter2 = 0 ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 PyObject * obj2 = 0 ;
10020 PyObject * obj3 = 0 ;
10022 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10027 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10028 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
10029 if (!SWIG_IsOK(res2) || !iter2) {
10030 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
10032 swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
10034 arg2 = iter_t->get_current();
10036 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
10039 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
10040 if (!SWIG_IsOK(ecode3)) {
10041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::size_type""'");
10043 arg3 = static_cast< std::vector<Hex::Edge * >::size_type >(val3);
10044 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
10045 if (!SWIG_IsOK(res4)) {
10046 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector<Hex::Edge * >::value_type""'");
10048 arg4 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp4);
10049 (arg1)->insert(arg2,arg3,arg4);
10050 resultobj = SWIG_Py_Void();
10057 SWIGINTERN PyObject *_wrap_VectorEdges_insert(PyObject *self, PyObject *args) {
10062 if (!PyTuple_Check(args)) SWIG_fail;
10063 argc = PyObject_Length(args);
10064 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10065 argv[ii] = PyTuple_GET_ITEM(args,ii);
10069 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
10070 _v = SWIG_CheckState(res);
10072 swig::PySwigIterator *iter = 0;
10073 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
10074 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
10077 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
10078 _v = SWIG_CheckState(res);
10080 return _wrap_VectorEdges_insert__SWIG_0(self, args);
10087 int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
10088 _v = SWIG_CheckState(res);
10090 swig::PySwigIterator *iter = 0;
10091 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
10092 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
10095 int res = SWIG_AsVal_size_t(argv[2], NULL);
10096 _v = SWIG_CheckState(res);
10100 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
10101 _v = SWIG_CheckState(res);
10103 return _wrap_VectorEdges_insert__SWIG_1(self, args);
10111 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::value_type)\n insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
10116 SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117 PyObject *resultobj = 0;
10118 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10119 std::vector<Hex::Edge * >::size_type arg2 ;
10124 PyObject * obj0 = 0 ;
10125 PyObject * obj1 = 0 ;
10127 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
10128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
10129 if (!SWIG_IsOK(res1)) {
10130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10132 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10133 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10134 if (!SWIG_IsOK(ecode2)) {
10135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
10137 arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
10138 (arg1)->reserve(arg2);
10139 resultobj = SWIG_Py_Void();
10146 SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10147 PyObject *resultobj = 0;
10148 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10149 std::vector<Hex::Edge * >::size_type result;
10152 PyObject * obj0 = 0 ;
10154 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
10155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
10156 if (!SWIG_IsOK(res1)) {
10157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
10159 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10160 result = ((std::vector<Hex::Edge * > const *)arg1)->capacity();
10161 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10168 SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10169 PyObject *resultobj = 0;
10170 std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10173 PyObject * obj0 = 0 ;
10175 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_DISOWN | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10180 arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10183 resultobj = SWIG_Py_Void();
10190 SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10192 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
10193 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_NewClientData(obj));
10194 return SWIG_Py_Void();
10197 SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198 PyObject *resultobj = 0;
10199 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10200 PyObject **arg2 = (PyObject **) 0 ;
10201 swig::PySwigIterator *result = 0 ;
10204 PyObject * obj0 = 0 ;
10207 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
10208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10209 if (!SWIG_IsOK(res1)) {
10210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10212 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10213 result = (swig::PySwigIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
10214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
10221 SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10222 PyObject *resultobj = 0;
10223 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10227 PyObject * obj0 = 0 ;
10229 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10234 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10235 result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector<Hex::Vertex * > const *)arg1);
10236 resultobj = SWIG_From_bool(static_cast< bool >(result));
10243 SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244 PyObject *resultobj = 0;
10245 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10246 std::vector<Hex::Vertex * >::size_type result;
10249 PyObject * obj0 = 0 ;
10251 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
10252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10256 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10257 result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector<Hex::Vertex * > const *)arg1);
10258 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10265 SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10266 PyObject *resultobj = 0;
10267 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10268 std::vector<Hex::Vertex * >::value_type result;
10271 PyObject * obj0 = 0 ;
10273 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
10274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10275 if (!SWIG_IsOK(res1)) {
10276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10278 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10280 result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
10282 catch(std::out_of_range &_e) {
10283 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
10293 SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10296 std::vector<Hex::Vertex * >::difference_type arg2 ;
10297 std::vector<Hex::Vertex * >::difference_type arg3 ;
10298 std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *result = 0 ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 PyObject * obj2 = 0 ;
10309 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10311 if (!SWIG_IsOK(res1)) {
10312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10314 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10315 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10316 if (!SWIG_IsOK(ecode2)) {
10317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10319 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10320 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10321 if (!SWIG_IsOK(ecode3)) {
10322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10324 arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10326 result = (std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
10328 catch(std::out_of_range &_e) {
10329 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_OWN | 0 );
10339 SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340 PyObject *resultobj = 0;
10341 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10342 std::vector<Hex::Vertex * >::difference_type arg2 ;
10343 std::vector<Hex::Vertex * >::difference_type arg3 ;
10344 std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *arg4 = 0 ;
10351 int res4 = SWIG_OLDOBJ ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 PyObject * obj2 = 0 ;
10355 PyObject * obj3 = 0 ;
10357 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10362 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10363 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10364 if (!SWIG_IsOK(ecode2)) {
10365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10367 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10368 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10369 if (!SWIG_IsOK(ecode3)) {
10370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10372 arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10374 std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
10375 res4 = swig::asptr(obj3, &ptr);
10376 if (!SWIG_IsOK(res4)) {
10377 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &""'");
10380 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &""'");
10385 std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &)*arg4);
10387 catch(std::out_of_range &_e) {
10388 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10390 catch(std::invalid_argument &_e) {
10391 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10394 resultobj = SWIG_Py_Void();
10395 if (SWIG_IsNewObj(res4)) delete arg4;
10398 if (SWIG_IsNewObj(res4)) delete arg4;
10403 SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10404 PyObject *resultobj = 0;
10405 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10406 std::vector<Hex::Vertex * >::difference_type arg2 ;
10407 std::vector<Hex::Vertex * >::difference_type arg3 ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 PyObject * obj2 = 0 ;
10418 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10423 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10424 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10425 if (!SWIG_IsOK(ecode2)) {
10426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10428 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10429 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10430 if (!SWIG_IsOK(ecode3)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10433 arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10435 std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
10437 catch(std::out_of_range &_e) {
10438 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10441 resultobj = SWIG_Py_Void();
10448 SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10449 PyObject *resultobj = 0;
10450 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10451 std::vector<Hex::Vertex * >::difference_type arg2 ;
10456 PyObject * obj0 = 0 ;
10457 PyObject * obj1 = 0 ;
10459 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
10460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10461 if (!SWIG_IsOK(res1)) {
10462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10464 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10465 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10466 if (!SWIG_IsOK(ecode2)) {
10467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10469 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10471 std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(arg1,arg2);
10473 catch(std::out_of_range &_e) {
10474 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10477 resultobj = SWIG_Py_Void();
10484 SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10487 std::vector<Hex::Vertex * >::difference_type arg2 ;
10488 std::vector<Hex::Vertex * >::value_type result;
10493 PyObject * obj0 = 0 ;
10494 PyObject * obj1 = 0 ;
10496 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
10497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10498 if (!SWIG_IsOK(res1)) {
10499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10501 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10502 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10503 if (!SWIG_IsOK(ecode2)) {
10504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10506 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10508 result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(arg1,arg2);
10510 catch(std::out_of_range &_e) {
10511 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
10521 SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10524 std::vector<Hex::Vertex * >::difference_type arg2 ;
10525 std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
10532 PyObject * obj0 = 0 ;
10533 PyObject * obj1 = 0 ;
10534 PyObject * obj2 = 0 ;
10536 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
10537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10538 if (!SWIG_IsOK(res1)) {
10539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10541 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10542 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10543 if (!SWIG_IsOK(ecode2)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10546 arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10547 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
10548 if (!SWIG_IsOK(res3)) {
10549 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
10551 arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
10553 std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(arg1,arg2,arg3);
10555 catch(std::out_of_range &_e) {
10556 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10559 resultobj = SWIG_Py_Void();
10566 SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10567 PyObject *resultobj = 0;
10568 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10569 std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
10574 PyObject * obj0 = 0 ;
10575 PyObject * obj1 = 0 ;
10577 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
10578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10582 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
10584 if (!SWIG_IsOK(res2)) {
10585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
10587 arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
10588 std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
10589 resultobj = SWIG_Py_Void();
10596 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597 PyObject *resultobj = 0;
10598 std::vector<Hex::Vertex * > *result = 0 ;
10600 if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
10601 result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >();
10602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
10609 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 PyObject *resultobj = 0;
10611 std::vector<Hex::Vertex * > *arg1 = 0 ;
10612 std::vector<Hex::Vertex * > *result = 0 ;
10613 int res1 = SWIG_OLDOBJ ;
10614 PyObject * obj0 = 0 ;
10616 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
10618 std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
10619 res1 = swig::asptr(obj0, &ptr);
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
10624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
10628 result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >((std::vector<Hex::Vertex * > const &)*arg1);
10629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
10630 if (SWIG_IsNewObj(res1)) delete arg1;
10633 if (SWIG_IsNewObj(res1)) delete arg1;
10638 SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10639 PyObject *resultobj = 0;
10640 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10644 PyObject * obj0 = 0 ;
10646 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
10647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10648 if (!SWIG_IsOK(res1)) {
10649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10651 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10652 result = (bool)((std::vector<Hex::Vertex * > const *)arg1)->empty();
10653 resultobj = SWIG_From_bool(static_cast< bool >(result));
10660 SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10661 PyObject *resultobj = 0;
10662 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10663 std::vector<Hex::Vertex * >::size_type result;
10666 PyObject * obj0 = 0 ;
10668 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
10669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10670 if (!SWIG_IsOK(res1)) {
10671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10673 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10674 result = ((std::vector<Hex::Vertex * > const *)arg1)->size();
10675 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10682 SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683 PyObject *resultobj = 0;
10684 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10687 PyObject * obj0 = 0 ;
10689 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10694 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10696 resultobj = SWIG_Py_Void();
10703 SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704 PyObject *resultobj = 0;
10705 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10706 std::vector<Hex::Vertex * > *arg2 = 0 ;
10711 PyObject * obj0 = 0 ;
10712 PyObject * obj1 = 0 ;
10714 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
10715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10716 if (!SWIG_IsOK(res1)) {
10717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10719 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10720 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 );
10721 if (!SWIG_IsOK(res2)) {
10722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
10725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
10727 arg2 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp2);
10728 (arg1)->swap(*arg2);
10729 resultobj = SWIG_Py_Void();
10736 SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10737 PyObject *resultobj = 0;
10738 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10739 SwigValueWrapper<std::allocator<Hex::Vertex * > > result;
10742 PyObject * obj0 = 0 ;
10744 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
10745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10746 if (!SWIG_IsOK(res1)) {
10747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10749 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10750 result = ((std::vector<Hex::Vertex * > const *)arg1)->get_allocator();
10751 resultobj = SWIG_NewPointerObj((new std::vector<Hex::Vertex * >::allocator_type(static_cast< const std::vector<Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
10758 SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10759 PyObject *resultobj = 0;
10760 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10761 std::vector<Hex::Vertex * >::iterator result;
10764 PyObject * obj0 = 0 ;
10766 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
10767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10768 if (!SWIG_IsOK(res1)) {
10769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10771 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10772 result = (arg1)->begin();
10773 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
10774 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10781 SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10782 PyObject *resultobj = 0;
10783 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10784 std::vector<Hex::Vertex * >::const_iterator result;
10787 PyObject * obj0 = 0 ;
10789 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
10790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10791 if (!SWIG_IsOK(res1)) {
10792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10794 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10795 result = ((std::vector<Hex::Vertex * > const *)arg1)->begin();
10796 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
10797 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10804 SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *self, PyObject *args) {
10809 if (!PyTuple_Check(args)) SWIG_fail;
10810 argc = PyObject_Length(args);
10811 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10812 argv[ii] = PyTuple_GET_ITEM(args,ii);
10816 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10817 _v = SWIG_CheckState(res);
10819 return _wrap_VectorVertices_begin__SWIG_0(self, args);
10824 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10825 _v = SWIG_CheckState(res);
10827 return _wrap_VectorVertices_begin__SWIG_1(self, args);
10832 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
10837 SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10838 PyObject *resultobj = 0;
10839 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10840 std::vector<Hex::Vertex * >::iterator result;
10843 PyObject * obj0 = 0 ;
10845 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
10846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10847 if (!SWIG_IsOK(res1)) {
10848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10850 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10851 result = (arg1)->end();
10852 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
10853 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10860 SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10861 PyObject *resultobj = 0;
10862 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10863 std::vector<Hex::Vertex * >::const_iterator result;
10866 PyObject * obj0 = 0 ;
10868 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
10869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10870 if (!SWIG_IsOK(res1)) {
10871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10873 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10874 result = ((std::vector<Hex::Vertex * > const *)arg1)->end();
10875 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
10876 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10883 SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *self, PyObject *args) {
10888 if (!PyTuple_Check(args)) SWIG_fail;
10889 argc = PyObject_Length(args);
10890 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10891 argv[ii] = PyTuple_GET_ITEM(args,ii);
10895 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10896 _v = SWIG_CheckState(res);
10898 return _wrap_VectorVertices_end__SWIG_0(self, args);
10903 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10904 _v = SWIG_CheckState(res);
10906 return _wrap_VectorVertices_end__SWIG_1(self, args);
10911 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
10916 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10917 PyObject *resultobj = 0;
10918 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10919 std::vector<Hex::Vertex * >::reverse_iterator result;
10922 PyObject * obj0 = 0 ;
10924 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10929 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10930 result = (arg1)->rbegin();
10931 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
10932 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10939 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940 PyObject *resultobj = 0;
10941 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10942 std::vector<Hex::Vertex * >::const_reverse_iterator result;
10945 PyObject * obj0 = 0 ;
10947 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
10948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10952 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10953 result = ((std::vector<Hex::Vertex * > const *)arg1)->rbegin();
10954 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
10955 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10962 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *self, PyObject *args) {
10967 if (!PyTuple_Check(args)) SWIG_fail;
10968 argc = PyObject_Length(args);
10969 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10970 argv[ii] = PyTuple_GET_ITEM(args,ii);
10974 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10975 _v = SWIG_CheckState(res);
10977 return _wrap_VectorVertices_rbegin__SWIG_0(self, args);
10982 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10983 _v = SWIG_CheckState(res);
10985 return _wrap_VectorVertices_rbegin__SWIG_1(self, args);
10990 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
10995 SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10996 PyObject *resultobj = 0;
10997 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10998 std::vector<Hex::Vertex * >::reverse_iterator result;
11001 PyObject * obj0 = 0 ;
11003 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
11004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11005 if (!SWIG_IsOK(res1)) {
11006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11008 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11009 result = (arg1)->rend();
11010 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
11011 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11018 SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11021 std::vector<Hex::Vertex * >::const_reverse_iterator result;
11024 PyObject * obj0 = 0 ;
11026 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
11027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11028 if (!SWIG_IsOK(res1)) {
11029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11031 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11032 result = ((std::vector<Hex::Vertex * > const *)arg1)->rend();
11033 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
11034 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11041 SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *self, PyObject *args) {
11046 if (!PyTuple_Check(args)) SWIG_fail;
11047 argc = PyObject_Length(args);
11048 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
11049 argv[ii] = PyTuple_GET_ITEM(args,ii);
11053 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11054 _v = SWIG_CheckState(res);
11056 return _wrap_VectorVertices_rend__SWIG_0(self, args);
11061 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11062 _v = SWIG_CheckState(res);
11064 return _wrap_VectorVertices_rend__SWIG_1(self, args);
11069 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
11074 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11075 PyObject *resultobj = 0;
11076 std::vector<Hex::Vertex * >::size_type arg1 ;
11077 std::vector<Hex::Vertex * > *result = 0 ;
11080 PyObject * obj0 = 0 ;
11082 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
11083 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11084 if (!SWIG_IsOK(ecode1)) {
11085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11087 arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
11088 result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1);
11089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
11096 SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *resultobj = 0;
11098 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11101 PyObject * obj0 = 0 ;
11103 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
11104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11105 if (!SWIG_IsOK(res1)) {
11106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11108 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11109 (arg1)->pop_back();
11110 resultobj = SWIG_Py_Void();
11117 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11120 std::vector<Hex::Vertex * >::size_type arg2 ;
11125 PyObject * obj0 = 0 ;
11126 PyObject * obj1 = 0 ;
11128 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
11129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11133 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11134 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11135 if (!SWIG_IsOK(ecode2)) {
11136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11138 arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11139 (arg1)->resize(arg2);
11140 resultobj = SWIG_Py_Void();
11147 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11150 std::vector<Hex::Vertex * >::iterator arg2 ;
11151 std::vector<Hex::Vertex * >::iterator result;
11154 swig::PySwigIterator *iter2 = 0 ;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11159 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
11160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11164 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11165 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11166 if (!SWIG_IsOK(res2) || !iter2) {
11167 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11169 swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11171 arg2 = iter_t->get_current();
11173 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11176 result = (arg1)->erase(arg2);
11177 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11178 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11185 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *resultobj = 0;
11187 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11188 std::vector<Hex::Vertex * >::iterator arg2 ;
11189 std::vector<Hex::Vertex * >::iterator arg3 ;
11190 std::vector<Hex::Vertex * >::iterator result;
11193 swig::PySwigIterator *iter2 = 0 ;
11195 swig::PySwigIterator *iter3 = 0 ;
11197 PyObject * obj0 = 0 ;
11198 PyObject * obj1 = 0 ;
11199 PyObject * obj2 = 0 ;
11201 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
11202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11203 if (!SWIG_IsOK(res1)) {
11204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11206 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11207 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11208 if (!SWIG_IsOK(res2) || !iter2) {
11209 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11211 swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11213 arg2 = iter_t->get_current();
11215 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11218 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
11219 if (!SWIG_IsOK(res3) || !iter3) {
11220 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11222 swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter3);
11224 arg3 = iter_t->get_current();
11226 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11229 result = (arg1)->erase(arg2,arg3);
11230 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11231 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11238 SWIGINTERN PyObject *_wrap_VectorVertices_erase(PyObject *self, PyObject *args) {
11243 if (!PyTuple_Check(args)) SWIG_fail;
11244 argc = PyObject_Length(args);
11245 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11246 argv[ii] = PyTuple_GET_ITEM(args,ii);
11250 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11251 _v = SWIG_CheckState(res);
11253 swig::PySwigIterator *iter = 0;
11254 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11255 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11257 return _wrap_VectorVertices_erase__SWIG_0(self, args);
11263 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11264 _v = SWIG_CheckState(res);
11266 swig::PySwigIterator *iter = 0;
11267 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11268 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11270 swig::PySwigIterator *iter = 0;
11271 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11272 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11274 return _wrap_VectorVertices_erase__SWIG_1(self, args);
11281 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Vertex * >::iterator)\n erase(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::iterator)\n");
11286 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11287 PyObject *resultobj = 0;
11288 std::vector<Hex::Vertex * >::size_type arg1 ;
11289 std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11290 std::vector<Hex::Vertex * > *result = 0 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11298 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
11299 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11300 if (!SWIG_IsOK(ecode1)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11303 arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
11304 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11305 if (!SWIG_IsOK(res2)) {
11306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11308 arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
11309 result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1,arg2);
11310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
11317 SWIGINTERN PyObject *_wrap_new_VectorVertices(PyObject *self, PyObject *args) {
11322 if (!PyTuple_Check(args)) SWIG_fail;
11323 argc = PyObject_Length(args);
11324 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11325 argv[ii] = PyTuple_GET_ITEM(args,ii);
11328 return _wrap_new_VectorVertices__SWIG_0(self, args);
11333 int res = SWIG_AsVal_size_t(argv[0], NULL);
11334 _v = SWIG_CheckState(res);
11337 return _wrap_new_VectorVertices__SWIG_2(self, args);
11342 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11343 _v = SWIG_CheckState(res);
11345 return _wrap_new_VectorVertices__SWIG_1(self, args);
11351 int res = SWIG_AsVal_size_t(argv[0], NULL);
11352 _v = SWIG_CheckState(res);
11356 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11357 _v = SWIG_CheckState(res);
11359 return _wrap_new_VectorVertices__SWIG_3(self, args);
11365 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorVertices'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Vertex)>()\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * > const &)\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type)\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11370 SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 PyObject *resultobj = 0;
11372 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11373 std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11378 PyObject * obj0 = 0 ;
11379 PyObject * obj1 = 0 ;
11381 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
11382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11383 if (!SWIG_IsOK(res1)) {
11384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11386 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11388 if (!SWIG_IsOK(res2)) {
11389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11391 arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
11392 (arg1)->push_back(arg2);
11393 resultobj = SWIG_Py_Void();
11400 SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11401 PyObject *resultobj = 0;
11402 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11403 std::vector<Hex::Vertex * >::value_type result;
11406 PyObject * obj0 = 0 ;
11408 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
11409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11410 if (!SWIG_IsOK(res1)) {
11411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11413 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11414 result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->front();
11415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11422 SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423 PyObject *resultobj = 0;
11424 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11425 std::vector<Hex::Vertex * >::value_type result;
11428 PyObject * obj0 = 0 ;
11430 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
11431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11432 if (!SWIG_IsOK(res1)) {
11433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11435 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11436 result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->back();
11437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11444 SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11445 PyObject *resultobj = 0;
11446 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11447 std::vector<Hex::Vertex * >::size_type arg2 ;
11448 std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11455 PyObject * obj0 = 0 ;
11456 PyObject * obj1 = 0 ;
11457 PyObject * obj2 = 0 ;
11459 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
11460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11461 if (!SWIG_IsOK(res1)) {
11462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11464 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11465 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11466 if (!SWIG_IsOK(ecode2)) {
11467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11469 arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11470 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11471 if (!SWIG_IsOK(res3)) {
11472 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11474 arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11475 (arg1)->assign(arg2,arg3);
11476 resultobj = SWIG_Py_Void();
11483 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11484 PyObject *resultobj = 0;
11485 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11486 std::vector<Hex::Vertex * >::size_type arg2 ;
11487 std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11494 PyObject * obj0 = 0 ;
11495 PyObject * obj1 = 0 ;
11496 PyObject * obj2 = 0 ;
11498 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
11499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11500 if (!SWIG_IsOK(res1)) {
11501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11503 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11504 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11505 if (!SWIG_IsOK(ecode2)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11508 arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11509 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11510 if (!SWIG_IsOK(res3)) {
11511 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11513 arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11514 (arg1)->resize(arg2,arg3);
11515 resultobj = SWIG_Py_Void();
11522 SWIGINTERN PyObject *_wrap_VectorVertices_resize(PyObject *self, PyObject *args) {
11527 if (!PyTuple_Check(args)) SWIG_fail;
11528 argc = PyObject_Length(args);
11529 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11530 argv[ii] = PyTuple_GET_ITEM(args,ii);
11534 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11535 _v = SWIG_CheckState(res);
11538 int res = SWIG_AsVal_size_t(argv[1], NULL);
11539 _v = SWIG_CheckState(res);
11542 return _wrap_VectorVertices_resize__SWIG_0(self, args);
11548 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11549 _v = SWIG_CheckState(res);
11552 int res = SWIG_AsVal_size_t(argv[1], NULL);
11553 _v = SWIG_CheckState(res);
11557 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11558 _v = SWIG_CheckState(res);
11560 return _wrap_VectorVertices_resize__SWIG_1(self, args);
11567 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Vertex * >::size_type)\n resize(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11572 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11575 std::vector<Hex::Vertex * >::iterator arg2 ;
11576 std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11577 std::vector<Hex::Vertex * >::iterator result;
11580 swig::PySwigIterator *iter2 = 0 ;
11584 PyObject * obj0 = 0 ;
11585 PyObject * obj1 = 0 ;
11586 PyObject * obj2 = 0 ;
11588 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
11589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11593 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11594 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11595 if (!SWIG_IsOK(res2) || !iter2) {
11596 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11598 swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11600 arg2 = iter_t->get_current();
11602 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11605 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11606 if (!SWIG_IsOK(res3)) {
11607 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11609 arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11610 result = (arg1)->insert(arg2,arg3);
11611 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11612 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11619 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620 PyObject *resultobj = 0;
11621 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11622 std::vector<Hex::Vertex * >::iterator arg2 ;
11623 std::vector<Hex::Vertex * >::size_type arg3 ;
11624 std::vector<Hex::Vertex * >::value_type arg4 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11627 swig::PySwigIterator *iter2 = 0 ;
11633 PyObject * obj0 = 0 ;
11634 PyObject * obj1 = 0 ;
11635 PyObject * obj2 = 0 ;
11636 PyObject * obj3 = 0 ;
11638 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11640 if (!SWIG_IsOK(res1)) {
11641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11643 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11644 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11645 if (!SWIG_IsOK(res2) || !iter2) {
11646 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11648 swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11650 arg2 = iter_t->get_current();
11652 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11655 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
11656 if (!SWIG_IsOK(ecode3)) {
11657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11659 arg3 = static_cast< std::vector<Hex::Vertex * >::size_type >(val3);
11660 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
11661 if (!SWIG_IsOK(res4)) {
11662 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11664 arg4 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp4);
11665 (arg1)->insert(arg2,arg3,arg4);
11666 resultobj = SWIG_Py_Void();
11673 SWIGINTERN PyObject *_wrap_VectorVertices_insert(PyObject *self, PyObject *args) {
11678 if (!PyTuple_Check(args)) SWIG_fail;
11679 argc = PyObject_Length(args);
11680 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
11681 argv[ii] = PyTuple_GET_ITEM(args,ii);
11685 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11686 _v = SWIG_CheckState(res);
11688 swig::PySwigIterator *iter = 0;
11689 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11690 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11693 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11694 _v = SWIG_CheckState(res);
11696 return _wrap_VectorVertices_insert__SWIG_0(self, args);
11703 int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11704 _v = SWIG_CheckState(res);
11706 swig::PySwigIterator *iter = 0;
11707 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11708 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11711 int res = SWIG_AsVal_size_t(argv[2], NULL);
11712 _v = SWIG_CheckState(res);
11716 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11717 _v = SWIG_CheckState(res);
11719 return _wrap_VectorVertices_insert__SWIG_1(self, args);
11727 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::value_type)\n insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11732 SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 PyObject *resultobj = 0;
11734 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11735 std::vector<Hex::Vertex * >::size_type arg2 ;
11740 PyObject * obj0 = 0 ;
11741 PyObject * obj1 = 0 ;
11743 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
11744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11748 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11749 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11750 if (!SWIG_IsOK(ecode2)) {
11751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11753 arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11754 (arg1)->reserve(arg2);
11755 resultobj = SWIG_Py_Void();
11762 SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11765 std::vector<Hex::Vertex * >::size_type result;
11768 PyObject * obj0 = 0 ;
11770 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
11771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11775 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11776 result = ((std::vector<Hex::Vertex * > const *)arg1)->capacity();
11777 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11784 SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11785 PyObject *resultobj = 0;
11786 std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11789 PyObject * obj0 = 0 ;
11791 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
11792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_DISOWN | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11796 arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11799 resultobj = SWIG_Py_Void();
11806 SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
11809 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_NewClientData(obj));
11810 return SWIG_Py_Void();
11813 SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11814 PyObject *resultobj = 0;
11815 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11816 PyObject **arg2 = (PyObject **) 0 ;
11817 swig::PySwigIterator *result = 0 ;
11820 PyObject * obj0 = 0 ;
11823 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
11824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11825 if (!SWIG_IsOK(res1)) {
11826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11828 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11829 result = (swig::PySwigIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
11830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
11837 SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838 PyObject *resultobj = 0;
11839 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11843 PyObject * obj0 = 0 ;
11845 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
11846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11847 if (!SWIG_IsOK(res1)) {
11848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
11850 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11851 result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector<Hex::NewShape * > const *)arg1);
11852 resultobj = SWIG_From_bool(static_cast< bool >(result));
11859 SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11860 PyObject *resultobj = 0;
11861 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11862 std::vector<Hex::NewShape * >::size_type result;
11865 PyObject * obj0 = 0 ;
11867 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
11868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11869 if (!SWIG_IsOK(res1)) {
11870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
11872 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11873 result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector<Hex::NewShape * > const *)arg1);
11874 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11881 SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11882 PyObject *resultobj = 0;
11883 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11884 std::vector<Hex::NewShape * >::value_type result;
11887 PyObject * obj0 = 0 ;
11889 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
11890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11894 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11896 result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
11898 catch(std::out_of_range &_e) {
11899 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
11909 SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910 PyObject *resultobj = 0;
11911 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11912 std::vector<Hex::NewShape * >::difference_type arg2 ;
11913 std::vector<Hex::NewShape * >::difference_type arg3 ;
11914 std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *result = 0 ;
11921 PyObject * obj0 = 0 ;
11922 PyObject * obj1 = 0 ;
11923 PyObject * obj2 = 0 ;
11925 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11930 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11931 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11935 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
11936 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11937 if (!SWIG_IsOK(ecode3)) {
11938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11940 arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
11942 result = (std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
11944 catch(std::out_of_range &_e) {
11945 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_OWN | 0 );
11955 SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11956 PyObject *resultobj = 0;
11957 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11958 std::vector<Hex::NewShape * >::difference_type arg2 ;
11959 std::vector<Hex::NewShape * >::difference_type arg3 ;
11960 std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *arg4 = 0 ;
11967 int res4 = SWIG_OLDOBJ ;
11968 PyObject * obj0 = 0 ;
11969 PyObject * obj1 = 0 ;
11970 PyObject * obj2 = 0 ;
11971 PyObject * obj3 = 0 ;
11973 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
11975 if (!SWIG_IsOK(res1)) {
11976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11978 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11979 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11980 if (!SWIG_IsOK(ecode2)) {
11981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11983 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
11984 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11985 if (!SWIG_IsOK(ecode3)) {
11986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11988 arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
11990 std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
11991 res4 = swig::asptr(obj3, &ptr);
11992 if (!SWIG_IsOK(res4)) {
11993 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &""'");
11996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &""'");
12001 std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &)*arg4);
12003 catch(std::out_of_range &_e) {
12004 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12006 catch(std::invalid_argument &_e) {
12007 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12010 resultobj = SWIG_Py_Void();
12011 if (SWIG_IsNewObj(res4)) delete arg4;
12014 if (SWIG_IsNewObj(res4)) delete arg4;
12019 SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020 PyObject *resultobj = 0;
12021 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12022 std::vector<Hex::NewShape * >::difference_type arg2 ;
12023 std::vector<Hex::NewShape * >::difference_type arg3 ;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 PyObject * obj2 = 0 ;
12034 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12036 if (!SWIG_IsOK(res1)) {
12037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12039 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12040 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12041 if (!SWIG_IsOK(ecode2)) {
12042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12044 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12045 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12046 if (!SWIG_IsOK(ecode3)) {
12047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12049 arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
12051 std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
12053 catch(std::out_of_range &_e) {
12054 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12057 resultobj = SWIG_Py_Void();
12064 SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12065 PyObject *resultobj = 0;
12066 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12067 std::vector<Hex::NewShape * >::difference_type arg2 ;
12072 PyObject * obj0 = 0 ;
12073 PyObject * obj1 = 0 ;
12075 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
12076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12077 if (!SWIG_IsOK(res1)) {
12078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12080 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12081 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12082 if (!SWIG_IsOK(ecode2)) {
12083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12085 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12087 std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(arg1,arg2);
12089 catch(std::out_of_range &_e) {
12090 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12093 resultobj = SWIG_Py_Void();
12100 SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *resultobj = 0;
12102 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12103 std::vector<Hex::NewShape * >::difference_type arg2 ;
12104 std::vector<Hex::NewShape * >::value_type result;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12112 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
12113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12114 if (!SWIG_IsOK(res1)) {
12115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12117 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12118 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12119 if (!SWIG_IsOK(ecode2)) {
12120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12122 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12124 result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(arg1,arg2);
12126 catch(std::out_of_range &_e) {
12127 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
12137 SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138 PyObject *resultobj = 0;
12139 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12140 std::vector<Hex::NewShape * >::difference_type arg2 ;
12141 std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12148 PyObject * obj0 = 0 ;
12149 PyObject * obj1 = 0 ;
12150 PyObject * obj2 = 0 ;
12152 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
12153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12157 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12158 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12159 if (!SWIG_IsOK(ecode2)) {
12160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12162 arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
12164 if (!SWIG_IsOK(res3)) {
12165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12167 arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
12169 std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(arg1,arg2,arg3);
12171 catch(std::out_of_range &_e) {
12172 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12175 resultobj = SWIG_Py_Void();
12182 SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183 PyObject *resultobj = 0;
12184 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12185 std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12190 PyObject * obj0 = 0 ;
12191 PyObject * obj1 = 0 ;
12193 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
12194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12198 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
12200 if (!SWIG_IsOK(res2)) {
12201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12203 arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
12204 std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
12205 resultobj = SWIG_Py_Void();
12212 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12213 PyObject *resultobj = 0;
12214 std::vector<Hex::NewShape * > *result = 0 ;
12216 if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
12217 result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >();
12218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
12225 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12226 PyObject *resultobj = 0;
12227 std::vector<Hex::NewShape * > *arg1 = 0 ;
12228 std::vector<Hex::NewShape * > *result = 0 ;
12229 int res1 = SWIG_OLDOBJ ;
12230 PyObject * obj0 = 0 ;
12232 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
12234 std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
12235 res1 = swig::asptr(obj0, &ptr);
12236 if (!SWIG_IsOK(res1)) {
12237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
12240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
12244 result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >((std::vector<Hex::NewShape * > const &)*arg1);
12245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
12246 if (SWIG_IsNewObj(res1)) delete arg1;
12249 if (SWIG_IsNewObj(res1)) delete arg1;
12254 SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12255 PyObject *resultobj = 0;
12256 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12260 PyObject * obj0 = 0 ;
12262 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
12263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12264 if (!SWIG_IsOK(res1)) {
12265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12267 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12268 result = (bool)((std::vector<Hex::NewShape * > const *)arg1)->empty();
12269 resultobj = SWIG_From_bool(static_cast< bool >(result));
12276 SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12277 PyObject *resultobj = 0;
12278 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12279 std::vector<Hex::NewShape * >::size_type result;
12282 PyObject * obj0 = 0 ;
12284 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
12285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12286 if (!SWIG_IsOK(res1)) {
12287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12289 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12290 result = ((std::vector<Hex::NewShape * > const *)arg1)->size();
12291 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12298 SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299 PyObject *resultobj = 0;
12300 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12303 PyObject * obj0 = 0 ;
12305 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
12306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12307 if (!SWIG_IsOK(res1)) {
12308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12310 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12312 resultobj = SWIG_Py_Void();
12319 SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12322 std::vector<Hex::NewShape * > *arg2 = 0 ;
12327 PyObject * obj0 = 0 ;
12328 PyObject * obj1 = 0 ;
12330 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
12331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12332 if (!SWIG_IsOK(res1)) {
12333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12335 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 );
12337 if (!SWIG_IsOK(res2)) {
12338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
12341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
12343 arg2 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp2);
12344 (arg1)->swap(*arg2);
12345 resultobj = SWIG_Py_Void();
12352 SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12353 PyObject *resultobj = 0;
12354 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12355 SwigValueWrapper<std::allocator<Hex::NewShape * > > result;
12358 PyObject * obj0 = 0 ;
12360 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
12361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12362 if (!SWIG_IsOK(res1)) {
12363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12365 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12366 result = ((std::vector<Hex::NewShape * > const *)arg1)->get_allocator();
12367 resultobj = SWIG_NewPointerObj((new std::vector<Hex::NewShape * >::allocator_type(static_cast< const std::vector<Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
12374 SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375 PyObject *resultobj = 0;
12376 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12377 std::vector<Hex::NewShape * >::iterator result;
12380 PyObject * obj0 = 0 ;
12382 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
12383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12387 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12388 result = (arg1)->begin();
12389 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12390 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12397 SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12398 PyObject *resultobj = 0;
12399 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12400 std::vector<Hex::NewShape * >::const_iterator result;
12403 PyObject * obj0 = 0 ;
12405 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
12406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12407 if (!SWIG_IsOK(res1)) {
12408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12410 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12411 result = ((std::vector<Hex::NewShape * > const *)arg1)->begin();
12412 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
12413 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12420 SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *self, PyObject *args) {
12425 if (!PyTuple_Check(args)) SWIG_fail;
12426 argc = PyObject_Length(args);
12427 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12428 argv[ii] = PyTuple_GET_ITEM(args,ii);
12432 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12433 _v = SWIG_CheckState(res);
12435 return _wrap_VectorShapes_begin__SWIG_0(self, args);
12440 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12441 _v = SWIG_CheckState(res);
12443 return _wrap_VectorShapes_begin__SWIG_1(self, args);
12448 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
12453 SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12454 PyObject *resultobj = 0;
12455 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12456 std::vector<Hex::NewShape * >::iterator result;
12459 PyObject * obj0 = 0 ;
12461 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
12462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12463 if (!SWIG_IsOK(res1)) {
12464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12466 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12467 result = (arg1)->end();
12468 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12469 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12476 SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477 PyObject *resultobj = 0;
12478 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12479 std::vector<Hex::NewShape * >::const_iterator result;
12482 PyObject * obj0 = 0 ;
12484 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
12485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12489 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12490 result = ((std::vector<Hex::NewShape * > const *)arg1)->end();
12491 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
12492 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12499 SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *self, PyObject *args) {
12504 if (!PyTuple_Check(args)) SWIG_fail;
12505 argc = PyObject_Length(args);
12506 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12507 argv[ii] = PyTuple_GET_ITEM(args,ii);
12511 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12512 _v = SWIG_CheckState(res);
12514 return _wrap_VectorShapes_end__SWIG_0(self, args);
12519 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12520 _v = SWIG_CheckState(res);
12522 return _wrap_VectorShapes_end__SWIG_1(self, args);
12527 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
12532 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12533 PyObject *resultobj = 0;
12534 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12535 std::vector<Hex::NewShape * >::reverse_iterator result;
12538 PyObject * obj0 = 0 ;
12540 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
12541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12542 if (!SWIG_IsOK(res1)) {
12543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12545 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12546 result = (arg1)->rbegin();
12547 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
12548 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12555 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12556 PyObject *resultobj = 0;
12557 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12558 std::vector<Hex::NewShape * >::const_reverse_iterator result;
12561 PyObject * obj0 = 0 ;
12563 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
12564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12565 if (!SWIG_IsOK(res1)) {
12566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12568 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12569 result = ((std::vector<Hex::NewShape * > const *)arg1)->rbegin();
12570 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
12571 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12578 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *self, PyObject *args) {
12583 if (!PyTuple_Check(args)) SWIG_fail;
12584 argc = PyObject_Length(args);
12585 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12586 argv[ii] = PyTuple_GET_ITEM(args,ii);
12590 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12591 _v = SWIG_CheckState(res);
12593 return _wrap_VectorShapes_rbegin__SWIG_0(self, args);
12598 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12599 _v = SWIG_CheckState(res);
12601 return _wrap_VectorShapes_rbegin__SWIG_1(self, args);
12606 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
12611 SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612 PyObject *resultobj = 0;
12613 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12614 std::vector<Hex::NewShape * >::reverse_iterator result;
12617 PyObject * obj0 = 0 ;
12619 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
12620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12621 if (!SWIG_IsOK(res1)) {
12622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12624 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12625 result = (arg1)->rend();
12626 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
12627 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12634 SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12635 PyObject *resultobj = 0;
12636 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12637 std::vector<Hex::NewShape * >::const_reverse_iterator result;
12640 PyObject * obj0 = 0 ;
12642 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
12643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12644 if (!SWIG_IsOK(res1)) {
12645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12647 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12648 result = ((std::vector<Hex::NewShape * > const *)arg1)->rend();
12649 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
12650 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12657 SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *self, PyObject *args) {
12662 if (!PyTuple_Check(args)) SWIG_fail;
12663 argc = PyObject_Length(args);
12664 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12665 argv[ii] = PyTuple_GET_ITEM(args,ii);
12669 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12670 _v = SWIG_CheckState(res);
12672 return _wrap_VectorShapes_rend__SWIG_0(self, args);
12677 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12678 _v = SWIG_CheckState(res);
12680 return _wrap_VectorShapes_rend__SWIG_1(self, args);
12685 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
12690 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12691 PyObject *resultobj = 0;
12692 std::vector<Hex::NewShape * >::size_type arg1 ;
12693 std::vector<Hex::NewShape * > *result = 0 ;
12696 PyObject * obj0 = 0 ;
12698 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
12699 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12700 if (!SWIG_IsOK(ecode1)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12703 arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
12704 result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1);
12705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
12712 SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *resultobj = 0;
12714 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12717 PyObject * obj0 = 0 ;
12719 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
12720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12721 if (!SWIG_IsOK(res1)) {
12722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12724 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12725 (arg1)->pop_back();
12726 resultobj = SWIG_Py_Void();
12733 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12736 std::vector<Hex::NewShape * >::size_type arg2 ;
12741 PyObject * obj0 = 0 ;
12742 PyObject * obj1 = 0 ;
12744 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
12745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12749 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12750 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12751 if (!SWIG_IsOK(ecode2)) {
12752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12754 arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
12755 (arg1)->resize(arg2);
12756 resultobj = SWIG_Py_Void();
12763 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12766 std::vector<Hex::NewShape * >::iterator arg2 ;
12767 std::vector<Hex::NewShape * >::iterator result;
12770 swig::PySwigIterator *iter2 = 0 ;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12775 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
12776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12780 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12781 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
12782 if (!SWIG_IsOK(res2) || !iter2) {
12783 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12785 swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
12787 arg2 = iter_t->get_current();
12789 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12792 result = (arg1)->erase(arg2);
12793 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12794 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12801 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12804 std::vector<Hex::NewShape * >::iterator arg2 ;
12805 std::vector<Hex::NewShape * >::iterator arg3 ;
12806 std::vector<Hex::NewShape * >::iterator result;
12809 swig::PySwigIterator *iter2 = 0 ;
12811 swig::PySwigIterator *iter3 = 0 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12817 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
12818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12819 if (!SWIG_IsOK(res1)) {
12820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12822 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12823 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
12824 if (!SWIG_IsOK(res2) || !iter2) {
12825 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12827 swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
12829 arg2 = iter_t->get_current();
12831 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12834 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
12835 if (!SWIG_IsOK(res3) || !iter3) {
12836 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12838 swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter3);
12840 arg3 = iter_t->get_current();
12842 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12845 result = (arg1)->erase(arg2,arg3);
12846 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12847 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12854 SWIGINTERN PyObject *_wrap_VectorShapes_erase(PyObject *self, PyObject *args) {
12859 if (!PyTuple_Check(args)) SWIG_fail;
12860 argc = PyObject_Length(args);
12861 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12862 argv[ii] = PyTuple_GET_ITEM(args,ii);
12866 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12867 _v = SWIG_CheckState(res);
12869 swig::PySwigIterator *iter = 0;
12870 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12871 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12873 return _wrap_VectorShapes_erase__SWIG_0(self, args);
12879 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12880 _v = SWIG_CheckState(res);
12882 swig::PySwigIterator *iter = 0;
12883 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12884 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12886 swig::PySwigIterator *iter = 0;
12887 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12888 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12890 return _wrap_VectorShapes_erase__SWIG_1(self, args);
12897 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::NewShape * >::iterator)\n erase(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::iterator)\n");
12902 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 std::vector<Hex::NewShape * >::size_type arg1 ;
12905 std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12906 std::vector<Hex::NewShape * > *result = 0 ;
12911 PyObject * obj0 = 0 ;
12912 PyObject * obj1 = 0 ;
12914 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
12915 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12916 if (!SWIG_IsOK(ecode1)) {
12917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12919 arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
12920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
12921 if (!SWIG_IsOK(res2)) {
12922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12924 arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
12925 result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1,arg2);
12926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
12933 SWIGINTERN PyObject *_wrap_new_VectorShapes(PyObject *self, PyObject *args) {
12938 if (!PyTuple_Check(args)) SWIG_fail;
12939 argc = PyObject_Length(args);
12940 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
12941 argv[ii] = PyTuple_GET_ITEM(args,ii);
12944 return _wrap_new_VectorShapes__SWIG_0(self, args);
12949 int res = SWIG_AsVal_size_t(argv[0], NULL);
12950 _v = SWIG_CheckState(res);
12953 return _wrap_new_VectorShapes__SWIG_2(self, args);
12958 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12959 _v = SWIG_CheckState(res);
12961 return _wrap_new_VectorShapes__SWIG_1(self, args);
12967 int res = SWIG_AsVal_size_t(argv[0], NULL);
12968 _v = SWIG_CheckState(res);
12972 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
12973 _v = SWIG_CheckState(res);
12975 return _wrap_new_VectorShapes__SWIG_3(self, args);
12981 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorShapes'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::NewShape)>()\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * > const &)\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type)\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
12986 SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12987 PyObject *resultobj = 0;
12988 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12989 std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12994 PyObject * obj0 = 0 ;
12995 PyObject * obj1 = 0 ;
12997 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
12998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
12999 if (!SWIG_IsOK(res1)) {
13000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13002 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13004 if (!SWIG_IsOK(res2)) {
13005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13007 arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
13008 (arg1)->push_back(arg2);
13009 resultobj = SWIG_Py_Void();
13016 SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13017 PyObject *resultobj = 0;
13018 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13019 std::vector<Hex::NewShape * >::value_type result;
13022 PyObject * obj0 = 0 ;
13024 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
13025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13026 if (!SWIG_IsOK(res1)) {
13027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13029 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13030 result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->front();
13031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13038 SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13039 PyObject *resultobj = 0;
13040 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13041 std::vector<Hex::NewShape * >::value_type result;
13044 PyObject * obj0 = 0 ;
13046 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
13047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13048 if (!SWIG_IsOK(res1)) {
13049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13051 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13052 result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->back();
13053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13060 SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13063 std::vector<Hex::NewShape * >::size_type arg2 ;
13064 std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 PyObject * obj2 = 0 ;
13075 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
13076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13080 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13081 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13082 if (!SWIG_IsOK(ecode2)) {
13083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13085 arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13086 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13087 if (!SWIG_IsOK(res3)) {
13088 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13090 arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13091 (arg1)->assign(arg2,arg3);
13092 resultobj = SWIG_Py_Void();
13099 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *resultobj = 0;
13101 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13102 std::vector<Hex::NewShape * >::size_type arg2 ;
13103 std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13110 PyObject * obj0 = 0 ;
13111 PyObject * obj1 = 0 ;
13112 PyObject * obj2 = 0 ;
13114 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
13115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13116 if (!SWIG_IsOK(res1)) {
13117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13119 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13120 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13121 if (!SWIG_IsOK(ecode2)) {
13122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13124 arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13125 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13126 if (!SWIG_IsOK(res3)) {
13127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13129 arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13130 (arg1)->resize(arg2,arg3);
13131 resultobj = SWIG_Py_Void();
13138 SWIGINTERN PyObject *_wrap_VectorShapes_resize(PyObject *self, PyObject *args) {
13143 if (!PyTuple_Check(args)) SWIG_fail;
13144 argc = PyObject_Length(args);
13145 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
13146 argv[ii] = PyTuple_GET_ITEM(args,ii);
13150 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13151 _v = SWIG_CheckState(res);
13154 int res = SWIG_AsVal_size_t(argv[1], NULL);
13155 _v = SWIG_CheckState(res);
13158 return _wrap_VectorShapes_resize__SWIG_0(self, args);
13164 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13165 _v = SWIG_CheckState(res);
13168 int res = SWIG_AsVal_size_t(argv[1], NULL);
13169 _v = SWIG_CheckState(res);
13173 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13174 _v = SWIG_CheckState(res);
13176 return _wrap_VectorShapes_resize__SWIG_1(self, args);
13183 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::NewShape * >::size_type)\n resize(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
13188 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13189 PyObject *resultobj = 0;
13190 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13191 std::vector<Hex::NewShape * >::iterator arg2 ;
13192 std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13193 std::vector<Hex::NewShape * >::iterator result;
13196 swig::PySwigIterator *iter2 = 0 ;
13200 PyObject * obj0 = 0 ;
13201 PyObject * obj1 = 0 ;
13202 PyObject * obj2 = 0 ;
13204 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
13205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13206 if (!SWIG_IsOK(res1)) {
13207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13209 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13210 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
13211 if (!SWIG_IsOK(res2) || !iter2) {
13212 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13214 swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
13216 arg2 = iter_t->get_current();
13218 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13221 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13222 if (!SWIG_IsOK(res3)) {
13223 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13225 arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13226 result = (arg1)->insert(arg2,arg3);
13227 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
13228 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
13235 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13236 PyObject *resultobj = 0;
13237 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13238 std::vector<Hex::NewShape * >::iterator arg2 ;
13239 std::vector<Hex::NewShape * >::size_type arg3 ;
13240 std::vector<Hex::NewShape * >::value_type arg4 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13243 swig::PySwigIterator *iter2 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 PyObject * obj1 = 0 ;
13251 PyObject * obj2 = 0 ;
13252 PyObject * obj3 = 0 ;
13254 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13259 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13260 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
13261 if (!SWIG_IsOK(res2) || !iter2) {
13262 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13264 swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
13266 arg2 = iter_t->get_current();
13268 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13271 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13272 if (!SWIG_IsOK(ecode3)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13275 arg3 = static_cast< std::vector<Hex::NewShape * >::size_type >(val3);
13276 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
13277 if (!SWIG_IsOK(res4)) {
13278 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13280 arg4 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp4);
13281 (arg1)->insert(arg2,arg3,arg4);
13282 resultobj = SWIG_Py_Void();
13289 SWIGINTERN PyObject *_wrap_VectorShapes_insert(PyObject *self, PyObject *args) {
13294 if (!PyTuple_Check(args)) SWIG_fail;
13295 argc = PyObject_Length(args);
13296 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
13297 argv[ii] = PyTuple_GET_ITEM(args,ii);
13301 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13302 _v = SWIG_CheckState(res);
13304 swig::PySwigIterator *iter = 0;
13305 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
13306 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
13309 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13310 _v = SWIG_CheckState(res);
13312 return _wrap_VectorShapes_insert__SWIG_0(self, args);
13319 int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13320 _v = SWIG_CheckState(res);
13322 swig::PySwigIterator *iter = 0;
13323 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
13324 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
13327 int res = SWIG_AsVal_size_t(argv[2], NULL);
13328 _v = SWIG_CheckState(res);
13332 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13333 _v = SWIG_CheckState(res);
13335 return _wrap_VectorShapes_insert__SWIG_1(self, args);
13343 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::value_type)\n insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
13348 SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13349 PyObject *resultobj = 0;
13350 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13351 std::vector<Hex::NewShape * >::size_type arg2 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13359 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
13360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13361 if (!SWIG_IsOK(res1)) {
13362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13364 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13365 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13366 if (!SWIG_IsOK(ecode2)) {
13367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13369 arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13370 (arg1)->reserve(arg2);
13371 resultobj = SWIG_Py_Void();
13378 SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13379 PyObject *resultobj = 0;
13380 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13381 std::vector<Hex::NewShape * >::size_type result;
13384 PyObject * obj0 = 0 ;
13386 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
13387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
13388 if (!SWIG_IsOK(res1)) {
13389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13391 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13392 result = ((std::vector<Hex::NewShape * > const *)arg1)->capacity();
13393 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13400 SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *resultobj = 0;
13402 std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13405 PyObject * obj0 = 0 ;
13407 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
13408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_DISOWN | 0 );
13409 if (!SWIG_IsOK(res1)) {
13410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13412 arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13415 resultobj = SWIG_Py_Void();
13422 SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13424 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
13425 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_NewClientData(obj));
13426 return SWIG_Py_Void();
13429 SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13430 PyObject *resultobj = 0;
13431 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13432 PyObject **arg2 = (PyObject **) 0 ;
13433 swig::PySwigIterator *result = 0 ;
13436 PyObject * obj0 = 0 ;
13439 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
13440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13441 if (!SWIG_IsOK(res1)) {
13442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector<double > *""'");
13444 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13445 result = (swig::PySwigIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
13446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
13453 SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *resultobj = 0;
13455 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13459 PyObject * obj0 = 0 ;
13461 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
13462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13466 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13467 result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector<double > const *)arg1);
13468 resultobj = SWIG_From_bool(static_cast< bool >(result));
13475 SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13476 PyObject *resultobj = 0;
13477 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13478 std::vector<double >::size_type result;
13481 PyObject * obj0 = 0 ;
13483 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
13484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13485 if (!SWIG_IsOK(res1)) {
13486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13488 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13489 result = std_vector_Sl_double_Sg____len__((std::vector<double > const *)arg1);
13490 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13497 SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13498 PyObject *resultobj = 0;
13499 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13500 std::vector<double >::value_type result;
13503 PyObject * obj0 = 0 ;
13505 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
13506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13507 if (!SWIG_IsOK(res1)) {
13508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector<double > *""'");
13510 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13512 result = (std::vector<double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
13514 catch(std::out_of_range &_e) {
13515 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13518 resultobj = SWIG_From_double(static_cast< double >(result));
13525 SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13526 PyObject *resultobj = 0;
13527 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13528 std::vector<double >::difference_type arg2 ;
13529 std::vector<double >::difference_type arg3 ;
13530 std::vector<double,std::allocator<double > > *result = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13541 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
13542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13543 if (!SWIG_IsOK(res1)) {
13544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13546 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13547 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13548 if (!SWIG_IsOK(ecode2)) {
13549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13551 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13552 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13553 if (!SWIG_IsOK(ecode3)) {
13554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13556 arg3 = static_cast< std::vector<double >::difference_type >(val3);
13558 result = (std::vector<double,std::allocator<double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
13560 catch(std::out_of_range &_e) {
13561 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_OWN | 0 );
13571 SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13572 PyObject *resultobj = 0;
13573 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13574 std::vector<double >::difference_type arg2 ;
13575 std::vector<double >::difference_type arg3 ;
13576 std::vector<double,std::allocator<double > > *arg4 = 0 ;
13583 int res4 = SWIG_OLDOBJ ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 PyObject * obj2 = 0 ;
13587 PyObject * obj3 = 0 ;
13589 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13594 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13595 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13596 if (!SWIG_IsOK(ecode2)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13599 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13600 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13601 if (!SWIG_IsOK(ecode3)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13604 arg3 = static_cast< std::vector<double >::difference_type >(val3);
13606 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
13607 res4 = swig::asptr(obj3, &ptr);
13608 if (!SWIG_IsOK(res4)) {
13609 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
13612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
13617 std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector<double,std::allocator<double > > const &)*arg4);
13619 catch(std::out_of_range &_e) {
13620 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13622 catch(std::invalid_argument &_e) {
13623 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
13626 resultobj = SWIG_Py_Void();
13627 if (SWIG_IsNewObj(res4)) delete arg4;
13630 if (SWIG_IsNewObj(res4)) delete arg4;
13635 SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13636 PyObject *resultobj = 0;
13637 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13638 std::vector<double >::difference_type arg2 ;
13639 std::vector<double >::difference_type arg3 ;
13646 PyObject * obj0 = 0 ;
13647 PyObject * obj1 = 0 ;
13648 PyObject * obj2 = 0 ;
13650 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
13651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13652 if (!SWIG_IsOK(res1)) {
13653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13655 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13656 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13657 if (!SWIG_IsOK(ecode2)) {
13658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13660 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13661 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13662 if (!SWIG_IsOK(ecode3)) {
13663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13665 arg3 = static_cast< std::vector<double >::difference_type >(val3);
13667 std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
13669 catch(std::out_of_range &_e) {
13670 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13673 resultobj = SWIG_Py_Void();
13680 SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13681 PyObject *resultobj = 0;
13682 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13683 std::vector<double >::difference_type arg2 ;
13688 PyObject * obj0 = 0 ;
13689 PyObject * obj1 = 0 ;
13691 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
13692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13693 if (!SWIG_IsOK(res1)) {
13694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
13696 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13697 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13698 if (!SWIG_IsOK(ecode2)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13701 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13703 std_vector_Sl_double_Sg____delitem__(arg1,arg2);
13705 catch(std::out_of_range &_e) {
13706 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13709 resultobj = SWIG_Py_Void();
13716 SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13717 PyObject *resultobj = 0;
13718 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13719 std::vector<double >::difference_type arg2 ;
13720 std::vector<double >::value_type *result = 0 ;
13725 PyObject * obj0 = 0 ;
13726 PyObject * obj1 = 0 ;
13728 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
13729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13730 if (!SWIG_IsOK(res1)) {
13731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13733 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13734 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13735 if (!SWIG_IsOK(ecode2)) {
13736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13738 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13741 std::vector<double >::value_type const &_result_ref = std_vector_Sl_double_Sg____getitem__((std::vector<double > const *)arg1,arg2);
13742 result = (std::vector<double >::value_type *) &_result_ref;
13745 catch(std::out_of_range &_e) {
13746 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13749 resultobj = SWIG_From_double(static_cast< double >(*result));
13756 SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13757 PyObject *resultobj = 0;
13758 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13759 std::vector<double >::difference_type arg2 ;
13760 std::vector<double >::value_type *arg3 = 0 ;
13765 std::vector<double >::value_type temp3 ;
13768 PyObject * obj0 = 0 ;
13769 PyObject * obj1 = 0 ;
13770 PyObject * obj2 = 0 ;
13772 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
13773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13774 if (!SWIG_IsOK(res1)) {
13775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
13777 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13778 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13779 if (!SWIG_IsOK(ecode2)) {
13780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13782 arg2 = static_cast< std::vector<double >::difference_type >(val2);
13783 ecode3 = SWIG_AsVal_double(obj2, &val3);
13784 if (!SWIG_IsOK(ecode3)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
13787 temp3 = static_cast< std::vector<double >::value_type >(val3);
13790 std_vector_Sl_double_Sg____setitem__(arg1,arg2,(double const &)*arg3);
13792 catch(std::out_of_range &_e) {
13793 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13796 resultobj = SWIG_Py_Void();
13803 SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13804 PyObject *resultobj = 0;
13805 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13806 std::vector<double >::value_type *arg2 = 0 ;
13809 std::vector<double >::value_type temp2 ;
13812 PyObject * obj0 = 0 ;
13813 PyObject * obj1 = 0 ;
13815 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
13816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13817 if (!SWIG_IsOK(res1)) {
13818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector<double > *""'");
13820 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13821 ecode2 = SWIG_AsVal_double(obj1, &val2);
13822 if (!SWIG_IsOK(ecode2)) {
13823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
13825 temp2 = static_cast< std::vector<double >::value_type >(val2);
13827 std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
13828 resultobj = SWIG_Py_Void();
13835 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13836 PyObject *resultobj = 0;
13837 std::vector<double > *result = 0 ;
13839 if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
13840 result = (std::vector<double > *)new std::vector<double >();
13841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
13848 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13849 PyObject *resultobj = 0;
13850 std::vector<double > *arg1 = 0 ;
13851 std::vector<double > *result = 0 ;
13852 int res1 = SWIG_OLDOBJ ;
13853 PyObject * obj0 = 0 ;
13855 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
13857 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
13858 res1 = swig::asptr(obj0, &ptr);
13859 if (!SWIG_IsOK(res1)) {
13860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
13863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
13867 result = (std::vector<double > *)new std::vector<double >((std::vector<double > const &)*arg1);
13868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
13869 if (SWIG_IsNewObj(res1)) delete arg1;
13872 if (SWIG_IsNewObj(res1)) delete arg1;
13877 SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13878 PyObject *resultobj = 0;
13879 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13883 PyObject * obj0 = 0 ;
13885 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
13886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13887 if (!SWIG_IsOK(res1)) {
13888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector<double > const *""'");
13890 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13891 result = (bool)((std::vector<double > const *)arg1)->empty();
13892 resultobj = SWIG_From_bool(static_cast< bool >(result));
13899 SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13900 PyObject *resultobj = 0;
13901 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13902 std::vector<double >::size_type result;
13905 PyObject * obj0 = 0 ;
13907 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
13908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13909 if (!SWIG_IsOK(res1)) {
13910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector<double > const *""'");
13912 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13913 result = ((std::vector<double > const *)arg1)->size();
13914 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13921 SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13922 PyObject *resultobj = 0;
13923 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13926 PyObject * obj0 = 0 ;
13928 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
13929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13930 if (!SWIG_IsOK(res1)) {
13931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector<double > *""'");
13933 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13935 resultobj = SWIG_Py_Void();
13942 SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13943 PyObject *resultobj = 0;
13944 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13945 std::vector<double > *arg2 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13953 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
13954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector<double > *""'");
13958 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
13960 if (!SWIG_IsOK(res2)) {
13961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
13964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
13966 arg2 = reinterpret_cast< std::vector<double > * >(argp2);
13967 (arg1)->swap(*arg2);
13968 resultobj = SWIG_Py_Void();
13975 SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13976 PyObject *resultobj = 0;
13977 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13978 SwigValueWrapper<std::allocator<double > > result;
13981 PyObject * obj0 = 0 ;
13983 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
13984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
13985 if (!SWIG_IsOK(res1)) {
13986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector<double > const *""'");
13988 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13989 result = ((std::vector<double > const *)arg1)->get_allocator();
13990 resultobj = SWIG_NewPointerObj((new std::vector<double >::allocator_type(static_cast< const std::vector<double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
13997 SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13998 PyObject *resultobj = 0;
13999 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14000 std::vector<double >::iterator result;
14003 PyObject * obj0 = 0 ;
14005 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
14006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14007 if (!SWIG_IsOK(res1)) {
14008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > *""'");
14010 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14011 result = (arg1)->begin();
14012 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14013 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14020 SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14021 PyObject *resultobj = 0;
14022 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14023 std::vector<double >::const_iterator result;
14026 PyObject * obj0 = 0 ;
14028 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
14029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14030 if (!SWIG_IsOK(res1)) {
14031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > const *""'");
14033 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14034 result = ((std::vector<double > const *)arg1)->begin();
14035 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
14036 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14043 SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *self, PyObject *args) {
14048 if (!PyTuple_Check(args)) SWIG_fail;
14049 argc = PyObject_Length(args);
14050 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14051 argv[ii] = PyTuple_GET_ITEM(args,ii);
14055 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14056 _v = SWIG_CheckState(res);
14058 return _wrap_VectorReal_begin__SWIG_0(self, args);
14063 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14064 _v = SWIG_CheckState(res);
14066 return _wrap_VectorReal_begin__SWIG_1(self, args);
14071 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
14076 SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14077 PyObject *resultobj = 0;
14078 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14079 std::vector<double >::iterator result;
14082 PyObject * obj0 = 0 ;
14084 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
14085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14086 if (!SWIG_IsOK(res1)) {
14087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > *""'");
14089 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14090 result = (arg1)->end();
14091 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14092 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14099 SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14100 PyObject *resultobj = 0;
14101 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14102 std::vector<double >::const_iterator result;
14105 PyObject * obj0 = 0 ;
14107 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > const *""'");
14112 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14113 result = ((std::vector<double > const *)arg1)->end();
14114 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
14115 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14122 SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *self, PyObject *args) {
14127 if (!PyTuple_Check(args)) SWIG_fail;
14128 argc = PyObject_Length(args);
14129 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14130 argv[ii] = PyTuple_GET_ITEM(args,ii);
14134 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14135 _v = SWIG_CheckState(res);
14137 return _wrap_VectorReal_end__SWIG_0(self, args);
14142 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14143 _v = SWIG_CheckState(res);
14145 return _wrap_VectorReal_end__SWIG_1(self, args);
14150 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
14155 SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14156 PyObject *resultobj = 0;
14157 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14158 std::vector<double >::reverse_iterator result;
14161 PyObject * obj0 = 0 ;
14163 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > *""'");
14168 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14169 result = (arg1)->rbegin();
14170 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
14171 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14178 SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14179 PyObject *resultobj = 0;
14180 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14181 std::vector<double >::const_reverse_iterator result;
14184 PyObject * obj0 = 0 ;
14186 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
14187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14188 if (!SWIG_IsOK(res1)) {
14189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > const *""'");
14191 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14192 result = ((std::vector<double > const *)arg1)->rbegin();
14193 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
14194 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14201 SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *self, PyObject *args) {
14206 if (!PyTuple_Check(args)) SWIG_fail;
14207 argc = PyObject_Length(args);
14208 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14209 argv[ii] = PyTuple_GET_ITEM(args,ii);
14213 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14214 _v = SWIG_CheckState(res);
14216 return _wrap_VectorReal_rbegin__SWIG_0(self, args);
14221 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14222 _v = SWIG_CheckState(res);
14224 return _wrap_VectorReal_rbegin__SWIG_1(self, args);
14229 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
14234 SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14235 PyObject *resultobj = 0;
14236 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14237 std::vector<double >::reverse_iterator result;
14240 PyObject * obj0 = 0 ;
14242 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
14243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > *""'");
14247 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14248 result = (arg1)->rend();
14249 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
14250 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14257 SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258 PyObject *resultobj = 0;
14259 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14260 std::vector<double >::const_reverse_iterator result;
14263 PyObject * obj0 = 0 ;
14265 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
14266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14267 if (!SWIG_IsOK(res1)) {
14268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > const *""'");
14270 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14271 result = ((std::vector<double > const *)arg1)->rend();
14272 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
14273 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14280 SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *self, PyObject *args) {
14285 if (!PyTuple_Check(args)) SWIG_fail;
14286 argc = PyObject_Length(args);
14287 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14288 argv[ii] = PyTuple_GET_ITEM(args,ii);
14292 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14293 _v = SWIG_CheckState(res);
14295 return _wrap_VectorReal_rend__SWIG_0(self, args);
14300 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14301 _v = SWIG_CheckState(res);
14303 return _wrap_VectorReal_rend__SWIG_1(self, args);
14308 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
14313 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14314 PyObject *resultobj = 0;
14315 std::vector<double >::size_type arg1 ;
14316 std::vector<double > *result = 0 ;
14319 PyObject * obj0 = 0 ;
14321 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
14322 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
14323 if (!SWIG_IsOK(ecode1)) {
14324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
14326 arg1 = static_cast< std::vector<double >::size_type >(val1);
14327 result = (std::vector<double > *)new std::vector<double >(arg1);
14328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
14335 SWIGINTERN PyObject *_wrap_VectorReal_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14336 PyObject *resultobj = 0;
14337 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14340 PyObject * obj0 = 0 ;
14342 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
14343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14344 if (!SWIG_IsOK(res1)) {
14345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector<double > *""'");
14347 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14348 (arg1)->pop_back();
14349 resultobj = SWIG_Py_Void();
14356 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14357 PyObject *resultobj = 0;
14358 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14359 std::vector<double >::size_type arg2 ;
14364 PyObject * obj0 = 0 ;
14365 PyObject * obj1 = 0 ;
14367 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
14368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
14372 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14374 if (!SWIG_IsOK(ecode2)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14377 arg2 = static_cast< std::vector<double >::size_type >(val2);
14378 (arg1)->resize(arg2);
14379 resultobj = SWIG_Py_Void();
14386 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14387 PyObject *resultobj = 0;
14388 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14389 std::vector<double >::iterator arg2 ;
14390 std::vector<double >::iterator result;
14393 swig::PySwigIterator *iter2 = 0 ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14398 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
14399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
14403 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14404 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14405 if (!SWIG_IsOK(res2) || !iter2) {
14406 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14408 swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14410 arg2 = iter_t->get_current();
14412 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14415 result = (arg1)->erase(arg2);
14416 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14417 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14424 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14425 PyObject *resultobj = 0;
14426 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14427 std::vector<double >::iterator arg2 ;
14428 std::vector<double >::iterator arg3 ;
14429 std::vector<double >::iterator result;
14432 swig::PySwigIterator *iter2 = 0 ;
14434 swig::PySwigIterator *iter3 = 0 ;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14440 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
14441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14442 if (!SWIG_IsOK(res1)) {
14443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
14445 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14446 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14447 if (!SWIG_IsOK(res2) || !iter2) {
14448 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14450 swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14452 arg2 = iter_t->get_current();
14454 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14457 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
14458 if (!SWIG_IsOK(res3) || !iter3) {
14459 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
14461 swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter3);
14463 arg3 = iter_t->get_current();
14465 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
14468 result = (arg1)->erase(arg2,arg3);
14469 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14470 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14477 SWIGINTERN PyObject *_wrap_VectorReal_erase(PyObject *self, PyObject *args) {
14482 if (!PyTuple_Check(args)) SWIG_fail;
14483 argc = PyObject_Length(args);
14484 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14485 argv[ii] = PyTuple_GET_ITEM(args,ii);
14489 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14490 _v = SWIG_CheckState(res);
14492 swig::PySwigIterator *iter = 0;
14493 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14494 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14496 return _wrap_VectorReal_erase__SWIG_0(self, args);
14502 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14503 _v = SWIG_CheckState(res);
14505 swig::PySwigIterator *iter = 0;
14506 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14507 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14509 swig::PySwigIterator *iter = 0;
14510 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14511 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14513 return _wrap_VectorReal_erase__SWIG_1(self, args);
14520 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<double >::iterator)\n erase(std::vector<double >::iterator,std::vector<double >::iterator)\n");
14525 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14526 PyObject *resultobj = 0;
14527 std::vector<double >::size_type arg1 ;
14528 std::vector<double >::value_type *arg2 = 0 ;
14529 std::vector<double > *result = 0 ;
14532 std::vector<double >::value_type temp2 ;
14535 PyObject * obj0 = 0 ;
14536 PyObject * obj1 = 0 ;
14538 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
14539 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
14540 if (!SWIG_IsOK(ecode1)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
14543 arg1 = static_cast< std::vector<double >::size_type >(val1);
14544 ecode2 = SWIG_AsVal_double(obj1, &val2);
14545 if (!SWIG_IsOK(ecode2)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
14548 temp2 = static_cast< std::vector<double >::value_type >(val2);
14550 result = (std::vector<double > *)new std::vector<double >(arg1,(std::vector<double >::value_type const &)*arg2);
14551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
14558 SWIGINTERN PyObject *_wrap_new_VectorReal(PyObject *self, PyObject *args) {
14563 if (!PyTuple_Check(args)) SWIG_fail;
14564 argc = PyObject_Length(args);
14565 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
14566 argv[ii] = PyTuple_GET_ITEM(args,ii);
14569 return _wrap_new_VectorReal__SWIG_0(self, args);
14574 int res = SWIG_AsVal_size_t(argv[0], NULL);
14575 _v = SWIG_CheckState(res);
14578 return _wrap_new_VectorReal__SWIG_2(self, args);
14583 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14584 _v = SWIG_CheckState(res);
14586 return _wrap_new_VectorReal__SWIG_1(self, args);
14592 int res = SWIG_AsVal_size_t(argv[0], NULL);
14593 _v = SWIG_CheckState(res);
14597 int res = SWIG_AsVal_double(argv[1], NULL);
14598 _v = SWIG_CheckState(res);
14601 return _wrap_new_VectorReal__SWIG_3(self, args);
14607 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorReal'.\n Possible C/C++ prototypes are:\n std::vector<(double)>()\n std::vector<(double)>(std::vector<double > const &)\n std::vector<(double)>(std::vector<double >::size_type)\n std::vector<(double)>(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14612 SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14613 PyObject *resultobj = 0;
14614 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14615 std::vector<double >::value_type *arg2 = 0 ;
14618 std::vector<double >::value_type temp2 ;
14621 PyObject * obj0 = 0 ;
14622 PyObject * obj1 = 0 ;
14624 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
14625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14626 if (!SWIG_IsOK(res1)) {
14627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector<double > *""'");
14629 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14630 ecode2 = SWIG_AsVal_double(obj1, &val2);
14631 if (!SWIG_IsOK(ecode2)) {
14632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
14634 temp2 = static_cast< std::vector<double >::value_type >(val2);
14636 (arg1)->push_back((std::vector<double >::value_type const &)*arg2);
14637 resultobj = SWIG_Py_Void();
14644 SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14645 PyObject *resultobj = 0;
14646 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14647 std::vector<double >::value_type *result = 0 ;
14650 PyObject * obj0 = 0 ;
14652 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
14653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14654 if (!SWIG_IsOK(res1)) {
14655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector<double > const *""'");
14657 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14659 std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->front();
14660 result = (std::vector<double >::value_type *) &_result_ref;
14662 resultobj = SWIG_From_double(static_cast< double >(*result));
14669 SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670 PyObject *resultobj = 0;
14671 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14672 std::vector<double >::value_type *result = 0 ;
14675 PyObject * obj0 = 0 ;
14677 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
14678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14679 if (!SWIG_IsOK(res1)) {
14680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector<double > const *""'");
14682 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14684 std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->back();
14685 result = (std::vector<double >::value_type *) &_result_ref;
14687 resultobj = SWIG_From_double(static_cast< double >(*result));
14694 SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695 PyObject *resultobj = 0;
14696 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14697 std::vector<double >::size_type arg2 ;
14698 std::vector<double >::value_type *arg3 = 0 ;
14703 std::vector<double >::value_type temp3 ;
14706 PyObject * obj0 = 0 ;
14707 PyObject * obj1 = 0 ;
14708 PyObject * obj2 = 0 ;
14710 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
14711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector<double > *""'");
14715 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14716 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14717 if (!SWIG_IsOK(ecode2)) {
14718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14720 arg2 = static_cast< std::vector<double >::size_type >(val2);
14721 ecode3 = SWIG_AsVal_double(obj2, &val3);
14722 if (!SWIG_IsOK(ecode3)) {
14723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14725 temp3 = static_cast< std::vector<double >::value_type >(val3);
14727 (arg1)->assign(arg2,(std::vector<double >::value_type const &)*arg3);
14728 resultobj = SWIG_Py_Void();
14735 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14736 PyObject *resultobj = 0;
14737 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14738 std::vector<double >::size_type arg2 ;
14739 std::vector<double >::value_type *arg3 = 0 ;
14744 std::vector<double >::value_type temp3 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14751 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
14752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14753 if (!SWIG_IsOK(res1)) {
14754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
14756 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14757 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14758 if (!SWIG_IsOK(ecode2)) {
14759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14761 arg2 = static_cast< std::vector<double >::size_type >(val2);
14762 ecode3 = SWIG_AsVal_double(obj2, &val3);
14763 if (!SWIG_IsOK(ecode3)) {
14764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14766 temp3 = static_cast< std::vector<double >::value_type >(val3);
14768 (arg1)->resize(arg2,(std::vector<double >::value_type const &)*arg3);
14769 resultobj = SWIG_Py_Void();
14776 SWIGINTERN PyObject *_wrap_VectorReal_resize(PyObject *self, PyObject *args) {
14781 if (!PyTuple_Check(args)) SWIG_fail;
14782 argc = PyObject_Length(args);
14783 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14784 argv[ii] = PyTuple_GET_ITEM(args,ii);
14788 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14789 _v = SWIG_CheckState(res);
14792 int res = SWIG_AsVal_size_t(argv[1], NULL);
14793 _v = SWIG_CheckState(res);
14796 return _wrap_VectorReal_resize__SWIG_0(self, args);
14802 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14803 _v = SWIG_CheckState(res);
14806 int res = SWIG_AsVal_size_t(argv[1], NULL);
14807 _v = SWIG_CheckState(res);
14811 int res = SWIG_AsVal_double(argv[2], NULL);
14812 _v = SWIG_CheckState(res);
14815 return _wrap_VectorReal_resize__SWIG_1(self, args);
14822 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<double >::size_type)\n resize(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14827 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14828 PyObject *resultobj = 0;
14829 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14830 std::vector<double >::iterator arg2 ;
14831 std::vector<double >::value_type *arg3 = 0 ;
14832 std::vector<double >::iterator result;
14835 swig::PySwigIterator *iter2 = 0 ;
14837 std::vector<double >::value_type temp3 ;
14840 PyObject * obj0 = 0 ;
14841 PyObject * obj1 = 0 ;
14842 PyObject * obj2 = 0 ;
14844 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
14845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14846 if (!SWIG_IsOK(res1)) {
14847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
14849 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14850 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14851 if (!SWIG_IsOK(res2) || !iter2) {
14852 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14854 swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14856 arg2 = iter_t->get_current();
14858 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14861 ecode3 = SWIG_AsVal_double(obj2, &val3);
14862 if (!SWIG_IsOK(ecode3)) {
14863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14865 temp3 = static_cast< std::vector<double >::value_type >(val3);
14867 result = (arg1)->insert(arg2,(std::vector<double >::value_type const &)*arg3);
14868 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14869 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14876 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14877 PyObject *resultobj = 0;
14878 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14879 std::vector<double >::iterator arg2 ;
14880 std::vector<double >::size_type arg3 ;
14881 std::vector<double >::value_type *arg4 = 0 ;
14884 swig::PySwigIterator *iter2 = 0 ;
14888 std::vector<double >::value_type temp4 ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 PyObject * obj2 = 0 ;
14894 PyObject * obj3 = 0 ;
14896 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
14898 if (!SWIG_IsOK(res1)) {
14899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
14901 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14902 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14903 if (!SWIG_IsOK(res2) || !iter2) {
14904 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14906 swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14908 arg2 = iter_t->get_current();
14910 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14913 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14914 if (!SWIG_IsOK(ecode3)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::size_type""'");
14917 arg3 = static_cast< std::vector<double >::size_type >(val3);
14918 ecode4 = SWIG_AsVal_double(obj3, &val4);
14919 if (!SWIG_IsOK(ecode4)) {
14920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector<double >::value_type""'");
14922 temp4 = static_cast< std::vector<double >::value_type >(val4);
14924 (arg1)->insert(arg2,arg3,(std::vector<double >::value_type const &)*arg4);
14925 resultobj = SWIG_Py_Void();
14932 SWIGINTERN PyObject *_wrap_VectorReal_insert(PyObject *self, PyObject *args) {
14937 if (!PyTuple_Check(args)) SWIG_fail;
14938 argc = PyObject_Length(args);
14939 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
14940 argv[ii] = PyTuple_GET_ITEM(args,ii);
14944 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14945 _v = SWIG_CheckState(res);
14947 swig::PySwigIterator *iter = 0;
14948 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14949 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14952 int res = SWIG_AsVal_double(argv[2], NULL);
14953 _v = SWIG_CheckState(res);
14956 return _wrap_VectorReal_insert__SWIG_0(self, args);
14963 int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14964 _v = SWIG_CheckState(res);
14966 swig::PySwigIterator *iter = 0;
14967 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14968 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14971 int res = SWIG_AsVal_size_t(argv[2], NULL);
14972 _v = SWIG_CheckState(res);
14976 int res = SWIG_AsVal_double(argv[3], NULL);
14977 _v = SWIG_CheckState(res);
14980 return _wrap_VectorReal_insert__SWIG_1(self, args);
14988 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<double >::iterator,std::vector<double >::value_type const &)\n insert(std::vector<double >::iterator,std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14993 SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 PyObject *resultobj = 0;
14995 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14996 std::vector<double >::size_type arg2 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15004 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
15005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
15006 if (!SWIG_IsOK(res1)) {
15007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector<double > *""'");
15009 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15010 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15011 if (!SWIG_IsOK(ecode2)) {
15012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
15014 arg2 = static_cast< std::vector<double >::size_type >(val2);
15015 (arg1)->reserve(arg2);
15016 resultobj = SWIG_Py_Void();
15023 SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024 PyObject *resultobj = 0;
15025 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
15026 std::vector<double >::size_type result;
15029 PyObject * obj0 = 0 ;
15031 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
15032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
15033 if (!SWIG_IsOK(res1)) {
15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector<double > const *""'");
15036 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15037 result = ((std::vector<double > const *)arg1)->capacity();
15038 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15045 SWIGINTERN PyObject *_wrap_delete_VectorReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *resultobj = 0;
15047 std::vector<double > *arg1 = (std::vector<double > *) 0 ;
15050 PyObject * obj0 = 0 ;
15052 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
15053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_DISOWN | 0 );
15054 if (!SWIG_IsOK(res1)) {
15055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector<double > *""'");
15057 arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15060 resultobj = SWIG_Py_Void();
15067 SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15069 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
15070 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_NewClientData(obj));
15071 return SWIG_Py_Void();
15074 SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075 PyObject *resultobj = 0;
15076 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15077 PyObject **arg2 = (PyObject **) 0 ;
15078 swig::PySwigIterator *result = 0 ;
15081 PyObject * obj0 = 0 ;
15084 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
15085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector<int > *""'");
15089 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15090 result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
15091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
15098 SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *resultobj = 0;
15100 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15104 PyObject * obj0 = 0 ;
15106 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
15107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15108 if (!SWIG_IsOK(res1)) {
15109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15111 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15112 result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector<int > const *)arg1);
15113 resultobj = SWIG_From_bool(static_cast< bool >(result));
15120 SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15121 PyObject *resultobj = 0;
15122 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15123 std::vector<int >::size_type result;
15126 PyObject * obj0 = 0 ;
15128 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
15129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15130 if (!SWIG_IsOK(res1)) {
15131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15133 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15134 result = std_vector_Sl_int_Sg____len__((std::vector<int > const *)arg1);
15135 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15142 SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 PyObject *resultobj = 0;
15144 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15145 std::vector<int >::value_type result;
15148 PyObject * obj0 = 0 ;
15150 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
15151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15152 if (!SWIG_IsOK(res1)) {
15153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector<int > *""'");
15155 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15157 result = (std::vector<int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
15159 catch(std::out_of_range &_e) {
15160 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15163 resultobj = SWIG_From_int(static_cast< int >(result));
15170 SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171 PyObject *resultobj = 0;
15172 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15173 std::vector<int >::difference_type arg2 ;
15174 std::vector<int >::difference_type arg3 ;
15175 std::vector<int,std::allocator<int > > *result = 0 ;
15182 PyObject * obj0 = 0 ;
15183 PyObject * obj1 = 0 ;
15184 PyObject * obj2 = 0 ;
15186 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
15187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15188 if (!SWIG_IsOK(res1)) {
15189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15191 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15192 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15193 if (!SWIG_IsOK(ecode2)) {
15194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15196 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15197 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15198 if (!SWIG_IsOK(ecode3)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15201 arg3 = static_cast< std::vector<int >::difference_type >(val3);
15203 result = (std::vector<int,std::allocator<int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
15205 catch(std::out_of_range &_e) {
15206 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_OWN | 0 );
15216 SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15219 std::vector<int >::difference_type arg2 ;
15220 std::vector<int >::difference_type arg3 ;
15221 std::vector<int,std::allocator<int > > *arg4 = 0 ;
15228 int res4 = SWIG_OLDOBJ ;
15229 PyObject * obj0 = 0 ;
15230 PyObject * obj1 = 0 ;
15231 PyObject * obj2 = 0 ;
15232 PyObject * obj3 = 0 ;
15234 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15239 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15240 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15241 if (!SWIG_IsOK(ecode2)) {
15242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15244 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15245 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15246 if (!SWIG_IsOK(ecode3)) {
15247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15249 arg3 = static_cast< std::vector<int >::difference_type >(val3);
15251 std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
15252 res4 = swig::asptr(obj3, &ptr);
15253 if (!SWIG_IsOK(res4)) {
15254 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
15257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
15262 std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector<int,std::allocator<int > > const &)*arg4);
15264 catch(std::out_of_range &_e) {
15265 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15267 catch(std::invalid_argument &_e) {
15268 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
15271 resultobj = SWIG_Py_Void();
15272 if (SWIG_IsNewObj(res4)) delete arg4;
15275 if (SWIG_IsNewObj(res4)) delete arg4;
15280 SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15283 std::vector<int >::difference_type arg2 ;
15284 std::vector<int >::difference_type arg3 ;
15291 PyObject * obj0 = 0 ;
15292 PyObject * obj1 = 0 ;
15293 PyObject * obj2 = 0 ;
15295 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
15296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15300 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15301 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15302 if (!SWIG_IsOK(ecode2)) {
15303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15305 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15306 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15307 if (!SWIG_IsOK(ecode3)) {
15308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15310 arg3 = static_cast< std::vector<int >::difference_type >(val3);
15312 std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
15314 catch(std::out_of_range &_e) {
15315 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15318 resultobj = SWIG_Py_Void();
15325 SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15326 PyObject *resultobj = 0;
15327 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15328 std::vector<int >::difference_type arg2 ;
15333 PyObject * obj0 = 0 ;
15334 PyObject * obj1 = 0 ;
15336 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
15337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
15341 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15342 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15343 if (!SWIG_IsOK(ecode2)) {
15344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15346 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15348 std_vector_Sl_int_Sg____delitem__(arg1,arg2);
15350 catch(std::out_of_range &_e) {
15351 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15354 resultobj = SWIG_Py_Void();
15361 SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15362 PyObject *resultobj = 0;
15363 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15364 std::vector<int >::difference_type arg2 ;
15365 std::vector<int >::value_type *result = 0 ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15373 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
15374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15378 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15379 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15380 if (!SWIG_IsOK(ecode2)) {
15381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15383 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15386 std::vector<int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector<int > const *)arg1,arg2);
15387 result = (std::vector<int >::value_type *) &_result_ref;
15390 catch(std::out_of_range &_e) {
15391 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15394 resultobj = SWIG_From_int(static_cast< int >(*result));
15401 SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15402 PyObject *resultobj = 0;
15403 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15404 std::vector<int >::difference_type arg2 ;
15405 std::vector<int >::value_type *arg3 = 0 ;
15410 std::vector<int >::value_type temp3 ;
15413 PyObject * obj0 = 0 ;
15414 PyObject * obj1 = 0 ;
15415 PyObject * obj2 = 0 ;
15417 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
15418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15419 if (!SWIG_IsOK(res1)) {
15420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
15422 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15423 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15424 if (!SWIG_IsOK(ecode2)) {
15425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15427 arg2 = static_cast< std::vector<int >::difference_type >(val2);
15428 ecode3 = SWIG_AsVal_int(obj2, &val3);
15429 if (!SWIG_IsOK(ecode3)) {
15430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
15432 temp3 = static_cast< std::vector<int >::value_type >(val3);
15435 std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
15437 catch(std::out_of_range &_e) {
15438 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15441 resultobj = SWIG_Py_Void();
15448 SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449 PyObject *resultobj = 0;
15450 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15451 std::vector<int >::value_type *arg2 = 0 ;
15454 std::vector<int >::value_type temp2 ;
15457 PyObject * obj0 = 0 ;
15458 PyObject * obj1 = 0 ;
15460 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
15461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector<int > *""'");
15465 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15466 ecode2 = SWIG_AsVal_int(obj1, &val2);
15467 if (!SWIG_IsOK(ecode2)) {
15468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
15470 temp2 = static_cast< std::vector<int >::value_type >(val2);
15472 std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
15473 resultobj = SWIG_Py_Void();
15480 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15481 PyObject *resultobj = 0;
15482 std::vector<int > *result = 0 ;
15484 if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
15485 result = (std::vector<int > *)new std::vector<int >();
15486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
15493 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494 PyObject *resultobj = 0;
15495 std::vector<int > *arg1 = 0 ;
15496 std::vector<int > *result = 0 ;
15497 int res1 = SWIG_OLDOBJ ;
15498 PyObject * obj0 = 0 ;
15500 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
15502 std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
15503 res1 = swig::asptr(obj0, &ptr);
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
15508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
15512 result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
15513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
15514 if (SWIG_IsNewObj(res1)) delete arg1;
15517 if (SWIG_IsNewObj(res1)) delete arg1;
15522 SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15528 PyObject * obj0 = 0 ;
15530 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
15531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector<int > const *""'");
15535 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15536 result = (bool)((std::vector<int > const *)arg1)->empty();
15537 resultobj = SWIG_From_bool(static_cast< bool >(result));
15544 SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545 PyObject *resultobj = 0;
15546 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15547 std::vector<int >::size_type result;
15550 PyObject * obj0 = 0 ;
15552 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
15553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15554 if (!SWIG_IsOK(res1)) {
15555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector<int > const *""'");
15557 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15558 result = ((std::vector<int > const *)arg1)->size();
15559 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15566 SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15567 PyObject *resultobj = 0;
15568 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15571 PyObject * obj0 = 0 ;
15573 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
15574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector<int > *""'");
15578 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15580 resultobj = SWIG_Py_Void();
15587 SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15588 PyObject *resultobj = 0;
15589 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15590 std::vector<int > *arg2 = 0 ;
15595 PyObject * obj0 = 0 ;
15596 PyObject * obj1 = 0 ;
15598 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
15599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector<int > *""'");
15603 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 );
15605 if (!SWIG_IsOK(res2)) {
15606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
15609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
15611 arg2 = reinterpret_cast< std::vector<int > * >(argp2);
15612 (arg1)->swap(*arg2);
15613 resultobj = SWIG_Py_Void();
15620 SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621 PyObject *resultobj = 0;
15622 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15623 SwigValueWrapper<std::allocator<int > > result;
15626 PyObject * obj0 = 0 ;
15628 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
15629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector<int > const *""'");
15633 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15634 result = ((std::vector<int > const *)arg1)->get_allocator();
15635 resultobj = SWIG_NewPointerObj((new std::vector<int >::allocator_type(static_cast< const std::vector<int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
15642 SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15643 PyObject *resultobj = 0;
15644 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15645 std::vector<int >::iterator result;
15648 PyObject * obj0 = 0 ;
15650 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
15651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15652 if (!SWIG_IsOK(res1)) {
15653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > *""'");
15655 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15656 result = (arg1)->begin();
15657 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
15658 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15665 SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15666 PyObject *resultobj = 0;
15667 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15668 std::vector<int >::const_iterator result;
15671 PyObject * obj0 = 0 ;
15673 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
15674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > const *""'");
15678 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15679 result = ((std::vector<int > const *)arg1)->begin();
15680 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
15681 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15688 SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *self, PyObject *args) {
15693 if (!PyTuple_Check(args)) SWIG_fail;
15694 argc = PyObject_Length(args);
15695 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15696 argv[ii] = PyTuple_GET_ITEM(args,ii);
15700 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15701 _v = SWIG_CheckState(res);
15703 return _wrap_VectorInt_begin__SWIG_0(self, args);
15708 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15709 _v = SWIG_CheckState(res);
15711 return _wrap_VectorInt_begin__SWIG_1(self, args);
15716 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
15721 SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15722 PyObject *resultobj = 0;
15723 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15724 std::vector<int >::iterator result;
15727 PyObject * obj0 = 0 ;
15729 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
15730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > *""'");
15734 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15735 result = (arg1)->end();
15736 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
15737 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15744 SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 PyObject *resultobj = 0;
15746 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15747 std::vector<int >::const_iterator result;
15750 PyObject * obj0 = 0 ;
15752 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
15753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15754 if (!SWIG_IsOK(res1)) {
15755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > const *""'");
15757 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15758 result = ((std::vector<int > const *)arg1)->end();
15759 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
15760 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15767 SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *self, PyObject *args) {
15772 if (!PyTuple_Check(args)) SWIG_fail;
15773 argc = PyObject_Length(args);
15774 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15775 argv[ii] = PyTuple_GET_ITEM(args,ii);
15779 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15780 _v = SWIG_CheckState(res);
15782 return _wrap_VectorInt_end__SWIG_0(self, args);
15787 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15788 _v = SWIG_CheckState(res);
15790 return _wrap_VectorInt_end__SWIG_1(self, args);
15795 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
15800 SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15801 PyObject *resultobj = 0;
15802 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15803 std::vector<int >::reverse_iterator result;
15806 PyObject * obj0 = 0 ;
15808 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
15809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15810 if (!SWIG_IsOK(res1)) {
15811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > *""'");
15813 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15814 result = (arg1)->rbegin();
15815 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
15816 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15823 SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15824 PyObject *resultobj = 0;
15825 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15826 std::vector<int >::const_reverse_iterator result;
15829 PyObject * obj0 = 0 ;
15831 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
15832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > const *""'");
15836 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15837 result = ((std::vector<int > const *)arg1)->rbegin();
15838 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
15839 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15846 SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *self, PyObject *args) {
15851 if (!PyTuple_Check(args)) SWIG_fail;
15852 argc = PyObject_Length(args);
15853 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15854 argv[ii] = PyTuple_GET_ITEM(args,ii);
15858 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15859 _v = SWIG_CheckState(res);
15861 return _wrap_VectorInt_rbegin__SWIG_0(self, args);
15866 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15867 _v = SWIG_CheckState(res);
15869 return _wrap_VectorInt_rbegin__SWIG_1(self, args);
15874 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
15879 SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15880 PyObject *resultobj = 0;
15881 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15882 std::vector<int >::reverse_iterator result;
15885 PyObject * obj0 = 0 ;
15887 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
15888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15889 if (!SWIG_IsOK(res1)) {
15890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > *""'");
15892 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15893 result = (arg1)->rend();
15894 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
15895 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15902 SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15903 PyObject *resultobj = 0;
15904 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15905 std::vector<int >::const_reverse_iterator result;
15908 PyObject * obj0 = 0 ;
15910 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
15911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15912 if (!SWIG_IsOK(res1)) {
15913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > const *""'");
15915 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15916 result = ((std::vector<int > const *)arg1)->rend();
15917 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
15918 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15925 SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *self, PyObject *args) {
15930 if (!PyTuple_Check(args)) SWIG_fail;
15931 argc = PyObject_Length(args);
15932 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15933 argv[ii] = PyTuple_GET_ITEM(args,ii);
15937 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15938 _v = SWIG_CheckState(res);
15940 return _wrap_VectorInt_rend__SWIG_0(self, args);
15945 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15946 _v = SWIG_CheckState(res);
15948 return _wrap_VectorInt_rend__SWIG_1(self, args);
15953 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
15958 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15959 PyObject *resultobj = 0;
15960 std::vector<int >::size_type arg1 ;
15961 std::vector<int > *result = 0 ;
15964 PyObject * obj0 = 0 ;
15966 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
15967 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15968 if (!SWIG_IsOK(ecode1)) {
15969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
15971 arg1 = static_cast< std::vector<int >::size_type >(val1);
15972 result = (std::vector<int > *)new std::vector<int >(arg1);
15973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
15980 SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15981 PyObject *resultobj = 0;
15982 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15985 PyObject * obj0 = 0 ;
15987 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector<int > *""'");
15992 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15993 (arg1)->pop_back();
15994 resultobj = SWIG_Py_Void();
16001 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16002 PyObject *resultobj = 0;
16003 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16004 std::vector<int >::size_type arg2 ;
16009 PyObject * obj0 = 0 ;
16010 PyObject * obj1 = 0 ;
16012 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
16013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16014 if (!SWIG_IsOK(res1)) {
16015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
16017 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16018 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16019 if (!SWIG_IsOK(ecode2)) {
16020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16022 arg2 = static_cast< std::vector<int >::size_type >(val2);
16023 (arg1)->resize(arg2);
16024 resultobj = SWIG_Py_Void();
16031 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16032 PyObject *resultobj = 0;
16033 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16034 std::vector<int >::iterator arg2 ;
16035 std::vector<int >::iterator result;
16038 swig::PySwigIterator *iter2 = 0 ;
16040 PyObject * obj0 = 0 ;
16041 PyObject * obj1 = 0 ;
16043 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
16044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
16048 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16049 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16050 if (!SWIG_IsOK(res2) || !iter2) {
16051 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16053 swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16055 arg2 = iter_t->get_current();
16057 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16060 result = (arg1)->erase(arg2);
16061 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16062 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16069 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16070 PyObject *resultobj = 0;
16071 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16072 std::vector<int >::iterator arg2 ;
16073 std::vector<int >::iterator arg3 ;
16074 std::vector<int >::iterator result;
16077 swig::PySwigIterator *iter2 = 0 ;
16079 swig::PySwigIterator *iter3 = 0 ;
16081 PyObject * obj0 = 0 ;
16082 PyObject * obj1 = 0 ;
16083 PyObject * obj2 = 0 ;
16085 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
16086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16087 if (!SWIG_IsOK(res1)) {
16088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
16090 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16091 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16092 if (!SWIG_IsOK(res2) || !iter2) {
16093 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16095 swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16097 arg2 = iter_t->get_current();
16099 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16102 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
16103 if (!SWIG_IsOK(res3) || !iter3) {
16104 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
16106 swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter3);
16108 arg3 = iter_t->get_current();
16110 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
16113 result = (arg1)->erase(arg2,arg3);
16114 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16115 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16122 SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
16127 if (!PyTuple_Check(args)) SWIG_fail;
16128 argc = PyObject_Length(args);
16129 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16130 argv[ii] = PyTuple_GET_ITEM(args,ii);
16134 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16135 _v = SWIG_CheckState(res);
16137 swig::PySwigIterator *iter = 0;
16138 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16139 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16141 return _wrap_VectorInt_erase__SWIG_0(self, args);
16147 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16148 _v = SWIG_CheckState(res);
16150 swig::PySwigIterator *iter = 0;
16151 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16152 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16154 swig::PySwigIterator *iter = 0;
16155 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16156 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16158 return _wrap_VectorInt_erase__SWIG_1(self, args);
16165 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<int >::iterator)\n erase(std::vector<int >::iterator,std::vector<int >::iterator)\n");
16170 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16171 PyObject *resultobj = 0;
16172 std::vector<int >::size_type arg1 ;
16173 std::vector<int >::value_type *arg2 = 0 ;
16174 std::vector<int > *result = 0 ;
16177 std::vector<int >::value_type temp2 ;
16180 PyObject * obj0 = 0 ;
16181 PyObject * obj1 = 0 ;
16183 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
16184 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
16185 if (!SWIG_IsOK(ecode1)) {
16186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
16188 arg1 = static_cast< std::vector<int >::size_type >(val1);
16189 ecode2 = SWIG_AsVal_int(obj1, &val2);
16190 if (!SWIG_IsOK(ecode2)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
16193 temp2 = static_cast< std::vector<int >::value_type >(val2);
16195 result = (std::vector<int > *)new std::vector<int >(arg1,(std::vector<int >::value_type const &)*arg2);
16196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
16203 SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
16208 if (!PyTuple_Check(args)) SWIG_fail;
16209 argc = PyObject_Length(args);
16210 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
16211 argv[ii] = PyTuple_GET_ITEM(args,ii);
16214 return _wrap_new_VectorInt__SWIG_0(self, args);
16219 int res = SWIG_AsVal_size_t(argv[0], NULL);
16220 _v = SWIG_CheckState(res);
16223 return _wrap_new_VectorInt__SWIG_2(self, args);
16228 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16229 _v = SWIG_CheckState(res);
16231 return _wrap_new_VectorInt__SWIG_1(self, args);
16237 int res = SWIG_AsVal_size_t(argv[0], NULL);
16238 _v = SWIG_CheckState(res);
16242 int res = SWIG_AsVal_int(argv[1], NULL);
16243 _v = SWIG_CheckState(res);
16246 return _wrap_new_VectorInt__SWIG_3(self, args);
16252 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorInt'.\n Possible C/C++ prototypes are:\n std::vector<(int)>()\n std::vector<(int)>(std::vector<int > const &)\n std::vector<(int)>(std::vector<int >::size_type)\n std::vector<(int)>(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16257 SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16258 PyObject *resultobj = 0;
16259 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16260 std::vector<int >::value_type *arg2 = 0 ;
16263 std::vector<int >::value_type temp2 ;
16266 PyObject * obj0 = 0 ;
16267 PyObject * obj1 = 0 ;
16269 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
16270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16271 if (!SWIG_IsOK(res1)) {
16272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector<int > *""'");
16274 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16275 ecode2 = SWIG_AsVal_int(obj1, &val2);
16276 if (!SWIG_IsOK(ecode2)) {
16277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
16279 temp2 = static_cast< std::vector<int >::value_type >(val2);
16281 (arg1)->push_back((std::vector<int >::value_type const &)*arg2);
16282 resultobj = SWIG_Py_Void();
16289 SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290 PyObject *resultobj = 0;
16291 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16292 std::vector<int >::value_type *result = 0 ;
16295 PyObject * obj0 = 0 ;
16297 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
16298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16299 if (!SWIG_IsOK(res1)) {
16300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector<int > const *""'");
16302 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16304 std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->front();
16305 result = (std::vector<int >::value_type *) &_result_ref;
16307 resultobj = SWIG_From_int(static_cast< int >(*result));
16314 SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16317 std::vector<int >::value_type *result = 0 ;
16320 PyObject * obj0 = 0 ;
16322 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
16323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16324 if (!SWIG_IsOK(res1)) {
16325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector<int > const *""'");
16327 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16329 std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->back();
16330 result = (std::vector<int >::value_type *) &_result_ref;
16332 resultobj = SWIG_From_int(static_cast< int >(*result));
16339 SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16340 PyObject *resultobj = 0;
16341 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16342 std::vector<int >::size_type arg2 ;
16343 std::vector<int >::value_type *arg3 = 0 ;
16348 std::vector<int >::value_type temp3 ;
16351 PyObject * obj0 = 0 ;
16352 PyObject * obj1 = 0 ;
16353 PyObject * obj2 = 0 ;
16355 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
16356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16357 if (!SWIG_IsOK(res1)) {
16358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector<int > *""'");
16360 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16361 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16362 if (!SWIG_IsOK(ecode2)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16365 arg2 = static_cast< std::vector<int >::size_type >(val2);
16366 ecode3 = SWIG_AsVal_int(obj2, &val3);
16367 if (!SWIG_IsOK(ecode3)) {
16368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16370 temp3 = static_cast< std::vector<int >::value_type >(val3);
16372 (arg1)->assign(arg2,(std::vector<int >::value_type const &)*arg3);
16373 resultobj = SWIG_Py_Void();
16380 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16381 PyObject *resultobj = 0;
16382 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16383 std::vector<int >::size_type arg2 ;
16384 std::vector<int >::value_type *arg3 = 0 ;
16389 std::vector<int >::value_type temp3 ;
16392 PyObject * obj0 = 0 ;
16393 PyObject * obj1 = 0 ;
16394 PyObject * obj2 = 0 ;
16396 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
16397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
16401 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16403 if (!SWIG_IsOK(ecode2)) {
16404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16406 arg2 = static_cast< std::vector<int >::size_type >(val2);
16407 ecode3 = SWIG_AsVal_int(obj2, &val3);
16408 if (!SWIG_IsOK(ecode3)) {
16409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16411 temp3 = static_cast< std::vector<int >::value_type >(val3);
16413 (arg1)->resize(arg2,(std::vector<int >::value_type const &)*arg3);
16414 resultobj = SWIG_Py_Void();
16421 SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
16426 if (!PyTuple_Check(args)) SWIG_fail;
16427 argc = PyObject_Length(args);
16428 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16429 argv[ii] = PyTuple_GET_ITEM(args,ii);
16433 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16434 _v = SWIG_CheckState(res);
16437 int res = SWIG_AsVal_size_t(argv[1], NULL);
16438 _v = SWIG_CheckState(res);
16441 return _wrap_VectorInt_resize__SWIG_0(self, args);
16447 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16448 _v = SWIG_CheckState(res);
16451 int res = SWIG_AsVal_size_t(argv[1], NULL);
16452 _v = SWIG_CheckState(res);
16456 int res = SWIG_AsVal_int(argv[2], NULL);
16457 _v = SWIG_CheckState(res);
16460 return _wrap_VectorInt_resize__SWIG_1(self, args);
16467 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<int >::size_type)\n resize(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16472 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16473 PyObject *resultobj = 0;
16474 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16475 std::vector<int >::iterator arg2 ;
16476 std::vector<int >::value_type *arg3 = 0 ;
16477 std::vector<int >::iterator result;
16480 swig::PySwigIterator *iter2 = 0 ;
16482 std::vector<int >::value_type temp3 ;
16485 PyObject * obj0 = 0 ;
16486 PyObject * obj1 = 0 ;
16487 PyObject * obj2 = 0 ;
16489 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
16490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16491 if (!SWIG_IsOK(res1)) {
16492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
16494 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16495 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16496 if (!SWIG_IsOK(res2) || !iter2) {
16497 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16499 swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16501 arg2 = iter_t->get_current();
16503 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16506 ecode3 = SWIG_AsVal_int(obj2, &val3);
16507 if (!SWIG_IsOK(ecode3)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16510 temp3 = static_cast< std::vector<int >::value_type >(val3);
16512 result = (arg1)->insert(arg2,(std::vector<int >::value_type const &)*arg3);
16513 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16514 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16521 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522 PyObject *resultobj = 0;
16523 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16524 std::vector<int >::iterator arg2 ;
16525 std::vector<int >::size_type arg3 ;
16526 std::vector<int >::value_type *arg4 = 0 ;
16529 swig::PySwigIterator *iter2 = 0 ;
16533 std::vector<int >::value_type temp4 ;
16536 PyObject * obj0 = 0 ;
16537 PyObject * obj1 = 0 ;
16538 PyObject * obj2 = 0 ;
16539 PyObject * obj3 = 0 ;
16541 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16543 if (!SWIG_IsOK(res1)) {
16544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
16546 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16548 if (!SWIG_IsOK(res2) || !iter2) {
16549 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16551 swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16553 arg2 = iter_t->get_current();
16555 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16558 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16559 if (!SWIG_IsOK(ecode3)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::size_type""'");
16562 arg3 = static_cast< std::vector<int >::size_type >(val3);
16563 ecode4 = SWIG_AsVal_int(obj3, &val4);
16564 if (!SWIG_IsOK(ecode4)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector<int >::value_type""'");
16567 temp4 = static_cast< std::vector<int >::value_type >(val4);
16569 (arg1)->insert(arg2,arg3,(std::vector<int >::value_type const &)*arg4);
16570 resultobj = SWIG_Py_Void();
16577 SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
16582 if (!PyTuple_Check(args)) SWIG_fail;
16583 argc = PyObject_Length(args);
16584 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
16585 argv[ii] = PyTuple_GET_ITEM(args,ii);
16589 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16590 _v = SWIG_CheckState(res);
16592 swig::PySwigIterator *iter = 0;
16593 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16594 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16597 int res = SWIG_AsVal_int(argv[2], NULL);
16598 _v = SWIG_CheckState(res);
16601 return _wrap_VectorInt_insert__SWIG_0(self, args);
16608 int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16609 _v = SWIG_CheckState(res);
16611 swig::PySwigIterator *iter = 0;
16612 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16613 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16616 int res = SWIG_AsVal_size_t(argv[2], NULL);
16617 _v = SWIG_CheckState(res);
16621 int res = SWIG_AsVal_int(argv[3], NULL);
16622 _v = SWIG_CheckState(res);
16625 return _wrap_VectorInt_insert__SWIG_1(self, args);
16633 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<int >::iterator,std::vector<int >::value_type const &)\n insert(std::vector<int >::iterator,std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16638 SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16639 PyObject *resultobj = 0;
16640 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16641 std::vector<int >::size_type arg2 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16649 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
16650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16651 if (!SWIG_IsOK(res1)) {
16652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector<int > *""'");
16654 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16656 if (!SWIG_IsOK(ecode2)) {
16657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16659 arg2 = static_cast< std::vector<int >::size_type >(val2);
16660 (arg1)->reserve(arg2);
16661 resultobj = SWIG_Py_Void();
16668 SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16669 PyObject *resultobj = 0;
16670 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16671 std::vector<int >::size_type result;
16674 PyObject * obj0 = 0 ;
16676 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
16677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
16678 if (!SWIG_IsOK(res1)) {
16679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector<int > const *""'");
16681 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16682 result = ((std::vector<int > const *)arg1)->capacity();
16683 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16690 SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16691 PyObject *resultobj = 0;
16692 std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16695 PyObject * obj0 = 0 ;
16697 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
16698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_DISOWN | 0 );
16699 if (!SWIG_IsOK(res1)) {
16700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector<int > *""'");
16702 arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16705 resultobj = SWIG_Py_Void();
16712 SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
16715 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_NewClientData(obj));
16716 return SWIG_Py_Void();
16719 SWIGINTERN int ABR_TYPES_set(PyObject *) {
16720 SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
16725 SWIGINTERN PyObject *ABR_TYPES_get(void) {
16726 PyObject *pyobj = 0;
16728 pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
16733 SWIGINTERN PyObject *_wrap_get_temp_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16734 PyObject *resultobj = 0;
16735 cpchar arg1 = (cpchar) 0 ;
16736 pchar arg2 = (pchar) 0 ;
16744 PyObject * obj0 = 0 ;
16745 PyObject * obj1 = 0 ;
16747 if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
16748 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16749 if (!SWIG_IsOK(res1)) {
16750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_temp_name" "', argument " "1"" of type '" "cpchar""'");
16752 arg1 = reinterpret_cast< cpchar >(buf1);
16753 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16754 if (!SWIG_IsOK(res2)) {
16755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_temp_name" "', argument " "2"" of type '" "pchar""'");
16757 arg2 = reinterpret_cast< pchar >(buf2);
16758 result = (pchar)Hex::get_temp_name((char const *)arg1,arg2);
16759 resultobj = SWIG_FromCharPtr((const char *)result);
16760 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16761 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16764 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16765 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16770 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16771 PyObject *resultobj = 0;
16772 cpchar arg1 = (cpchar) 0 ;
16773 cpchar arg2 = (cpchar) 0 ;
16774 cpchar arg3 = (cpchar) 0 ;
16784 PyObject * obj0 = 0 ;
16785 PyObject * obj1 = 0 ;
16786 PyObject * obj2 = 0 ;
16788 if (!PyArg_ParseTuple(args,(char *)"OOO:fatal_error",&obj0,&obj1,&obj2)) SWIG_fail;
16789 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16790 if (!SWIG_IsOK(res1)) {
16791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16793 arg1 = reinterpret_cast< cpchar >(buf1);
16794 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16795 if (!SWIG_IsOK(res2)) {
16796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
16798 arg2 = reinterpret_cast< cpchar >(buf2);
16799 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
16800 if (!SWIG_IsOK(res3)) {
16801 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fatal_error" "', argument " "3"" of type '" "cpchar""'");
16803 arg3 = reinterpret_cast< cpchar >(buf3);
16804 Hex::fatal_error((char const *)arg1,(char const *)arg2,(char const *)arg3);
16805 resultobj = SWIG_Py_Void();
16806 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16807 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16808 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16811 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16812 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16813 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16818 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16819 PyObject *resultobj = 0;
16820 cpchar arg1 = (cpchar) 0 ;
16821 cpchar arg2 = (cpchar) 0 ;
16828 PyObject * obj0 = 0 ;
16829 PyObject * obj1 = 0 ;
16831 if (!PyArg_ParseTuple(args,(char *)"OO:fatal_error",&obj0,&obj1)) SWIG_fail;
16832 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16836 arg1 = reinterpret_cast< cpchar >(buf1);
16837 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16838 if (!SWIG_IsOK(res2)) {
16839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
16841 arg2 = reinterpret_cast< cpchar >(buf2);
16842 Hex::fatal_error((char const *)arg1,(char const *)arg2);
16843 resultobj = SWIG_Py_Void();
16844 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16845 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16848 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16849 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16854 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16855 PyObject *resultobj = 0;
16856 cpchar arg1 = (cpchar) 0 ;
16860 PyObject * obj0 = 0 ;
16862 if (!PyArg_ParseTuple(args,(char *)"O:fatal_error",&obj0)) SWIG_fail;
16863 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16864 if (!SWIG_IsOK(res1)) {
16865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16867 arg1 = reinterpret_cast< cpchar >(buf1);
16868 Hex::fatal_error((char const *)arg1);
16869 resultobj = SWIG_Py_Void();
16870 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16873 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16878 SWIGINTERN PyObject *_wrap_fatal_error(PyObject *self, PyObject *args) {
16883 if (!PyTuple_Check(args)) SWIG_fail;
16884 argc = PyObject_Length(args);
16885 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16886 argv[ii] = PyTuple_GET_ITEM(args,ii);
16890 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16891 _v = SWIG_CheckState(res);
16893 return _wrap_fatal_error__SWIG_2(self, args);
16898 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16899 _v = SWIG_CheckState(res);
16901 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16902 _v = SWIG_CheckState(res);
16904 return _wrap_fatal_error__SWIG_1(self, args);
16910 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16911 _v = SWIG_CheckState(res);
16913 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16914 _v = SWIG_CheckState(res);
16916 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16917 _v = SWIG_CheckState(res);
16919 return _wrap_fatal_error__SWIG_0(self, args);
16926 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'fatal_error'.\n Possible C/C++ prototypes are:\n Hex::fatal_error(cpchar,cpchar,cpchar)\n Hex::fatal_error(cpchar,cpchar)\n Hex::fatal_error(cpchar)\n");
16931 SWIGINTERN PyObject *_wrap_prod_scalaire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16932 PyObject *resultobj = 0;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16943 if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
16944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
16945 if (!SWIG_IsOK(res1)) {
16946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_scalaire" "', argument " "1"" of type '" "double []""'");
16948 arg1 = reinterpret_cast< double * >(argp1);
16949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
16950 if (!SWIG_IsOK(res2)) {
16951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_scalaire" "', argument " "2"" of type '" "double []""'");
16953 arg2 = reinterpret_cast< double * >(argp2);
16954 result = (double)Hex::prod_scalaire(arg1,arg2);
16955 resultobj = SWIG_From_double(static_cast< double >(result));
16962 SWIGINTERN PyObject *_wrap_prod_vectoriel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16963 PyObject *resultobj = 0;
16967 double *result = 0 ;
16974 PyObject * obj0 = 0 ;
16975 PyObject * obj1 = 0 ;
16976 PyObject * obj2 = 0 ;
16978 if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
16979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_vectoriel" "', argument " "1"" of type '" "double []""'");
16983 arg1 = reinterpret_cast< double * >(argp1);
16984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
16985 if (!SWIG_IsOK(res2)) {
16986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_vectoriel" "', argument " "2"" of type '" "double []""'");
16988 arg2 = reinterpret_cast< double * >(argp2);
16989 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
16990 if (!SWIG_IsOK(res3)) {
16991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_vectoriel" "', argument " "3"" of type '" "double []""'");
16993 arg3 = reinterpret_cast< double * >(argp3);
16994 result = (double *)Hex::prod_vectoriel(arg1,arg2,arg3);
16995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
17002 SWIGINTERN PyObject *_wrap_prod_mixte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17003 PyObject *resultobj = 0;
17014 PyObject * obj0 = 0 ;
17015 PyObject * obj1 = 0 ;
17016 PyObject * obj2 = 0 ;
17018 if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
17019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17020 if (!SWIG_IsOK(res1)) {
17021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_mixte" "', argument " "1"" of type '" "double []""'");
17023 arg1 = reinterpret_cast< double * >(argp1);
17024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17025 if (!SWIG_IsOK(res2)) {
17026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_mixte" "', argument " "2"" of type '" "double []""'");
17028 arg2 = reinterpret_cast< double * >(argp2);
17029 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
17030 if (!SWIG_IsOK(res3)) {
17031 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_mixte" "', argument " "3"" of type '" "double []""'");
17033 arg3 = reinterpret_cast< double * >(argp3);
17034 result = (double)Hex::prod_mixte(arg1,arg2,arg3);
17035 resultobj = SWIG_From_double(static_cast< double >(result));
17042 SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17043 PyObject *resultobj = 0;
17048 PyObject * obj0 = 0 ;
17050 if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
17051 ecode1 = SWIG_AsVal_double(obj0, &val1);
17052 if (!SWIG_IsOK(ecode1)) {
17053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deg2radians" "', argument " "1"" of type '" "double""'");
17055 arg1 = static_cast< double >(val1);
17056 result = (double)Hex::deg2radians(arg1);
17057 resultobj = SWIG_From_double(static_cast< double >(result));
17064 SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17065 PyObject *resultobj = 0;
17070 PyObject * obj0 = 0 ;
17072 if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
17073 ecode1 = SWIG_AsVal_double(obj0, &val1);
17074 if (!SWIG_IsOK(ecode1)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rad2degres" "', argument " "1"" of type '" "double""'");
17077 arg1 = static_cast< double >(val1);
17078 result = (double)Hex::rad2degres(arg1);
17079 resultobj = SWIG_From_double(static_cast< double >(result));
17086 SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17087 PyObject *resultobj = 0;
17092 PyObject * obj0 = 0 ;
17094 if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
17095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17096 if (!SWIG_IsOK(res1)) {
17097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_norme" "', argument " "1"" of type '" "double []""'");
17099 arg1 = reinterpret_cast< double * >(argp1);
17100 result = (double)Hex::calc_norme(arg1);
17101 resultobj = SWIG_From_double(static_cast< double >(result));
17108 SWIGINTERN PyObject *_wrap_calc_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17109 PyObject *resultobj = 0;
17117 PyObject * obj0 = 0 ;
17118 PyObject * obj1 = 0 ;
17120 if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
17121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17122 if (!SWIG_IsOK(res1)) {
17123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_distance" "', argument " "1"" of type '" "double []""'");
17125 arg1 = reinterpret_cast< double * >(argp1);
17126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17127 if (!SWIG_IsOK(res2)) {
17128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_distance" "', argument " "2"" of type '" "double []""'");
17130 arg2 = reinterpret_cast< double * >(argp2);
17131 result = (double)Hex::calc_distance(arg1,arg2);
17132 resultobj = SWIG_From_double(static_cast< double >(result));
17139 SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17140 PyObject *resultobj = 0;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17151 if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
17152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17153 if (!SWIG_IsOK(res1)) {
17154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
17156 arg1 = reinterpret_cast< double * >(argp1);
17157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17158 if (!SWIG_IsOK(res2)) {
17159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
17161 arg2 = reinterpret_cast< double * >(argp2);
17162 result = (double)Hex::calc_d2(arg1,arg2);
17163 resultobj = SWIG_From_double(static_cast< double >(result));
17170 SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17171 PyObject *resultobj = 0;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17183 PyObject * obj2 = 0 ;
17185 if (!PyArg_ParseTuple(args,(char *)"OOO:calc_vecteur",&obj0,&obj1,&obj2)) SWIG_fail;
17186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17187 if (!SWIG_IsOK(res1)) {
17188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_vecteur" "', argument " "1"" of type '" "double []""'");
17190 arg1 = reinterpret_cast< double * >(argp1);
17191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17192 if (!SWIG_IsOK(res2)) {
17193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_vecteur" "', argument " "2"" of type '" "double []""'");
17195 arg2 = reinterpret_cast< double * >(argp2);
17196 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
17197 if (!SWIG_IsOK(res3)) {
17198 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_vecteur" "', argument " "3"" of type '" "double []""'");
17200 arg3 = reinterpret_cast< double * >(argp3);
17201 Hex::calc_vecteur(arg1,arg2,arg3);
17202 resultobj = SWIG_Py_Void();
17209 SWIGINTERN PyObject *_wrap_copy_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17210 PyObject *resultobj = 0;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17220 if (!PyArg_ParseTuple(args,(char *)"OO:copy_vecteur",&obj0,&obj1)) SWIG_fail;
17221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17222 if (!SWIG_IsOK(res1)) {
17223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_vecteur" "', argument " "1"" of type '" "double []""'");
17225 arg1 = reinterpret_cast< double * >(argp1);
17226 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17227 if (!SWIG_IsOK(res2)) {
17228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy_vecteur" "', argument " "2"" of type '" "double []""'");
17230 arg2 = reinterpret_cast< double * >(argp2);
17231 Hex::copy_vecteur(arg1,arg2);
17232 resultobj = SWIG_Py_Void();
17239 SWIGINTERN PyObject *_wrap_calc_milieu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *resultobj = 0;
17250 PyObject * obj0 = 0 ;
17251 PyObject * obj1 = 0 ;
17252 PyObject * obj2 = 0 ;
17254 if (!PyArg_ParseTuple(args,(char *)"OOO:calc_milieu",&obj0,&obj1,&obj2)) SWIG_fail;
17255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17256 if (!SWIG_IsOK(res1)) {
17257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_milieu" "', argument " "1"" of type '" "double []""'");
17259 arg1 = reinterpret_cast< double * >(argp1);
17260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17261 if (!SWIG_IsOK(res2)) {
17262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_milieu" "', argument " "2"" of type '" "double []""'");
17264 arg2 = reinterpret_cast< double * >(argp2);
17265 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
17266 if (!SWIG_IsOK(res3)) {
17267 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_milieu" "', argument " "3"" of type '" "double []""'");
17269 arg3 = reinterpret_cast< double * >(argp3);
17270 Hex::calc_milieu(arg1,arg2,arg3);
17271 resultobj = SWIG_Py_Void();
17278 SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 PyObject *resultobj = 0;
17284 PyObject * obj0 = 0 ;
17286 if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
17287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17288 if (!SWIG_IsOK(res1)) {
17289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "normer_vecteur" "', argument " "1"" of type '" "double []""'");
17291 arg1 = reinterpret_cast< double * >(argp1);
17292 result = (int)Hex::normer_vecteur(arg1);
17293 resultobj = SWIG_From_int(static_cast< int >(result));
17300 SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301 PyObject *resultobj = 0;
17306 PyObject * obj0 = 0 ;
17308 if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
17309 ecode1 = SWIG_AsVal_double(obj0, &val1);
17310 if (!SWIG_IsOK(ecode1)) {
17311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "carre" "', argument " "1"" of type '" "double""'");
17313 arg1 = static_cast< double >(val1);
17314 result = (double)Hex::carre(arg1);
17315 resultobj = SWIG_From_double(static_cast< double >(result));
17322 SWIGINTERN PyObject *_wrap_same_coords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 double *arg1 = (double *) 0 ;
17325 double *arg2 = (double *) 0 ;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 PyObject * obj2 = 0 ;
17338 if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
17339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17340 if (!SWIG_IsOK(res1)) {
17341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
17343 arg1 = reinterpret_cast< double * >(argp1);
17344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17345 if (!SWIG_IsOK(res2)) {
17346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
17348 arg2 = reinterpret_cast< double * >(argp2);
17349 ecode3 = SWIG_AsVal_double(obj2, &val3);
17350 if (!SWIG_IsOK(ecode3)) {
17351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "same_coords" "', argument " "3"" of type '" "double""'");
17353 arg3 = static_cast< double >(val3);
17354 result = (bool)Hex::same_coords(arg1,arg2,arg3);
17355 resultobj = SWIG_From_bool(static_cast< bool >(result));
17362 SWIGINTERN PyObject *_wrap_same_coords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 PyObject *resultobj = 0;
17364 double *arg1 = (double *) 0 ;
17365 double *arg2 = (double *) 0 ;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17374 if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
17375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17376 if (!SWIG_IsOK(res1)) {
17377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
17379 arg1 = reinterpret_cast< double * >(argp1);
17380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17381 if (!SWIG_IsOK(res2)) {
17382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
17384 arg2 = reinterpret_cast< double * >(argp2);
17385 result = (bool)Hex::same_coords(arg1,arg2);
17386 resultobj = SWIG_From_bool(static_cast< bool >(result));
17393 SWIGINTERN PyObject *_wrap_same_coords(PyObject *self, PyObject *args) {
17398 if (!PyTuple_Check(args)) SWIG_fail;
17399 argc = PyObject_Length(args);
17400 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17401 argv[ii] = PyTuple_GET_ITEM(args,ii);
17406 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17407 _v = SWIG_CheckState(res);
17410 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17411 _v = SWIG_CheckState(res);
17413 return _wrap_same_coords__SWIG_1(self, args);
17420 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17421 _v = SWIG_CheckState(res);
17424 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17425 _v = SWIG_CheckState(res);
17428 int res = SWIG_AsVal_double(argv[2], NULL);
17429 _v = SWIG_CheckState(res);
17432 return _wrap_same_coords__SWIG_0(self, args);
17439 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'same_coords'.\n Possible C/C++ prototypes are:\n Hex::same_coords(double *,double *,double)\n Hex::same_coords(double *,double *)\n");
17444 SWIGINTERN PyObject *_wrap_requals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 PyObject *resultobj = 0;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17456 if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
17457 ecode1 = SWIG_AsVal_double(obj0, &val1);
17458 if (!SWIG_IsOK(ecode1)) {
17459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "requals" "', argument " "1"" of type '" "double""'");
17461 arg1 = static_cast< double >(val1);
17462 ecode2 = SWIG_AsVal_double(obj1, &val2);
17463 if (!SWIG_IsOK(ecode2)) {
17464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "requals" "', argument " "2"" of type '" "double""'");
17466 arg2 = static_cast< double >(val2);
17467 result = (bool)Hex::requals(arg1,arg2);
17468 resultobj = SWIG_From_bool(static_cast< bool >(result));
17475 SWIGINTERN PyObject *_wrap_requals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *resultobj = 0;
17477 double *arg1 = (double *) 0 ;
17478 double *arg2 = (double *) 0 ;
17484 PyObject * obj0 = 0 ;
17485 PyObject * obj1 = 0 ;
17487 if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
17488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
17489 if (!SWIG_IsOK(res1)) {
17490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "requals" "', argument " "1"" of type '" "double const *""'");
17492 arg1 = reinterpret_cast< double * >(argp1);
17493 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
17494 if (!SWIG_IsOK(res2)) {
17495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "requals" "', argument " "2"" of type '" "double const *""'");
17497 arg2 = reinterpret_cast< double * >(argp2);
17498 result = (bool)Hex::requals((double const *)arg1,(double const *)arg2);
17499 resultobj = SWIG_From_bool(static_cast< bool >(result));
17506 SWIGINTERN PyObject *_wrap_requals(PyObject *self, PyObject *args) {
17511 if (!PyTuple_Check(args)) SWIG_fail;
17512 argc = PyObject_Length(args);
17513 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17514 argv[ii] = PyTuple_GET_ITEM(args,ii);
17519 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17520 _v = SWIG_CheckState(res);
17523 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17524 _v = SWIG_CheckState(res);
17526 return _wrap_requals__SWIG_1(self, args);
17533 int res = SWIG_AsVal_double(argv[0], NULL);
17534 _v = SWIG_CheckState(res);
17538 int res = SWIG_AsVal_double(argv[1], NULL);
17539 _v = SWIG_CheckState(res);
17542 return _wrap_requals__SWIG_0(self, args);
17548 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'requals'.\n Possible C/C++ prototypes are:\n Hex::requals(double const,double const)\n Hex::requals(double const *,double const *)\n");
17553 SWIGINTERN PyObject *_wrap_on_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554 PyObject *resultobj = 0;
17557 if (!PyArg_ParseTuple(args,(char *)":on_debug")) SWIG_fail;
17558 result = (bool)Hex::on_debug();
17559 resultobj = SWIG_From_bool(static_cast< bool >(result));
17566 SWIGINTERN PyObject *_wrap_in_test(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *resultobj = 0;
17570 if (!PyArg_ParseTuple(args,(char *)":in_test")) SWIG_fail;
17571 result = (bool)Hex::in_test();
17572 resultobj = SWIG_From_bool(static_cast< bool >(result));
17579 SWIGINTERN PyObject *_wrap_niv_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 PyObject *resultobj = 0;
17583 if (!PyArg_ParseTuple(args,(char *)":niv_debug")) SWIG_fail;
17584 result = (int)Hex::niv_debug();
17585 resultobj = SWIG_From_int(static_cast< int >(result));
17592 SWIGINTERN PyObject *_wrap_set_minus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17593 PyObject *resultobj = 0;
17597 PyObject * obj0 = 0 ;
17599 if (!PyArg_ParseTuple(args,(char *)"O:set_minus",&obj0)) SWIG_fail;
17600 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string, 0 );
17601 if (!SWIG_IsOK(res1)) {
17602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
17605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
17607 arg1 = reinterpret_cast< string * >(argp1);
17608 Hex::set_minus(*arg1);
17609 resultobj = SWIG_Py_Void();
17616 SWIGINTERN PyObject *_wrap_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617 PyObject *resultobj = 0;
17620 if (!PyArg_ParseTuple(args,(char *)":special_option")) SWIG_fail;
17621 result = (bool)Hex::special_option();
17622 resultobj = SWIG_From_bool(static_cast< bool >(result));
17629 SWIGINTERN PyObject *_wrap_set_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *resultobj = 0;
17634 PyObject * obj0 = 0 ;
17636 if (!PyArg_ParseTuple(args,(char *)"O:set_special_option",&obj0)) SWIG_fail;
17637 ecode1 = SWIG_AsVal_bool(obj0, &val1);
17638 if (!SWIG_IsOK(ecode1)) {
17639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_special_option" "', argument " "1"" of type '" "bool""'");
17641 arg1 = static_cast< bool >(val1);
17642 Hex::set_special_option(arg1);
17643 resultobj = SWIG_Py_Void();
17650 SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17651 PyObject *resultobj = 0;
17652 cpchar arg1 = (cpchar) 0 ;
17657 PyObject * obj0 = 0 ;
17659 if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
17660 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17661 if (!SWIG_IsOK(res1)) {
17662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sizeof_file" "', argument " "1"" of type '" "cpchar""'");
17664 arg1 = reinterpret_cast< cpchar >(buf1);
17665 result = (int)Hex::sizeof_file((char const *)arg1);
17666 resultobj = SWIG_From_int(static_cast< int >(result));
17667 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17670 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17675 SWIGINTERN PyObject *_wrap_read_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 cpchar arg1 = (cpchar) 0 ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17688 if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
17689 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17690 if (!SWIG_IsOK(res1)) {
17691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_file" "', argument " "1"" of type '" "cpchar""'");
17693 arg1 = reinterpret_cast< cpchar >(buf1);
17694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 );
17695 if (!SWIG_IsOK(res2)) {
17696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
17699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
17701 arg2 = reinterpret_cast< int * >(argp2);
17702 result = (char *)Hex::read_file((char const *)arg1,*arg2);
17703 resultobj = SWIG_FromCharPtr((const char *)result);
17704 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17707 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17712 SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17718 PyObject * obj0 = 0 ;
17720 if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string, 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
17726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
17728 arg1 = reinterpret_cast< string * >(argp1);
17729 result = (cpchar)Hex::get_time(*arg1);
17730 resultobj = SWIG_FromCharPtr((const char *)result);
17737 SWIGINTERN PyObject *_wrap_make_basename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17738 PyObject *resultobj = 0;
17739 cpchar arg1 = (cpchar) 0 ;
17747 PyObject * obj0 = 0 ;
17748 PyObject * obj1 = 0 ;
17750 if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
17751 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17752 if (!SWIG_IsOK(res1)) {
17753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_basename" "', argument " "1"" of type '" "cpchar""'");
17755 arg1 = reinterpret_cast< cpchar >(buf1);
17756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 );
17757 if (!SWIG_IsOK(res2)) {
17758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
17761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
17763 arg2 = reinterpret_cast< string * >(argp2);
17764 result = (int)Hex::make_basename((char const *)arg1,*arg2);
17765 resultobj = SWIG_From_int(static_cast< int >(result));
17766 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17769 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17774 SWIGINTERN int Epsil_set(PyObject *) {
17775 SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
17780 SWIGINTERN PyObject *Epsil_get(void) {
17781 PyObject *pyobj = 0;
17783 pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
17788 SWIGINTERN int UnEpsil_set(PyObject *) {
17789 SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
17794 SWIGINTERN PyObject *UnEpsil_get(void) {
17795 PyObject *pyobj = 0;
17797 pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
17802 SWIGINTERN int Epsil2_set(PyObject *) {
17803 SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
17808 SWIGINTERN PyObject *Epsil2_get(void) {
17809 PyObject *pyobj = 0;
17811 pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
17816 SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 PyObject *resultobj = 0;
17818 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17822 PyObject * obj0 = 0 ;
17824 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
17825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countHexa" "', argument " "1"" of type '" "Hex::EltBase *""'");
17829 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17830 result = (int)(arg1)->countHexa();
17831 resultobj = SWIG_From_int(static_cast< int >(result));
17838 SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *resultobj = 0;
17840 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17844 PyObject * obj0 = 0 ;
17846 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
17847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17848 if (!SWIG_IsOK(res1)) {
17849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countQuad" "', argument " "1"" of type '" "Hex::EltBase *""'");
17851 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17852 result = (int)(arg1)->countQuad();
17853 resultobj = SWIG_From_int(static_cast< int >(result));
17860 SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17861 PyObject *resultobj = 0;
17862 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17866 PyObject * obj0 = 0 ;
17868 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
17869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17870 if (!SWIG_IsOK(res1)) {
17871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
17873 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17874 result = (int)(arg1)->countEdge();
17875 resultobj = SWIG_From_int(static_cast< int >(result));
17882 SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17888 PyObject * obj0 = 0 ;
17890 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
17891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
17895 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17896 result = (int)(arg1)->countVertex();
17897 resultobj = SWIG_From_int(static_cast< int >(result));
17904 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 PyObject *resultobj = 0;
17906 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17915 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setError",&obj0,&obj1)) SWIG_fail;
17916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17917 if (!SWIG_IsOK(res1)) {
17918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
17920 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17921 ecode2 = SWIG_AsVal_int(obj1, &val2);
17922 if (!SWIG_IsOK(ecode2)) {
17923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setError" "', argument " "2"" of type '" "int""'");
17925 arg2 = static_cast< int >(val2);
17926 (arg1)->setError(arg2);
17927 resultobj = SWIG_Py_Void();
17934 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17935 PyObject *resultobj = 0;
17936 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17939 PyObject * obj0 = 0 ;
17941 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_setError",&obj0)) SWIG_fail;
17942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
17946 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17947 (arg1)->setError();
17948 resultobj = SWIG_Py_Void();
17955 SWIGINTERN PyObject *_wrap_EltBase_setError(PyObject *self, PyObject *args) {
17960 if (!PyTuple_Check(args)) SWIG_fail;
17961 argc = PyObject_Length(args);
17962 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17963 argv[ii] = PyTuple_GET_ITEM(args,ii);
17968 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
17969 _v = SWIG_CheckState(res);
17971 return _wrap_EltBase_setError__SWIG_1(self, args);
17977 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
17978 _v = SWIG_CheckState(res);
17981 int res = SWIG_AsVal_int(argv[1], NULL);
17982 _v = SWIG_CheckState(res);
17985 return _wrap_EltBase_setError__SWIG_0(self, args);
17991 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setError'.\n Possible C/C++ prototypes are:\n setError(int)\n setError()\n");
17996 SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17997 PyObject *resultobj = 0;
17998 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18002 PyObject * obj0 = 0 ;
18004 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
18005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18006 if (!SWIG_IsOK(res1)) {
18007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getError" "', argument " "1"" of type '" "Hex::EltBase *""'");
18009 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18010 result = (int)(arg1)->getError();
18011 resultobj = SWIG_From_int(static_cast< int >(result));
18018 SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019 PyObject *resultobj = 0;
18020 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18024 PyObject * obj0 = 0 ;
18026 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
18027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isValid" "', argument " "1"" of type '" "Hex::EltBase *""'");
18031 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18032 result = (bool)(arg1)->isValid();
18033 resultobj = SWIG_From_bool(static_cast< bool >(result));
18040 SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18041 PyObject *resultobj = 0;
18042 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18046 PyObject * obj0 = 0 ;
18048 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
18049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isBad" "', argument " "1"" of type '" "Hex::EltBase *""'");
18053 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18054 result = (bool)(arg1)->isBad();
18055 resultobj = SWIG_From_bool(static_cast< bool >(result));
18062 SWIGINTERN PyObject *_wrap_EltBase_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18067 PyObject * obj0 = 0 ;
18069 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_duplicate",&obj0)) SWIG_fail;
18070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_duplicate" "', argument " "1"" of type '" "Hex::EltBase *""'");
18074 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18075 (arg1)->duplicate();
18076 resultobj = SWIG_Py_Void();
18083 SWIGINTERN PyObject *_wrap_EltBase_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 PyObject *resultobj = 0;
18085 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18088 PyObject * obj0 = 0 ;
18090 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_clearAssociation",&obj0)) SWIG_fail;
18091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18092 if (!SWIG_IsOK(res1)) {
18093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_clearAssociation" "', argument " "1"" of type '" "Hex::EltBase *""'");
18095 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18096 (arg1)->clearAssociation();
18097 resultobj = SWIG_Py_Void();
18104 SWIGINTERN PyObject *_wrap_EltBase_replaceEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105 PyObject *resultobj = 0;
18106 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18107 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
18108 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 PyObject * obj2 = 0 ;
18119 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceEdge",&obj0,&obj1,&obj2)) SWIG_fail;
18120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18121 if (!SWIG_IsOK(res1)) {
18122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
18124 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
18126 if (!SWIG_IsOK(res2)) {
18127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
18129 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
18130 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
18131 if (!SWIG_IsOK(res3)) {
18132 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
18134 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
18135 (arg1)->replaceEdge(arg2,arg3);
18136 resultobj = SWIG_Py_Void();
18143 SWIGINTERN PyObject *_wrap_EltBase_replaceVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144 PyObject *resultobj = 0;
18145 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18146 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
18147 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18158 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceVertex",&obj0,&obj1,&obj2)) SWIG_fail;
18159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18160 if (!SWIG_IsOK(res1)) {
18161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
18163 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
18165 if (!SWIG_IsOK(res2)) {
18166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
18168 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
18169 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
18170 if (!SWIG_IsOK(res3)) {
18171 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
18173 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
18174 (arg1)->replaceVertex(arg2,arg3);
18175 resultobj = SWIG_Py_Void();
18182 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 Hex::Document *arg1 = (Hex::Document *) 0 ;
18185 Hex::EnumElt arg2 ;
18186 Hex::EltBase *result = 0 ;
18191 PyObject * obj0 = 0 ;
18192 PyObject * obj1 = 0 ;
18194 if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
18195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
18196 if (!SWIG_IsOK(res1)) {
18197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
18199 arg1 = reinterpret_cast< Hex::Document * >(argp1);
18200 ecode2 = SWIG_AsVal_int(obj1, &val2);
18201 if (!SWIG_IsOK(ecode2)) {
18202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EltBase" "', argument " "2"" of type '" "Hex::EnumElt""'");
18204 arg2 = static_cast< Hex::EnumElt >(val2);
18205 result = (Hex::EltBase *)new Hex::EltBase(arg1,arg2);
18206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
18213 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18214 PyObject *resultobj = 0;
18215 Hex::Document *arg1 = (Hex::Document *) 0 ;
18216 Hex::EltBase *result = 0 ;
18219 PyObject * obj0 = 0 ;
18221 if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
18222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
18223 if (!SWIG_IsOK(res1)) {
18224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
18226 arg1 = reinterpret_cast< Hex::Document * >(argp1);
18227 result = (Hex::EltBase *)new Hex::EltBase(arg1);
18228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
18235 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18236 PyObject *resultobj = 0;
18237 Hex::EnumElt arg1 ;
18238 Hex::EltBase *result = 0 ;
18241 PyObject * obj0 = 0 ;
18243 if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
18244 ecode1 = SWIG_AsVal_int(obj0, &val1);
18245 if (!SWIG_IsOK(ecode1)) {
18246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::EnumElt""'");
18248 arg1 = static_cast< Hex::EnumElt >(val1);
18249 result = (Hex::EltBase *)new Hex::EltBase(arg1);
18250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
18257 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18258 PyObject *resultobj = 0;
18259 Hex::EltBase *result = 0 ;
18261 if (!PyArg_ParseTuple(args,(char *)":new_EltBase")) SWIG_fail;
18262 result = (Hex::EltBase *)new Hex::EltBase();
18263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
18270 SWIGINTERN PyObject *_wrap_new_EltBase(PyObject *self, PyObject *args) {
18275 if (!PyTuple_Check(args)) SWIG_fail;
18276 argc = PyObject_Length(args);
18277 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18278 argv[ii] = PyTuple_GET_ITEM(args,ii);
18281 return _wrap_new_EltBase__SWIG_3(self, args);
18286 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
18287 _v = SWIG_CheckState(res);
18289 return _wrap_new_EltBase__SWIG_1(self, args);
18295 int res = SWIG_AsVal_int(argv[0], NULL);
18296 _v = SWIG_CheckState(res);
18299 return _wrap_new_EltBase__SWIG_2(self, args);
18305 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
18306 _v = SWIG_CheckState(res);
18309 int res = SWIG_AsVal_int(argv[1], NULL);
18310 _v = SWIG_CheckState(res);
18313 return _wrap_new_EltBase__SWIG_0(self, args);
18319 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EltBase'.\n Possible C/C++ prototypes are:\n Hex::EltBase(Hex::Document *,Hex::EnumElt)\n Hex::EltBase(Hex::Document *)\n Hex::EltBase(Hex::EnumElt)\n Hex::EltBase()\n");
18324 SWIGINTERN PyObject *_wrap_delete_EltBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18325 PyObject *resultobj = 0;
18326 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18329 PyObject * obj0 = 0 ;
18331 if (!PyArg_ParseTuple(args,(char *)"O:delete_EltBase",&obj0)) SWIG_fail;
18332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_DISOWN | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EltBase" "', argument " "1"" of type '" "Hex::EltBase *""'");
18336 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18339 resultobj = SWIG_Py_Void();
18346 SWIGINTERN PyObject *_wrap_EltBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18347 PyObject *resultobj = 0;
18348 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18351 PyObject * obj0 = 0 ;
18353 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_remove",&obj0)) SWIG_fail;
18354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18355 if (!SWIG_IsOK(res1)) {
18356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_remove" "', argument " "1"" of type '" "Hex::EltBase *""'");
18358 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18360 resultobj = SWIG_Py_Void();
18367 SWIGINTERN PyObject *_wrap_EltBase_suppress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18368 PyObject *resultobj = 0;
18369 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18372 PyObject * obj0 = 0 ;
18374 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_suppress",&obj0)) SWIG_fail;
18375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18376 if (!SWIG_IsOK(res1)) {
18377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_suppress" "', argument " "1"" of type '" "Hex::EltBase *""'");
18379 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18380 (arg1)->suppress();
18381 resultobj = SWIG_Py_Void();
18388 SWIGINTERN PyObject *_wrap_EltBase_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18389 PyObject *resultobj = 0;
18390 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18393 PyObject * obj0 = 0 ;
18395 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dump",&obj0)) SWIG_fail;
18396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dump" "', argument " "1"" of type '" "Hex::EltBase *""'");
18400 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18402 resultobj = SWIG_Py_Void();
18409 SWIGINTERN PyObject *_wrap_EltBase_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18410 PyObject *resultobj = 0;
18411 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18412 Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
18417 PyObject * obj0 = 0 ;
18418 PyObject * obj1 = 0 ;
18420 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_saveXml",&obj0,&obj1)) SWIG_fail;
18421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_saveXml" "', argument " "1"" of type '" "Hex::EltBase *""'");
18425 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 | 0 );
18427 if (!SWIG_IsOK(res2)) {
18428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
18430 arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
18431 (arg1)->saveXml(arg2);
18432 resultobj = SWIG_Py_Void();
18439 SWIGINTERN PyObject *_wrap_EltBase_majReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18440 PyObject *resultobj = 0;
18441 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18444 PyObject * obj0 = 0 ;
18446 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_majReferences",&obj0)) SWIG_fail;
18447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18448 if (!SWIG_IsOK(res1)) {
18449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_majReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
18451 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18452 (arg1)->majReferences();
18453 resultobj = SWIG_Py_Void();
18460 SWIGINTERN PyObject *_wrap_EltBase_makeVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18461 PyObject *resultobj = 0;
18462 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18463 char *arg2 = (char *) 0 ;
18470 PyObject * obj0 = 0 ;
18471 PyObject * obj1 = 0 ;
18473 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
18474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_makeVarName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18478 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18479 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18480 if (!SWIG_IsOK(res2)) {
18481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_makeVarName" "', argument " "2"" of type '" "char *""'");
18483 arg2 = reinterpret_cast< char * >(buf2);
18484 result = (char *)(arg1)->makeVarName(arg2);
18485 resultobj = SWIG_FromCharPtr((const char *)result);
18486 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18489 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18494 SWIGINTERN PyObject *_wrap_EltBase_makeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18495 PyObject *resultobj = 0;
18498 char *arg3 = (char *) 0 ;
18507 PyObject * obj0 = 0 ;
18508 PyObject * obj1 = 0 ;
18509 PyObject * obj2 = 0 ;
18511 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
18512 ecode1 = SWIG_AsVal_int(obj0, &val1);
18513 if (!SWIG_IsOK(ecode1)) {
18514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EltBase_makeName" "', argument " "1"" of type '" "int""'");
18516 arg1 = static_cast< int >(val1);
18517 ecode2 = SWIG_AsVal_int(obj1, &val2);
18518 if (!SWIG_IsOK(ecode2)) {
18519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_makeName" "', argument " "2"" of type '" "int""'");
18521 arg2 = static_cast< int >(val2);
18522 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
18523 if (!SWIG_IsOK(res3)) {
18524 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_makeName" "', argument " "3"" of type '" "char *""'");
18526 arg3 = reinterpret_cast< char * >(buf3);
18527 result = (char *)Hex::EltBase::makeName(arg1,arg2,arg3);
18528 resultobj = SWIG_FromCharPtr((const char *)result);
18529 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18532 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18537 SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538 PyObject *resultobj = 0;
18539 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18540 Hex::EltBase *result = 0 ;
18543 PyObject * obj0 = 0 ;
18545 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
18546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18547 if (!SWIG_IsOK(res1)) {
18548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_next" "', argument " "1"" of type '" "Hex::EltBase *""'");
18550 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18551 result = (Hex::EltBase *)(arg1)->next();
18552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18559 SWIGINTERN PyObject *_wrap_EltBase_setNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18560 PyObject *resultobj = 0;
18561 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18562 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18570 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setNext",&obj0,&obj1)) SWIG_fail;
18571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18572 if (!SWIG_IsOK(res1)) {
18573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setNext" "', argument " "1"" of type '" "Hex::EltBase *""'");
18575 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18577 if (!SWIG_IsOK(res2)) {
18578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setNext" "', argument " "2"" of type '" "Hex::EltBase *""'");
18580 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
18581 (arg1)->setNext(arg2);
18582 resultobj = SWIG_Py_Void();
18589 SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18590 PyObject *resultobj = 0;
18591 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18595 PyObject * obj0 = 0 ;
18597 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
18598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18599 if (!SWIG_IsOK(res1)) {
18600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getId" "', argument " "1"" of type '" "Hex::EltBase *""'");
18602 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18603 result = (int)(arg1)->getId();
18604 resultobj = SWIG_From_int(static_cast< int >(result));
18611 SWIGINTERN PyObject *_wrap_EltBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18612 PyObject *resultobj = 0;
18613 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18619 PyObject * obj0 = 0 ;
18620 PyObject * obj1 = 0 ;
18622 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setId",&obj0,&obj1)) SWIG_fail;
18623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18624 if (!SWIG_IsOK(res1)) {
18625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setId" "', argument " "1"" of type '" "Hex::EltBase *""'");
18627 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18628 ecode2 = SWIG_AsVal_int(obj1, &val2);
18629 if (!SWIG_IsOK(ecode2)) {
18630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setId" "', argument " "2"" of type '" "int""'");
18632 arg2 = static_cast< int >(val2);
18633 (arg1)->setId(arg2);
18634 resultobj = SWIG_Py_Void();
18641 SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642 PyObject *resultobj = 0;
18643 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18644 Hex::Document *result = 0 ;
18647 PyObject * obj0 = 0 ;
18649 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
18650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18651 if (!SWIG_IsOK(res1)) {
18652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dad" "', argument " "1"" of type '" "Hex::EltBase *""'");
18654 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18655 result = (Hex::Document *)(arg1)->dad();
18656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
18663 SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18666 Hex::EnumElt result;
18669 PyObject * obj0 = 0 ;
18671 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
18672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getType" "', argument " "1"" of type '" "Hex::EltBase *""'");
18676 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18677 result = (Hex::EnumElt)(arg1)->getType();
18678 resultobj = SWIG_From_int(static_cast< int >(result));
18685 SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18686 PyObject *resultobj = 0;
18687 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18691 PyObject * obj0 = 0 ;
18693 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
18694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18695 if (!SWIG_IsOK(res1)) {
18696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isHere" "', argument " "1"" of type '" "Hex::EltBase *""'");
18698 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18699 result = (bool)(arg1)->isHere();
18700 resultobj = SWIG_From_bool(static_cast< bool >(result));
18707 SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18708 PyObject *resultobj = 0;
18709 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18713 PyObject * obj0 = 0 ;
18715 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
18716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18717 if (!SWIG_IsOK(res1)) {
18718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isDeleted" "', argument " "1"" of type '" "Hex::EltBase *""'");
18720 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18721 result = (bool)(arg1)->isDeleted();
18722 resultobj = SWIG_From_bool(static_cast< bool >(result));
18729 SWIGINTERN PyObject *_wrap_EltBase_razReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18730 PyObject *resultobj = 0;
18731 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18734 PyObject * obj0 = 0 ;
18736 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_razReferences",&obj0)) SWIG_fail;
18737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_razReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
18741 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18742 (arg1)->razReferences();
18743 resultobj = SWIG_Py_Void();
18750 SWIGINTERN PyObject *_wrap_EltBase_addParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18751 PyObject *resultobj = 0;
18752 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18753 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
18758 PyObject * obj0 = 0 ;
18759 PyObject * obj1 = 0 ;
18761 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_addParent",&obj0,&obj1)) SWIG_fail;
18762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18763 if (!SWIG_IsOK(res1)) {
18764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_addParent" "', argument " "1"" of type '" "Hex::EltBase *""'");
18766 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18768 if (!SWIG_IsOK(res2)) {
18769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_addParent" "', argument " "2"" of type '" "Hex::EltBase *""'");
18771 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
18772 (arg1)->addParent(arg2);
18773 resultobj = SWIG_Py_Void();
18780 SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18781 PyObject *resultobj = 0;
18782 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18786 PyObject * obj0 = 0 ;
18788 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
18789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18790 if (!SWIG_IsOK(res1)) {
18791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNbrParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
18793 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18794 result = (int)(arg1)->getNbrParents();
18795 resultobj = SWIG_From_int(static_cast< int >(result));
18802 SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18803 PyObject *resultobj = 0;
18804 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18808 PyObject * obj0 = 0 ;
18810 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
18811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18812 if (!SWIG_IsOK(res1)) {
18813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_hasParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
18815 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18816 result = (bool)(arg1)->hasParents();
18817 resultobj = SWIG_From_bool(static_cast< bool >(result));
18824 SWIGINTERN PyObject *_wrap_EltBase_getFather(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18828 Hex::EltBase *result = 0 ;
18833 PyObject * obj0 = 0 ;
18834 PyObject * obj1 = 0 ;
18836 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
18837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18838 if (!SWIG_IsOK(res1)) {
18839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getFather" "', argument " "1"" of type '" "Hex::EltBase *""'");
18841 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18842 ecode2 = SWIG_AsVal_int(obj1, &val2);
18843 if (!SWIG_IsOK(ecode2)) {
18844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_getFather" "', argument " "2"" of type '" "int""'");
18846 arg2 = static_cast< int >(val2);
18847 result = (Hex::EltBase *)(arg1)->getFather(arg2);
18848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18855 SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18856 PyObject *resultobj = 0;
18857 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18861 PyObject * obj0 = 0 ;
18863 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
18864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18865 if (!SWIG_IsOK(res1)) {
18866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
18868 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18869 result = (int)(arg1)->getMark();
18870 resultobj = SWIG_From_int(static_cast< int >(result));
18877 SWIGINTERN PyObject *_wrap_EltBase_setMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878 PyObject *resultobj = 0;
18879 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18885 PyObject * obj0 = 0 ;
18886 PyObject * obj1 = 0 ;
18888 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setMark",&obj0,&obj1)) SWIG_fail;
18889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
18893 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18894 ecode2 = SWIG_AsVal_int(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setMark" "', argument " "2"" of type '" "int""'");
18898 arg2 = static_cast< int >(val2);
18899 (arg1)->setMark(arg2);
18900 resultobj = SWIG_Py_Void();
18907 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18910 pchar arg2 = (pchar) 0 ;
18917 PyObject * obj0 = 0 ;
18918 PyObject * obj1 = 0 ;
18920 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) SWIG_fail;
18921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18922 if (!SWIG_IsOK(res1)) {
18923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18925 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18926 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18927 if (!SWIG_IsOK(res2)) {
18928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_getName" "', argument " "2"" of type '" "pchar""'");
18930 arg2 = reinterpret_cast< pchar >(buf2);
18931 result = (char *)(arg1)->getName(arg2);
18932 resultobj = SWIG_FromCharPtr((const char *)result);
18933 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18936 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18941 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18942 PyObject *resultobj = 0;
18943 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18944 cpchar arg2 = (cpchar) 0 ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18953 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_printName",&obj0,&obj1)) SWIG_fail;
18954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18955 if (!SWIG_IsOK(res1)) {
18956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18958 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18959 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18960 if (!SWIG_IsOK(res2)) {
18961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_printName" "', argument " "2"" of type '" "cpchar""'");
18963 arg2 = reinterpret_cast< cpchar >(buf2);
18964 (arg1)->printName(arg2);
18965 resultobj = SWIG_Py_Void();
18966 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18969 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18974 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975 PyObject *resultobj = 0;
18976 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18979 PyObject * obj0 = 0 ;
18981 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_printName",&obj0)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18986 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18987 (arg1)->printName();
18988 resultobj = SWIG_Py_Void();
18995 SWIGINTERN PyObject *_wrap_EltBase_printName(PyObject *self, PyObject *args) {
19000 if (!PyTuple_Check(args)) SWIG_fail;
19001 argc = PyObject_Length(args);
19002 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19003 argv[ii] = PyTuple_GET_ITEM(args,ii);
19008 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19009 _v = SWIG_CheckState(res);
19011 return _wrap_EltBase_printName__SWIG_1(self, args);
19017 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19018 _v = SWIG_CheckState(res);
19020 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19021 _v = SWIG_CheckState(res);
19023 return _wrap_EltBase_printName__SWIG_0(self, args);
19029 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_printName'.\n Possible C/C++ prototypes are:\n printName(cpchar)\n printName()\n");
19034 SWIGINTERN PyObject *_wrap_EltBase_dumpRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19035 PyObject *resultobj = 0;
19036 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19039 PyObject * obj0 = 0 ;
19041 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dumpRef",&obj0)) SWIG_fail;
19042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19043 if (!SWIG_IsOK(res1)) {
19044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dumpRef" "', argument " "1"" of type '" "Hex::EltBase *""'");
19046 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19048 resultobj = SWIG_Py_Void();
19055 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19056 PyObject *resultobj = 0;
19057 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19061 PyObject * obj0 = 0 ;
19063 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
19064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19068 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19069 result = (cpchar)(arg1)->getName();
19070 resultobj = SWIG_FromCharPtr((const char *)result);
19077 SWIGINTERN PyObject *_wrap_EltBase_getName(PyObject *self, PyObject *args) {
19082 if (!PyTuple_Check(args)) SWIG_fail;
19083 argc = PyObject_Length(args);
19084 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19085 argv[ii] = PyTuple_GET_ITEM(args,ii);
19090 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19091 _v = SWIG_CheckState(res);
19093 return _wrap_EltBase_getName__SWIG_1(self, args);
19099 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19100 _v = SWIG_CheckState(res);
19102 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19103 _v = SWIG_CheckState(res);
19105 return _wrap_EltBase_getName__SWIG_0(self, args);
19111 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_getName'.\n Possible C/C++ prototypes are:\n getName(pchar)\n getName()\n");
19116 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117 PyObject *resultobj = 0;
19118 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19124 PyObject * obj0 = 0 ;
19125 PyObject * obj1 = 0 ;
19127 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
19128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19129 if (!SWIG_IsOK(res1)) {
19130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19132 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 | 0);
19134 if (!SWIG_IsOK(res2)) {
19135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
19138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
19140 arg2 = reinterpret_cast< string * >(argp2);
19141 (arg1)->setName((string const &)*arg2);
19142 resultobj = SWIG_Py_Void();
19149 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150 PyObject *resultobj = 0;
19151 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19152 cpchar arg2 = (cpchar) 0 ;
19158 PyObject * obj0 = 0 ;
19159 PyObject * obj1 = 0 ;
19161 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
19162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19163 if (!SWIG_IsOK(res1)) {
19164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19166 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19167 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19168 if (!SWIG_IsOK(res2)) {
19169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "cpchar""'");
19171 arg2 = reinterpret_cast< cpchar >(buf2);
19172 (arg1)->setName(arg2);
19173 resultobj = SWIG_Py_Void();
19174 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19177 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19182 SWIGINTERN PyObject *_wrap_EltBase_setName(PyObject *self, PyObject *args) {
19187 if (!PyTuple_Check(args)) SWIG_fail;
19188 argc = PyObject_Length(args);
19189 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19190 argv[ii] = PyTuple_GET_ITEM(args,ii);
19195 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19196 _v = SWIG_CheckState(res);
19198 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
19199 _v = SWIG_CheckState(res);
19201 return _wrap_EltBase_setName__SWIG_0(self, args);
19208 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19209 _v = SWIG_CheckState(res);
19211 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19212 _v = SWIG_CheckState(res);
19214 return _wrap_EltBase_setName__SWIG_1(self, args);
19220 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setName'.\n Possible C/C++ prototypes are:\n setName(string const &)\n setName(cpchar)\n");
19225 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19226 PyObject *resultobj = 0;
19227 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19234 PyObject * obj0 = 0 ;
19235 PyObject * obj1 = 0 ;
19237 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
19238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19239 if (!SWIG_IsOK(res1)) {
19240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
19242 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19243 ecode2 = SWIG_AsVal_int(obj1, &val2);
19244 if (!SWIG_IsOK(ecode2)) {
19245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_debug" "', argument " "2"" of type '" "int""'");
19247 arg2 = static_cast< int >(val2);
19248 result = (bool)(arg1)->debug(arg2);
19249 resultobj = SWIG_From_bool(static_cast< bool >(result));
19256 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257 PyObject *resultobj = 0;
19258 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19262 PyObject * obj0 = 0 ;
19264 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
19265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
19269 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19270 result = (bool)(arg1)->debug();
19271 resultobj = SWIG_From_bool(static_cast< bool >(result));
19278 SWIGINTERN PyObject *_wrap_EltBase_debug(PyObject *self, PyObject *args) {
19283 if (!PyTuple_Check(args)) SWIG_fail;
19284 argc = PyObject_Length(args);
19285 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19286 argv[ii] = PyTuple_GET_ITEM(args,ii);
19291 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19292 _v = SWIG_CheckState(res);
19294 return _wrap_EltBase_debug__SWIG_1(self, args);
19300 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19301 _v = SWIG_CheckState(res);
19304 int res = SWIG_AsVal_int(argv[1], NULL);
19305 _v = SWIG_CheckState(res);
19308 return _wrap_EltBase_debug__SWIG_0(self, args);
19314 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_debug'.\n Possible C/C++ prototypes are:\n debug(int)\n debug()\n");
19319 SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19320 PyObject *resultobj = 0;
19321 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19325 PyObject * obj0 = 0 ;
19327 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
19328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isAssociated" "', argument " "1"" of type '" "Hex::EltBase *""'");
19332 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19333 result = (bool)(arg1)->isAssociated();
19334 resultobj = SWIG_From_bool(static_cast< bool >(result));
19341 SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342 PyObject *resultobj = 0;
19343 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19347 PyObject * obj0 = 0 ;
19349 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
19350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
19351 if (!SWIG_IsOK(res1)) {
19352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNextName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19354 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19355 result = (arg1)->getNextName();
19356 resultobj = SWIG_NewPointerObj((new string(static_cast< const string& >(result))), SWIGTYPE_p_string, SWIG_POINTER_OWN | 0 );
19363 SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19365 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
19366 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
19367 return SWIG_Py_Void();
19370 SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19371 PyObject *resultobj = 0;
19372 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19376 PyObject * obj0 = 0 ;
19378 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
19379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19380 if (!SWIG_IsOK(res1)) {
19381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19383 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19384 result = (double)(arg1)->getX();
19385 resultobj = SWIG_From_double(static_cast< double >(result));
19392 SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393 PyObject *resultobj = 0;
19394 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19398 PyObject * obj0 = 0 ;
19400 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
19401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19405 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19406 result = (double)(arg1)->getY();
19407 resultobj = SWIG_From_double(static_cast< double >(result));
19414 SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415 PyObject *resultobj = 0;
19416 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19420 PyObject * obj0 = 0 ;
19422 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
19423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19424 if (!SWIG_IsOK(res1)) {
19425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19427 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19428 result = (double)(arg1)->getZ();
19429 resultobj = SWIG_From_double(static_cast< double >(result));
19436 SWIGINTERN PyObject *_wrap_Vertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19437 PyObject *resultobj = 0;
19438 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19447 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setX",&obj0,&obj1)) SWIG_fail;
19448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19449 if (!SWIG_IsOK(res1)) {
19450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19452 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19453 ecode2 = SWIG_AsVal_double(obj1, &val2);
19454 if (!SWIG_IsOK(ecode2)) {
19455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setX" "', argument " "2"" of type '" "double""'");
19457 arg2 = static_cast< double >(val2);
19458 (arg1)->setX(arg2);
19459 resultobj = SWIG_Py_Void();
19466 SWIGINTERN PyObject *_wrap_Vertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19467 PyObject *resultobj = 0;
19468 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19477 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setY",&obj0,&obj1)) SWIG_fail;
19478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19479 if (!SWIG_IsOK(res1)) {
19480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19482 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19483 ecode2 = SWIG_AsVal_double(obj1, &val2);
19484 if (!SWIG_IsOK(ecode2)) {
19485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setY" "', argument " "2"" of type '" "double""'");
19487 arg2 = static_cast< double >(val2);
19488 (arg1)->setY(arg2);
19489 resultobj = SWIG_Py_Void();
19496 SWIGINTERN PyObject *_wrap_Vertex_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497 PyObject *resultobj = 0;
19498 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19504 PyObject * obj0 = 0 ;
19505 PyObject * obj1 = 0 ;
19507 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setZ",&obj0,&obj1)) SWIG_fail;
19508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19509 if (!SWIG_IsOK(res1)) {
19510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19512 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19513 ecode2 = SWIG_AsVal_double(obj1, &val2);
19514 if (!SWIG_IsOK(ecode2)) {
19515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setZ" "', argument " "2"" of type '" "double""'");
19517 arg2 = static_cast< double >(val2);
19518 (arg1)->setZ(arg2);
19519 resultobj = SWIG_Py_Void();
19526 SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527 PyObject *resultobj = 0;
19528 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19532 PyObject * obj0 = 0 ;
19534 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
19535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19536 if (!SWIG_IsOK(res1)) {
19537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19539 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19540 result = (double)(arg1)->getAssoX();
19541 resultobj = SWIG_From_double(static_cast< double >(result));
19548 SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19549 PyObject *resultobj = 0;
19550 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19554 PyObject * obj0 = 0 ;
19556 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
19557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19558 if (!SWIG_IsOK(res1)) {
19559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19561 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19562 result = (double)(arg1)->getAssoY();
19563 resultobj = SWIG_From_double(static_cast< double >(result));
19570 SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19571 PyObject *resultobj = 0;
19572 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19576 PyObject * obj0 = 0 ;
19578 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
19579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19580 if (!SWIG_IsOK(res1)) {
19581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19583 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19584 result = (double)(arg1)->getAssoZ();
19585 resultobj = SWIG_From_double(static_cast< double >(result));
19592 SWIGINTERN PyObject *_wrap_Vertex_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19593 PyObject *resultobj = 0;
19594 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19595 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19604 PyObject * obj0 = 0 ;
19605 PyObject * obj1 = 0 ;
19606 PyObject * obj2 = 0 ;
19608 if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
19609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19610 if (!SWIG_IsOK(res1)) {
19611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
19613 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
19615 if (!SWIG_IsOK(res2)) {
19616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vertex_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19618 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19619 ecode3 = SWIG_AsVal_int(obj2, &val3);
19620 if (!SWIG_IsOK(ecode3)) {
19621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vertex_setAssociation" "', argument " "3"" of type '" "int""'");
19623 arg3 = static_cast< int >(val3);
19624 result = (int)(arg1)->setAssociation(arg2,arg3);
19625 resultobj = SWIG_From_int(static_cast< int >(result));
19632 SWIGINTERN PyObject *_wrap_Vertex_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19633 PyObject *resultobj = 0;
19634 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19637 PyObject * obj0 = 0 ;
19639 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_clearAssociation",&obj0)) SWIG_fail;
19640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_clearAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
19644 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19645 (arg1)->clearAssociation();
19646 resultobj = SWIG_Py_Void();
19653 SWIGINTERN PyObject *_wrap_Vertex_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *resultobj = 0;
19655 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19661 PyObject * obj0 = 0 ;
19662 PyObject * obj1 = 0 ;
19664 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setColor",&obj0,&obj1)) SWIG_fail;
19665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19666 if (!SWIG_IsOK(res1)) {
19667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setColor" "', argument " "1"" of type '" "Hex::Vertex *""'");
19669 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19670 ecode2 = SWIG_AsVal_double(obj1, &val2);
19671 if (!SWIG_IsOK(ecode2)) {
19672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setColor" "', argument " "2"" of type '" "double""'");
19674 arg2 = static_cast< double >(val2);
19675 (arg1)->setColor(arg2);
19676 resultobj = SWIG_Py_Void();
19683 SWIGINTERN PyObject *_wrap_new_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19684 PyObject *resultobj = 0;
19685 Hex::Document *arg1 = (Hex::Document *) 0 ;
19689 Hex::Vertex *result = 0 ;
19698 PyObject * obj0 = 0 ;
19699 PyObject * obj1 = 0 ;
19700 PyObject * obj2 = 0 ;
19701 PyObject * obj3 = 0 ;
19703 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
19705 if (!SWIG_IsOK(res1)) {
19706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vertex" "', argument " "1"" of type '" "Hex::Document *""'");
19708 arg1 = reinterpret_cast< Hex::Document * >(argp1);
19709 ecode2 = SWIG_AsVal_double(obj1, &val2);
19710 if (!SWIG_IsOK(ecode2)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vertex" "', argument " "2"" of type '" "double""'");
19713 arg2 = static_cast< double >(val2);
19714 ecode3 = SWIG_AsVal_double(obj2, &val3);
19715 if (!SWIG_IsOK(ecode3)) {
19716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vertex" "', argument " "3"" of type '" "double""'");
19718 arg3 = static_cast< double >(val3);
19719 ecode4 = SWIG_AsVal_double(obj3, &val4);
19720 if (!SWIG_IsOK(ecode4)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vertex" "', argument " "4"" of type '" "double""'");
19723 arg4 = static_cast< double >(val4);
19724 result = (Hex::Vertex *)new Hex::Vertex(arg1,arg2,arg3,arg4);
19725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_NEW | 0 );
19732 SWIGINTERN PyObject *_wrap_delete_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 PyObject *resultobj = 0;
19734 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19737 PyObject * obj0 = 0 ;
19739 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vertex",&obj0)) SWIG_fail;
19740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_DISOWN | 0 );
19741 if (!SWIG_IsOK(res1)) {
19742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vertex" "', argument " "1"" of type '" "Hex::Vertex *""'");
19744 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19747 resultobj = SWIG_Py_Void();
19754 SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
19757 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
19758 return SWIG_Py_Void();
19761 SWIGINTERN PyObject *_wrap_Edge_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19762 PyObject *resultobj = 0;
19763 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19765 Hex::Vertex *result = 0 ;
19770 PyObject * obj0 = 0 ;
19771 PyObject * obj1 = 0 ;
19773 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
19774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19775 if (!SWIG_IsOK(res1)) {
19776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getVertex" "', argument " "1"" of type '" "Hex::Edge *""'");
19778 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19779 ecode2 = SWIG_AsVal_int(obj1, &val2);
19780 if (!SWIG_IsOK(ecode2)) {
19781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_getVertex" "', argument " "2"" of type '" "int""'");
19783 arg2 = static_cast< int >(val2);
19784 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
19785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
19792 SWIGINTERN PyObject *_wrap_Edge_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793 PyObject *resultobj = 0;
19794 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19795 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19810 PyObject * obj0 = 0 ;
19811 PyObject * obj1 = 0 ;
19812 PyObject * obj2 = 0 ;
19813 PyObject * obj3 = 0 ;
19814 PyObject * obj4 = 0 ;
19816 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19818 if (!SWIG_IsOK(res1)) {
19819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_addAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19821 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
19823 if (!SWIG_IsOK(res2)) {
19824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19826 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19827 ecode3 = SWIG_AsVal_int(obj2, &val3);
19828 if (!SWIG_IsOK(ecode3)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_addAssociation" "', argument " "3"" of type '" "int""'");
19831 arg3 = static_cast< int >(val3);
19832 ecode4 = SWIG_AsVal_double(obj3, &val4);
19833 if (!SWIG_IsOK(ecode4)) {
19834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Edge_addAssociation" "', argument " "4"" of type '" "double""'");
19836 arg4 = static_cast< double >(val4);
19837 ecode5 = SWIG_AsVal_double(obj4, &val5);
19838 if (!SWIG_IsOK(ecode5)) {
19839 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Edge_addAssociation" "', argument " "5"" of type '" "double""'");
19841 arg5 = static_cast< double >(val5);
19842 result = (int)(arg1)->addAssociation(arg2,arg3,arg4,arg5);
19843 resultobj = SWIG_From_int(static_cast< int >(result));
19850 SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19851 PyObject *resultobj = 0;
19852 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19853 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19862 PyObject * obj0 = 0 ;
19863 PyObject * obj1 = 0 ;
19864 PyObject * obj2 = 0 ;
19866 if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
19867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19868 if (!SWIG_IsOK(res1)) {
19869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19871 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19872 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
19873 if (!SWIG_IsOK(res2)) {
19874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19876 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19877 ecode3 = SWIG_AsVal_int(obj2, &val3);
19878 if (!SWIG_IsOK(ecode3)) {
19879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
19881 arg3 = static_cast< int >(val3);
19882 result = (int)(arg1)->setAssociation(arg2,arg3);
19883 resultobj = SWIG_From_int(static_cast< int >(result));
19890 SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19891 PyObject *resultobj = 0;
19892 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19893 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19899 PyObject * obj0 = 0 ;
19900 PyObject * obj1 = 0 ;
19902 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
19903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19904 if (!SWIG_IsOK(res1)) {
19905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19907 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
19909 if (!SWIG_IsOK(res2)) {
19910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19912 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19913 result = (int)(arg1)->findAssociation(arg2);
19914 resultobj = SWIG_From_int(static_cast< int >(result));
19921 SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19922 PyObject *resultobj = 0;
19923 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19926 PyObject * obj0 = 0 ;
19928 if (!PyArg_ParseTuple(args,(char *)"O:Edge_clearAssociation",&obj0)) SWIG_fail;
19929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19930 if (!SWIG_IsOK(res1)) {
19931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_clearAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19933 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19934 (arg1)->clearAssociation();
19935 resultobj = SWIG_Py_Void();
19942 SWIGINTERN PyObject *_wrap_Edge_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19943 PyObject *resultobj = 0;
19944 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19950 PyObject * obj0 = 0 ;
19951 PyObject * obj1 = 0 ;
19953 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_setColor",&obj0,&obj1)) SWIG_fail;
19954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19955 if (!SWIG_IsOK(res1)) {
19956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setColor" "', argument " "1"" of type '" "Hex::Edge *""'");
19958 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19959 ecode2 = SWIG_AsVal_double(obj1, &val2);
19960 if (!SWIG_IsOK(ecode2)) {
19961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_setColor" "', argument " "2"" of type '" "double""'");
19963 arg2 = static_cast< double >(val2);
19964 (arg1)->setColor(arg2);
19965 resultobj = SWIG_Py_Void();
19972 SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19973 PyObject *resultobj = 0;
19974 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19978 PyObject * obj0 = 0 ;
19980 if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
19981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
19982 if (!SWIG_IsOK(res1)) {
19983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getWay" "', argument " "1"" of type '" "Hex::Edge *""'");
19985 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19986 result = (bool)(arg1)->getWay();
19987 resultobj = SWIG_From_bool(static_cast< bool >(result));
19994 SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19995 PyObject *resultobj = 0;
19996 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20000 PyObject * obj0 = 0 ;
20002 if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
20003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
20004 if (!SWIG_IsOK(res1)) {
20005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getLength" "', argument " "1"" of type '" "Hex::Edge *""'");
20007 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20008 result = (double)(arg1)->getLength();
20009 resultobj = SWIG_From_double(static_cast< double >(result));
20016 SWIGINTERN PyObject *_wrap_new_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20017 PyObject *resultobj = 0;
20018 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20019 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20020 Hex::Edge *result = 0 ;
20025 PyObject * obj0 = 0 ;
20026 PyObject * obj1 = 0 ;
20028 if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
20029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20030 if (!SWIG_IsOK(res1)) {
20031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "Hex::Vertex *""'");
20033 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20035 if (!SWIG_IsOK(res2)) {
20036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Edge" "', argument " "2"" of type '" "Hex::Vertex *""'");
20038 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20039 result = (Hex::Edge *)new Hex::Edge(arg1,arg2);
20040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, SWIG_POINTER_NEW | 0 );
20047 SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20048 PyObject *resultobj = 0;
20049 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20052 PyObject * obj0 = 0 ;
20054 if (!PyArg_ParseTuple(args,(char *)"O:delete_Edge",&obj0)) SWIG_fail;
20055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, SWIG_POINTER_DISOWN | 0 );
20056 if (!SWIG_IsOK(res1)) {
20057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "Hex::Edge *""'");
20059 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20062 resultobj = SWIG_Py_Void();
20069 SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20071 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20072 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
20073 return SWIG_Py_Void();
20076 SWIGINTERN PyObject *_wrap_Quad_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20077 PyObject *resultobj = 0;
20078 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20080 Hex::Edge *result = 0 ;
20085 PyObject * obj0 = 0 ;
20086 PyObject * obj1 = 0 ;
20088 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
20089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20090 if (!SWIG_IsOK(res1)) {
20091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getEdge" "', argument " "1"" of type '" "Hex::Quad *""'");
20093 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20094 ecode2 = SWIG_AsVal_int(obj1, &val2);
20095 if (!SWIG_IsOK(ecode2)) {
20096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getEdge" "', argument " "2"" of type '" "int""'");
20098 arg2 = static_cast< int >(val2);
20099 result = (Hex::Edge *)(arg1)->getEdge(arg2);
20100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
20107 SWIGINTERN PyObject *_wrap_Quad_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108 PyObject *resultobj = 0;
20109 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20111 Hex::Vertex *result = 0 ;
20116 PyObject * obj0 = 0 ;
20117 PyObject * obj1 = 0 ;
20119 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
20120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20121 if (!SWIG_IsOK(res1)) {
20122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
20124 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20125 ecode2 = SWIG_AsVal_int(obj1, &val2);
20126 if (!SWIG_IsOK(ecode2)) {
20127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getVertex" "', argument " "2"" of type '" "int""'");
20129 arg2 = static_cast< int >(val2);
20130 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
20131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20138 SWIGINTERN PyObject *_wrap_Quad_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139 PyObject *resultobj = 0;
20140 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20141 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20150 PyObject * obj0 = 0 ;
20151 PyObject * obj1 = 0 ;
20152 PyObject * obj2 = 0 ;
20154 if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
20155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20156 if (!SWIG_IsOK(res1)) {
20157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_addAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
20159 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
20161 if (!SWIG_IsOK(res2)) {
20162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20164 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20165 ecode3 = SWIG_AsVal_int(obj2, &val3);
20166 if (!SWIG_IsOK(ecode3)) {
20167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quad_addAssociation" "', argument " "3"" of type '" "int""'");
20169 arg3 = static_cast< int >(val3);
20170 result = (int)(arg1)->addAssociation(arg2,arg3);
20171 resultobj = SWIG_From_int(static_cast< int >(result));
20178 SWIGINTERN PyObject *_wrap_Quad_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20179 PyObject *resultobj = 0;
20180 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20183 PyObject * obj0 = 0 ;
20185 if (!PyArg_ParseTuple(args,(char *)"O:Quad_clearAssociation",&obj0)) SWIG_fail;
20186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20187 if (!SWIG_IsOK(res1)) {
20188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_clearAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
20190 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20191 (arg1)->clearAssociation();
20192 resultobj = SWIG_Py_Void();
20199 SWIGINTERN PyObject *_wrap_Quad_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200 PyObject *resultobj = 0;
20201 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20207 PyObject * obj0 = 0 ;
20208 PyObject * obj1 = 0 ;
20210 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_setColor",&obj0,&obj1)) SWIG_fail;
20211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20212 if (!SWIG_IsOK(res1)) {
20213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_setColor" "', argument " "1"" of type '" "Hex::Quad *""'");
20215 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20216 ecode2 = SWIG_AsVal_double(obj1, &val2);
20217 if (!SWIG_IsOK(ecode2)) {
20218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_setColor" "', argument " "2"" of type '" "double""'");
20220 arg2 = static_cast< double >(val2);
20221 (arg1)->setColor(arg2);
20222 resultobj = SWIG_Py_Void();
20229 SWIGINTERN PyObject *_wrap_Quad_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20232 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20233 Hex::Vertex *result = 0 ;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20241 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
20242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20243 if (!SWIG_IsOK(res1)) {
20244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_nearestVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
20246 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20248 if (!SWIG_IsOK(res2)) {
20249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
20251 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20252 result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
20253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20260 SWIGINTERN PyObject *_wrap_Quad_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261 PyObject *resultobj = 0;
20262 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20263 double *arg2 = (double *) 0 ;
20264 double *result = 0 ;
20269 PyObject * obj0 = 0 ;
20270 PyObject * obj1 = 0 ;
20272 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
20273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20274 if (!SWIG_IsOK(res1)) {
20275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getCenter" "', argument " "1"" of type '" "Hex::Quad *""'");
20277 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20279 if (!SWIG_IsOK(res2)) {
20280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_getCenter" "', argument " "2"" of type '" "double *""'");
20282 arg2 = reinterpret_cast< double * >(argp2);
20283 result = (double *)(arg1)->getCenter(arg2);
20284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
20291 SWIGINTERN PyObject *_wrap_new_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292 PyObject *resultobj = 0;
20293 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20294 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20295 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
20296 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
20297 Hex::Quad *result = 0 ;
20306 PyObject * obj0 = 0 ;
20307 PyObject * obj1 = 0 ;
20308 PyObject * obj2 = 0 ;
20309 PyObject * obj3 = 0 ;
20311 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20313 if (!SWIG_IsOK(res1)) {
20314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quad" "', argument " "1"" of type '" "Hex::Vertex *""'");
20316 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20318 if (!SWIG_IsOK(res2)) {
20319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Quad" "', argument " "2"" of type '" "Hex::Vertex *""'");
20321 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20322 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20323 if (!SWIG_IsOK(res3)) {
20324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Quad" "', argument " "3"" of type '" "Hex::Vertex *""'");
20326 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
20327 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20328 if (!SWIG_IsOK(res4)) {
20329 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Quad" "', argument " "4"" of type '" "Hex::Vertex *""'");
20331 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
20332 result = (Hex::Quad *)new Hex::Quad(arg1,arg2,arg3,arg4);
20333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, SWIG_POINTER_NEW | 0 );
20340 SWIGINTERN PyObject *_wrap_delete_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 PyObject *resultobj = 0;
20342 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20345 PyObject * obj0 = 0 ;
20347 if (!PyArg_ParseTuple(args,(char *)"O:delete_Quad",&obj0)) SWIG_fail;
20348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, SWIG_POINTER_DISOWN | 0 );
20349 if (!SWIG_IsOK(res1)) {
20350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quad" "', argument " "1"" of type '" "Hex::Quad *""'");
20352 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20355 resultobj = SWIG_Py_Void();
20362 SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20365 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
20366 return SWIG_Py_Void();
20369 SWIGINTERN PyObject *_wrap_Hexa_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370 PyObject *resultobj = 0;
20371 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20373 Hex::Quad *result = 0 ;
20378 PyObject * obj0 = 0 ;
20379 PyObject * obj1 = 0 ;
20381 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
20382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
20383 if (!SWIG_IsOK(res1)) {
20384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getQuad" "', argument " "1"" of type '" "Hex::Hexa *""'");
20386 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20387 ecode2 = SWIG_AsVal_int(obj1, &val2);
20388 if (!SWIG_IsOK(ecode2)) {
20389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getQuad" "', argument " "2"" of type '" "int""'");
20391 arg2 = static_cast< int >(val2);
20392 result = (Hex::Quad *)(arg1)->getQuad(arg2);
20393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
20400 SWIGINTERN PyObject *_wrap_Hexa_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20401 PyObject *resultobj = 0;
20402 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20404 Hex::Edge *result = 0 ;
20409 PyObject * obj0 = 0 ;
20410 PyObject * obj1 = 0 ;
20412 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
20413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
20414 if (!SWIG_IsOK(res1)) {
20415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getEdge" "', argument " "1"" of type '" "Hex::Hexa *""'");
20417 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20418 ecode2 = SWIG_AsVal_int(obj1, &val2);
20419 if (!SWIG_IsOK(ecode2)) {
20420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getEdge" "', argument " "2"" of type '" "int""'");
20422 arg2 = static_cast< int >(val2);
20423 result = (Hex::Edge *)(arg1)->getEdge(arg2);
20424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
20431 SWIGINTERN PyObject *_wrap_Hexa_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20435 Hex::Vertex *result = 0 ;
20440 PyObject * obj0 = 0 ;
20441 PyObject * obj1 = 0 ;
20443 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
20444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getVertex" "', argument " "1"" of type '" "Hex::Hexa *""'");
20448 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20449 ecode2 = SWIG_AsVal_int(obj1, &val2);
20450 if (!SWIG_IsOK(ecode2)) {
20451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getVertex" "', argument " "2"" of type '" "int""'");
20453 arg2 = static_cast< int >(val2);
20454 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
20455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
20462 SWIGINTERN PyObject *_wrap_Hexa_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20463 PyObject *resultobj = 0;
20464 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20473 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_setColor",&obj0,&obj1)) SWIG_fail;
20474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_setColor" "', argument " "1"" of type '" "Hex::Hexa *""'");
20478 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20479 ecode2 = SWIG_AsVal_double(obj1, &val2);
20480 if (!SWIG_IsOK(ecode2)) {
20481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_setColor" "', argument " "2"" of type '" "double""'");
20483 arg2 = static_cast< double >(val2);
20484 (arg1)->setColor(arg2);
20485 resultobj = SWIG_Py_Void();
20492 SWIGINTERN PyObject *_wrap_new_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *resultobj = 0;
20494 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20495 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
20496 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
20497 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
20498 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
20499 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
20500 Hex::Hexa *result = 0 ;
20513 PyObject * obj0 = 0 ;
20514 PyObject * obj1 = 0 ;
20515 PyObject * obj2 = 0 ;
20516 PyObject * obj3 = 0 ;
20517 PyObject * obj4 = 0 ;
20518 PyObject * obj5 = 0 ;
20520 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hexa" "', argument " "1"" of type '" "Hex::Quad *""'");
20525 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20527 if (!SWIG_IsOK(res2)) {
20528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hexa" "', argument " "2"" of type '" "Hex::Quad *""'");
20530 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
20531 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20532 if (!SWIG_IsOK(res3)) {
20533 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Hexa" "', argument " "3"" of type '" "Hex::Quad *""'");
20535 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
20536 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20537 if (!SWIG_IsOK(res4)) {
20538 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Hexa" "', argument " "4"" of type '" "Hex::Quad *""'");
20540 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
20541 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20542 if (!SWIG_IsOK(res5)) {
20543 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Hexa" "', argument " "5"" of type '" "Hex::Quad *""'");
20545 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
20546 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
20547 if (!SWIG_IsOK(res6)) {
20548 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Hexa" "', argument " "6"" of type '" "Hex::Quad *""'");
20550 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
20551 result = (Hex::Hexa *)new Hex::Hexa(arg1,arg2,arg3,arg4,arg5,arg6);
20552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_NEW | 0 );
20559 SWIGINTERN PyObject *_wrap_delete_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20560 PyObject *resultobj = 0;
20561 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20564 PyObject * obj0 = 0 ;
20566 if (!PyArg_ParseTuple(args,(char *)"O:delete_Hexa",&obj0)) SWIG_fail;
20567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_DISOWN | 0 );
20568 if (!SWIG_IsOK(res1)) {
20569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hexa" "', argument " "1"" of type '" "Hex::Hexa *""'");
20571 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20574 resultobj = SWIG_Py_Void();
20581 SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20584 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
20585 return SWIG_Py_Void();
20588 SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20589 PyObject *resultobj = 0;
20590 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20594 PyObject * obj0 = 0 ;
20596 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
20597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
20598 if (!SWIG_IsOK(res1)) {
20599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDx" "', argument " "1"" of type '" "Hex::Vector *""'");
20601 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20602 result = (double)(arg1)->getDx();
20603 resultobj = SWIG_From_double(static_cast< double >(result));
20610 SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *resultobj = 0;
20612 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20616 PyObject * obj0 = 0 ;
20618 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
20619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
20620 if (!SWIG_IsOK(res1)) {
20621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDy" "', argument " "1"" of type '" "Hex::Vector *""'");
20623 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20624 result = (double)(arg1)->getDy();
20625 resultobj = SWIG_From_double(static_cast< double >(result));
20632 SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20633 PyObject *resultobj = 0;
20634 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20638 PyObject * obj0 = 0 ;
20640 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
20641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
20642 if (!SWIG_IsOK(res1)) {
20643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDz" "', argument " "1"" of type '" "Hex::Vector *""'");
20645 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20646 result = (double)(arg1)->getDz();
20647 resultobj = SWIG_From_double(static_cast< double >(result));
20654 SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655 PyObject *resultobj = 0;
20656 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20660 PyObject * obj0 = 0 ;
20662 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
20663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
20664 if (!SWIG_IsOK(res1)) {
20665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getNorm" "', argument " "1"" of type '" "Hex::Vector *""'");
20667 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20668 result = (double)(arg1)->getNorm();
20669 resultobj = SWIG_From_double(static_cast< double >(result));
20676 SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20677 PyObject *resultobj = 0;
20678 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20682 PyObject * obj0 = 0 ;
20684 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
20685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
20686 if (!SWIG_IsOK(res1)) {
20687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getAngleX" "', argument " "1"" of type '" "Hex::Vector *""'");
20689 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20690 result = (double)(arg1)->getAngleX();
20691 resultobj = SWIG_From_double(static_cast< double >(result));
20698 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20699 PyObject *resultobj = 0;
20700 Hex::Document *arg1 = (Hex::Document *) 0 ;
20704 Hex::Vector *result = 0 ;
20713 PyObject * obj0 = 0 ;
20714 PyObject * obj1 = 0 ;
20715 PyObject * obj2 = 0 ;
20716 PyObject * obj3 = 0 ;
20718 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20723 arg1 = reinterpret_cast< Hex::Document * >(argp1);
20724 ecode2 = SWIG_AsVal_double(obj1, &val2);
20725 if (!SWIG_IsOK(ecode2)) {
20726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20728 arg2 = static_cast< double >(val2);
20729 ecode3 = SWIG_AsVal_double(obj2, &val3);
20730 if (!SWIG_IsOK(ecode3)) {
20731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
20733 arg3 = static_cast< double >(val3);
20734 ecode4 = SWIG_AsVal_double(obj3, &val4);
20735 if (!SWIG_IsOK(ecode4)) {
20736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vector" "', argument " "4"" of type '" "double""'");
20738 arg4 = static_cast< double >(val4);
20739 result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3,arg4);
20740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
20747 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20748 PyObject *resultobj = 0;
20749 Hex::Document *arg1 = (Hex::Document *) 0 ;
20752 Hex::Vector *result = 0 ;
20759 PyObject * obj0 = 0 ;
20760 PyObject * obj1 = 0 ;
20761 PyObject * obj2 = 0 ;
20763 if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
20764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
20765 if (!SWIG_IsOK(res1)) {
20766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20768 arg1 = reinterpret_cast< Hex::Document * >(argp1);
20769 ecode2 = SWIG_AsVal_double(obj1, &val2);
20770 if (!SWIG_IsOK(ecode2)) {
20771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20773 arg2 = static_cast< double >(val2);
20774 ecode3 = SWIG_AsVal_double(obj2, &val3);
20775 if (!SWIG_IsOK(ecode3)) {
20776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
20778 arg3 = static_cast< double >(val3);
20779 result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3);
20780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
20787 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20788 PyObject *resultobj = 0;
20789 Hex::Document *arg1 = (Hex::Document *) 0 ;
20791 Hex::Vector *result = 0 ;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20799 if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
20800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20804 arg1 = reinterpret_cast< Hex::Document * >(argp1);
20805 ecode2 = SWIG_AsVal_double(obj1, &val2);
20806 if (!SWIG_IsOK(ecode2)) {
20807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20809 arg2 = static_cast< double >(val2);
20810 result = (Hex::Vector *)new Hex::Vector(arg1,arg2);
20811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
20818 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20819 PyObject *resultobj = 0;
20820 Hex::Document *arg1 = (Hex::Document *) 0 ;
20821 Hex::Vector *result = 0 ;
20824 PyObject * obj0 = 0 ;
20826 if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
20827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
20828 if (!SWIG_IsOK(res1)) {
20829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20831 arg1 = reinterpret_cast< Hex::Document * >(argp1);
20832 result = (Hex::Vector *)new Hex::Vector(arg1);
20833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
20840 SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
20845 if (!PyTuple_Check(args)) SWIG_fail;
20846 argc = PyObject_Length(args);
20847 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
20848 argv[ii] = PyTuple_GET_ITEM(args,ii);
20853 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20854 _v = SWIG_CheckState(res);
20856 return _wrap_new_Vector__SWIG_3(self, args);
20862 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20863 _v = SWIG_CheckState(res);
20866 int res = SWIG_AsVal_double(argv[1], NULL);
20867 _v = SWIG_CheckState(res);
20870 return _wrap_new_Vector__SWIG_2(self, args);
20877 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20878 _v = SWIG_CheckState(res);
20881 int res = SWIG_AsVal_double(argv[1], NULL);
20882 _v = SWIG_CheckState(res);
20886 int res = SWIG_AsVal_double(argv[2], NULL);
20887 _v = SWIG_CheckState(res);
20890 return _wrap_new_Vector__SWIG_1(self, args);
20898 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20899 _v = SWIG_CheckState(res);
20902 int res = SWIG_AsVal_double(argv[1], NULL);
20903 _v = SWIG_CheckState(res);
20907 int res = SWIG_AsVal_double(argv[2], NULL);
20908 _v = SWIG_CheckState(res);
20912 int res = SWIG_AsVal_double(argv[3], NULL);
20913 _v = SWIG_CheckState(res);
20916 return _wrap_new_Vector__SWIG_0(self, args);
20924 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vector'.\n Possible C/C++ prototypes are:\n Hex::Vector(Hex::Document *,double,double,double)\n Hex::Vector(Hex::Document *,double,double)\n Hex::Vector(Hex::Document *,double)\n Hex::Vector(Hex::Document *)\n");
20929 SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20934 PyObject * obj0 = 0 ;
20936 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vector",&obj0)) SWIG_fail;
20937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, SWIG_POINTER_DISOWN | 0 );
20938 if (!SWIG_IsOK(res1)) {
20939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "Hex::Vector *""'");
20941 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20944 resultobj = SWIG_Py_Void();
20951 SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20954 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
20955 return SWIG_Py_Void();
20958 SWIGINTERN PyObject *_wrap_new_Document__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *resultobj = 0;
20960 cpchar arg1 = (cpchar) 0 ;
20961 Hex::Hex *arg2 = (Hex::Hex *) 0 ;
20962 Hex::Document *result = 0 ;
20968 PyObject * obj0 = 0 ;
20969 PyObject * obj1 = 0 ;
20971 if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
20972 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
20976 arg1 = reinterpret_cast< cpchar >(buf1);
20977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hex, 0 | 0 );
20978 if (!SWIG_IsOK(res2)) {
20979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Document" "', argument " "2"" of type '" "Hex::Hex *""'");
20981 arg2 = reinterpret_cast< Hex::Hex * >(argp2);
20982 result = (Hex::Document *)new Hex::Document(arg1,arg2);
20983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW | 0 );
20984 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20987 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20992 SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 cpchar arg1 = (cpchar) 0 ;
20995 Hex::Document *result = 0 ;
20999 PyObject * obj0 = 0 ;
21001 if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
21002 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21003 if (!SWIG_IsOK(res1)) {
21004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
21006 arg1 = reinterpret_cast< cpchar >(buf1);
21007 result = (Hex::Document *)new Hex::Document(arg1);
21008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW | 0 );
21009 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21012 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21017 SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
21022 if (!PyTuple_Check(args)) SWIG_fail;
21023 argc = PyObject_Length(args);
21024 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
21025 argv[ii] = PyTuple_GET_ITEM(args,ii);
21029 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
21030 _v = SWIG_CheckState(res);
21032 return _wrap_new_Document__SWIG_1(self, args);
21037 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
21038 _v = SWIG_CheckState(res);
21041 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hex, 0);
21042 _v = SWIG_CheckState(res);
21044 return _wrap_new_Document__SWIG_0(self, args);
21050 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Document'.\n Possible C/C++ prototypes are:\n Hex::Document(cpchar,Hex::Hex *)\n Hex::Document(cpchar)\n");
21055 SWIGINTERN PyObject *_wrap_Document_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21056 PyObject *resultobj = 0;
21057 Hex::Document *arg1 = (Hex::Document *) 0 ;
21060 PyObject * obj0 = 0 ;
21062 if (!PyArg_ParseTuple(args,(char *)"O:Document_dump",&obj0)) SWIG_fail;
21063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21064 if (!SWIG_IsOK(res1)) {
21065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_dump" "', argument " "1"" of type '" "Hex::Document *""'");
21067 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21069 resultobj = SWIG_Py_Void();
21076 SWIGINTERN PyObject *_wrap_Document_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077 PyObject *resultobj = 0;
21078 Hex::Document *arg1 = (Hex::Document *) 0 ;
21079 char *arg2 = (char *) 0 ;
21086 PyObject * obj0 = 0 ;
21087 PyObject * obj1 = 0 ;
21089 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
21090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setName" "', argument " "1"" of type '" "Hex::Document *""'");
21094 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21095 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21096 if (!SWIG_IsOK(res2)) {
21097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_setName" "', argument " "2"" of type '" "char const *""'");
21099 arg2 = reinterpret_cast< char * >(buf2);
21100 result = (int)(arg1)->setName((char const *)arg2);
21101 resultobj = SWIG_From_int(static_cast< int >(result));
21102 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21105 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21110 SWIGINTERN PyObject *_wrap_Document_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21111 PyObject *resultobj = 0;
21112 Hex::Document *arg1 = (Hex::Document *) 0 ;
21118 PyObject * obj0 = 0 ;
21119 PyObject * obj1 = 0 ;
21121 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setLevel",&obj0,&obj1)) SWIG_fail;
21122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setLevel" "', argument " "1"" of type '" "Hex::Document *""'");
21126 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21127 ecode2 = SWIG_AsVal_int(obj1, &val2);
21128 if (!SWIG_IsOK(ecode2)) {
21129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setLevel" "', argument " "2"" of type '" "int""'");
21131 arg2 = static_cast< int >(val2);
21132 (arg1)->setLevel(arg2);
21133 resultobj = SWIG_Py_Void();
21140 SWIGINTERN PyObject *_wrap_Document_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141 PyObject *resultobj = 0;
21142 Hex::Document *arg1 = (Hex::Document *) 0 ;
21143 char *arg2 = (char *) 0 ;
21150 PyObject * obj0 = 0 ;
21151 PyObject * obj1 = 0 ;
21153 if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
21154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_save" "', argument " "1"" of type '" "Hex::Document *""'");
21158 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21159 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21160 if (!SWIG_IsOK(res2)) {
21161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_save" "', argument " "2"" of type '" "char const *""'");
21163 arg2 = reinterpret_cast< char * >(buf2);
21164 result = (int)(arg1)->save((char const *)arg2);
21165 resultobj = SWIG_From_int(static_cast< int >(result));
21166 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21169 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21174 SWIGINTERN PyObject *_wrap_Document_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 Hex::Document *arg1 = (Hex::Document *) 0 ;
21177 cpchar arg2 = (cpchar) 0 ;
21184 PyObject * obj0 = 0 ;
21185 PyObject * obj1 = 0 ;
21187 if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
21188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_saveVtk" "', argument " "1"" of type '" "Hex::Document *""'");
21192 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21193 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21194 if (!SWIG_IsOK(res2)) {
21195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_saveVtk" "', argument " "2"" of type '" "cpchar""'");
21197 arg2 = reinterpret_cast< cpchar >(buf2);
21198 result = (int)(arg1)->saveVtk(arg2);
21199 resultobj = SWIG_From_int(static_cast< int >(result));
21200 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21203 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21208 SWIGINTERN PyObject *_wrap_Document_purge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *resultobj = 0;
21210 Hex::Document *arg1 = (Hex::Document *) 0 ;
21213 PyObject * obj0 = 0 ;
21215 if (!PyArg_ParseTuple(args,(char *)"O:Document_purge",&obj0)) SWIG_fail;
21216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21217 if (!SWIG_IsOK(res1)) {
21218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_purge" "', argument " "1"" of type '" "Hex::Document *""'");
21220 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21222 resultobj = SWIG_Py_Void();
21229 SWIGINTERN PyObject *_wrap_Document_setTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21230 PyObject *resultobj = 0;
21231 Hex::Document *arg1 = (Hex::Document *) 0 ;
21237 PyObject * obj0 = 0 ;
21238 PyObject * obj1 = 0 ;
21240 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setTolerance",&obj0,&obj1)) SWIG_fail;
21241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
21245 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21246 ecode2 = SWIG_AsVal_double(obj1, &val2);
21247 if (!SWIG_IsOK(ecode2)) {
21248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setTolerance" "', argument " "2"" of type '" "double""'");
21250 arg2 = static_cast< double >(val2);
21251 (arg1)->setTolerance(arg2);
21252 resultobj = SWIG_Py_Void();
21259 SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260 PyObject *resultobj = 0;
21261 Hex::Document *arg1 = (Hex::Document *) 0 ;
21265 PyObject * obj0 = 0 ;
21267 if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
21268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
21272 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21273 result = (double)(arg1)->getTolerance();
21274 resultobj = SWIG_From_double(static_cast< double >(result));
21281 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282 PyObject *resultobj = 0;
21283 Hex::Document *arg1 = (Hex::Document *) 0 ;
21287 Hex::Vertex *result = 0 ;
21296 PyObject * obj0 = 0 ;
21297 PyObject * obj1 = 0 ;
21298 PyObject * obj2 = 0 ;
21299 PyObject * obj3 = 0 ;
21301 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21306 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21307 ecode2 = SWIG_AsVal_double(obj1, &val2);
21308 if (!SWIG_IsOK(ecode2)) {
21309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21311 arg2 = static_cast< double >(val2);
21312 ecode3 = SWIG_AsVal_double(obj2, &val3);
21313 if (!SWIG_IsOK(ecode3)) {
21314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
21316 arg3 = static_cast< double >(val3);
21317 ecode4 = SWIG_AsVal_double(obj3, &val4);
21318 if (!SWIG_IsOK(ecode4)) {
21319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVertex" "', argument " "4"" of type '" "double""'");
21321 arg4 = static_cast< double >(val4);
21322 result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3,arg4);
21323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21330 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21331 PyObject *resultobj = 0;
21332 Hex::Document *arg1 = (Hex::Document *) 0 ;
21335 Hex::Vertex *result = 0 ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 PyObject * obj2 = 0 ;
21346 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
21347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21351 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21352 ecode2 = SWIG_AsVal_double(obj1, &val2);
21353 if (!SWIG_IsOK(ecode2)) {
21354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21356 arg2 = static_cast< double >(val2);
21357 ecode3 = SWIG_AsVal_double(obj2, &val3);
21358 if (!SWIG_IsOK(ecode3)) {
21359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
21361 arg3 = static_cast< double >(val3);
21362 result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3);
21363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21370 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371 PyObject *resultobj = 0;
21372 Hex::Document *arg1 = (Hex::Document *) 0 ;
21374 Hex::Vertex *result = 0 ;
21379 PyObject * obj0 = 0 ;
21380 PyObject * obj1 = 0 ;
21382 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
21383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21384 if (!SWIG_IsOK(res1)) {
21385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21387 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21388 ecode2 = SWIG_AsVal_double(obj1, &val2);
21389 if (!SWIG_IsOK(ecode2)) {
21390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21392 arg2 = static_cast< double >(val2);
21393 result = (Hex::Vertex *)(arg1)->addVertex(arg2);
21394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21401 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21402 PyObject *resultobj = 0;
21403 Hex::Document *arg1 = (Hex::Document *) 0 ;
21404 Hex::Vertex *result = 0 ;
21407 PyObject * obj0 = 0 ;
21409 if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
21410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21411 if (!SWIG_IsOK(res1)) {
21412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21414 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21415 result = (Hex::Vertex *)(arg1)->addVertex();
21416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21423 SWIGINTERN PyObject *_wrap_Document_addVertex(PyObject *self, PyObject *args) {
21428 if (!PyTuple_Check(args)) SWIG_fail;
21429 argc = PyObject_Length(args);
21430 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
21431 argv[ii] = PyTuple_GET_ITEM(args,ii);
21436 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21437 _v = SWIG_CheckState(res);
21439 return _wrap_Document_addVertex__SWIG_3(self, args);
21445 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21446 _v = SWIG_CheckState(res);
21449 int res = SWIG_AsVal_double(argv[1], NULL);
21450 _v = SWIG_CheckState(res);
21453 return _wrap_Document_addVertex__SWIG_2(self, args);
21460 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21461 _v = SWIG_CheckState(res);
21464 int res = SWIG_AsVal_double(argv[1], NULL);
21465 _v = SWIG_CheckState(res);
21469 int res = SWIG_AsVal_double(argv[2], NULL);
21470 _v = SWIG_CheckState(res);
21473 return _wrap_Document_addVertex__SWIG_1(self, args);
21481 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21482 _v = SWIG_CheckState(res);
21485 int res = SWIG_AsVal_double(argv[1], NULL);
21486 _v = SWIG_CheckState(res);
21490 int res = SWIG_AsVal_double(argv[2], NULL);
21491 _v = SWIG_CheckState(res);
21495 int res = SWIG_AsVal_double(argv[3], NULL);
21496 _v = SWIG_CheckState(res);
21499 return _wrap_Document_addVertex__SWIG_0(self, args);
21507 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVertex'.\n Possible C/C++ prototypes are:\n addVertex(double,double,double)\n addVertex(double,double)\n addVertex(double)\n addVertex()\n");
21512 SWIGINTERN PyObject *_wrap_Document_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513 PyObject *resultobj = 0;
21514 Hex::Document *arg1 = (Hex::Document *) 0 ;
21515 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21516 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21517 Hex::Edge *result = 0 ;
21524 PyObject * obj0 = 0 ;
21525 PyObject * obj1 = 0 ;
21526 PyObject * obj2 = 0 ;
21528 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
21529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21530 if (!SWIG_IsOK(res1)) {
21531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdge" "', argument " "1"" of type '" "Hex::Document *""'");
21533 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21534 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21535 if (!SWIG_IsOK(res2)) {
21536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
21538 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21539 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21540 if (!SWIG_IsOK(res3)) {
21541 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
21543 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21544 result = (Hex::Edge *)(arg1)->addEdge(arg2,arg3);
21545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
21552 SWIGINTERN PyObject *_wrap_Document_addEdgeVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553 PyObject *resultobj = 0;
21554 Hex::Document *arg1 = (Hex::Document *) 0 ;
21555 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21556 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
21557 Hex::Edge *result = 0 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 PyObject * obj2 = 0 ;
21568 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
21569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeVector" "', argument " "1"" of type '" "Hex::Document *""'");
21573 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21575 if (!SWIG_IsOK(res2)) {
21576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeVector" "', argument " "2"" of type '" "Hex::Vertex *""'");
21578 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21579 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
21580 if (!SWIG_IsOK(res3)) {
21581 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdgeVector" "', argument " "3"" of type '" "Hex::Vector *""'");
21583 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
21584 result = (Hex::Edge *)(arg1)->addEdgeVector(arg2,arg3);
21585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
21592 SWIGINTERN PyObject *_wrap_Document_addQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21593 PyObject *resultobj = 0;
21594 Hex::Document *arg1 = (Hex::Document *) 0 ;
21595 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
21596 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
21597 Hex::Edge *arg4 = (Hex::Edge *) 0 ;
21598 Hex::Edge *arg5 = (Hex::Edge *) 0 ;
21599 Hex::Quad *result = 0 ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 PyObject * obj2 = 0 ;
21613 PyObject * obj3 = 0 ;
21614 PyObject * obj4 = 0 ;
21616 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuad" "', argument " "1"" of type '" "Hex::Document *""'");
21621 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21623 if (!SWIG_IsOK(res2)) {
21624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
21626 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
21627 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21628 if (!SWIG_IsOK(res3)) {
21629 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
21631 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
21632 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21633 if (!SWIG_IsOK(res4)) {
21634 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuad" "', argument " "4"" of type '" "Hex::Edge *""'");
21636 arg4 = reinterpret_cast< Hex::Edge * >(argp4);
21637 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21638 if (!SWIG_IsOK(res5)) {
21639 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuad" "', argument " "5"" of type '" "Hex::Edge *""'");
21641 arg5 = reinterpret_cast< Hex::Edge * >(argp5);
21642 result = (Hex::Quad *)(arg1)->addQuad(arg2,arg3,arg4,arg5);
21643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
21650 SWIGINTERN PyObject *_wrap_Document_addQuadVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21651 PyObject *resultobj = 0;
21652 Hex::Document *arg1 = (Hex::Document *) 0 ;
21653 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21654 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21655 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
21656 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
21657 Hex::Quad *result = 0 ;
21668 PyObject * obj0 = 0 ;
21669 PyObject * obj1 = 0 ;
21670 PyObject * obj2 = 0 ;
21671 PyObject * obj3 = 0 ;
21672 PyObject * obj4 = 0 ;
21674 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadVertices" "', argument " "1"" of type '" "Hex::Document *""'");
21679 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21681 if (!SWIG_IsOK(res2)) {
21682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
21684 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21685 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21686 if (!SWIG_IsOK(res3)) {
21687 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuadVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
21689 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21690 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21691 if (!SWIG_IsOK(res4)) {
21692 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuadVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
21694 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
21695 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21696 if (!SWIG_IsOK(res5)) {
21697 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuadVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
21699 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
21700 result = (Hex::Quad *)(arg1)->addQuadVertices(arg2,arg3,arg4,arg5);
21701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
21708 SWIGINTERN PyObject *_wrap_Document_addHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709 PyObject *resultobj = 0;
21710 Hex::Document *arg1 = (Hex::Document *) 0 ;
21711 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21712 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21713 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21714 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
21715 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
21716 Hex::Quad *arg7 = (Hex::Quad *) 0 ;
21717 Hex::Hexa *result = 0 ;
21732 PyObject * obj0 = 0 ;
21733 PyObject * obj1 = 0 ;
21734 PyObject * obj2 = 0 ;
21735 PyObject * obj3 = 0 ;
21736 PyObject * obj4 = 0 ;
21737 PyObject * obj5 = 0 ;
21738 PyObject * obj6 = 0 ;
21740 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
21741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21742 if (!SWIG_IsOK(res1)) {
21743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa" "', argument " "1"" of type '" "Hex::Document *""'");
21745 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21747 if (!SWIG_IsOK(res2)) {
21748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa" "', argument " "2"" of type '" "Hex::Quad *""'");
21750 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21751 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21752 if (!SWIG_IsOK(res3)) {
21753 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa" "', argument " "3"" of type '" "Hex::Quad *""'");
21755 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21756 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21757 if (!SWIG_IsOK(res4)) {
21758 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa" "', argument " "4"" of type '" "Hex::Quad *""'");
21760 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
21761 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21762 if (!SWIG_IsOK(res5)) {
21763 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa" "', argument " "5"" of type '" "Hex::Quad *""'");
21765 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
21766 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21767 if (!SWIG_IsOK(res6)) {
21768 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa" "', argument " "6"" of type '" "Hex::Quad *""'");
21770 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
21771 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21772 if (!SWIG_IsOK(res7)) {
21773 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexa" "', argument " "7"" of type '" "Hex::Quad *""'");
21775 arg7 = reinterpret_cast< Hex::Quad * >(argp7);
21776 result = (Hex::Hexa *)(arg1)->addHexa(arg2,arg3,arg4,arg5,arg6,arg7);
21777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
21784 SWIGINTERN PyObject *_wrap_Document_addHexaVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 Hex::Document *arg1 = (Hex::Document *) 0 ;
21787 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21788 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21789 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
21790 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
21791 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
21792 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
21793 Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
21794 Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
21795 Hex::Hexa *result = 0 ;
21814 PyObject * obj0 = 0 ;
21815 PyObject * obj1 = 0 ;
21816 PyObject * obj2 = 0 ;
21817 PyObject * obj3 = 0 ;
21818 PyObject * obj4 = 0 ;
21819 PyObject * obj5 = 0 ;
21820 PyObject * obj6 = 0 ;
21821 PyObject * obj7 = 0 ;
21822 PyObject * obj8 = 0 ;
21824 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
21825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21826 if (!SWIG_IsOK(res1)) {
21827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaVertices" "', argument " "1"" of type '" "Hex::Document *""'");
21829 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21831 if (!SWIG_IsOK(res2)) {
21832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
21834 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21835 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21836 if (!SWIG_IsOK(res3)) {
21837 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexaVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
21839 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21840 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21841 if (!SWIG_IsOK(res4)) {
21842 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexaVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
21844 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
21845 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21846 if (!SWIG_IsOK(res5)) {
21847 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexaVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
21849 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
21850 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21851 if (!SWIG_IsOK(res6)) {
21852 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexaVertices" "', argument " "6"" of type '" "Hex::Vertex *""'");
21854 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
21855 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21856 if (!SWIG_IsOK(res7)) {
21857 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexaVertices" "', argument " "7"" of type '" "Hex::Vertex *""'");
21859 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
21860 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21861 if (!SWIG_IsOK(res8)) {
21862 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_addHexaVertices" "', argument " "8"" of type '" "Hex::Vertex *""'");
21864 arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
21865 res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21866 if (!SWIG_IsOK(res9)) {
21867 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_addHexaVertices" "', argument " "9"" of type '" "Hex::Vertex *""'");
21869 arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
21870 result = (Hex::Hexa *)(arg1)->addHexaVertices(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
21871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
21878 SWIGINTERN PyObject *_wrap_Document_addHexa2Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 Hex::Document *arg1 = (Hex::Document *) 0 ;
21881 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21882 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21883 Hex::Hexa *result = 0 ;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 PyObject * obj2 = 0 ;
21894 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
21895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21896 if (!SWIG_IsOK(res1)) {
21897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa2Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21899 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21901 if (!SWIG_IsOK(res2)) {
21902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa2Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
21904 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21905 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21906 if (!SWIG_IsOK(res3)) {
21907 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa2Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
21909 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21910 result = (Hex::Hexa *)(arg1)->addHexa2Quads(arg2,arg3);
21911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
21918 SWIGINTERN PyObject *_wrap_Document_addHexa3Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21919 PyObject *resultobj = 0;
21920 Hex::Document *arg1 = (Hex::Document *) 0 ;
21921 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21922 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21923 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21924 Hex::Hexa *result = 0 ;
21933 PyObject * obj0 = 0 ;
21934 PyObject * obj1 = 0 ;
21935 PyObject * obj2 = 0 ;
21936 PyObject * obj3 = 0 ;
21938 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa3Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21943 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21945 if (!SWIG_IsOK(res2)) {
21946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa3Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
21948 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21949 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21950 if (!SWIG_IsOK(res3)) {
21951 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa3Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
21953 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21954 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21955 if (!SWIG_IsOK(res4)) {
21956 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa3Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
21958 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
21959 result = (Hex::Hexa *)(arg1)->addHexa3Quads(arg2,arg3,arg4);
21960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
21967 SWIGINTERN PyObject *_wrap_Document_addHexa4Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21968 PyObject *resultobj = 0;
21969 Hex::Document *arg1 = (Hex::Document *) 0 ;
21970 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21971 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21972 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21973 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
21974 Hex::Hexa *result = 0 ;
21985 PyObject * obj0 = 0 ;
21986 PyObject * obj1 = 0 ;
21987 PyObject * obj2 = 0 ;
21988 PyObject * obj3 = 0 ;
21989 PyObject * obj4 = 0 ;
21991 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21993 if (!SWIG_IsOK(res1)) {
21994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa4Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21996 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
21998 if (!SWIG_IsOK(res2)) {
21999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa4Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
22001 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22003 if (!SWIG_IsOK(res3)) {
22004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa4Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
22006 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22007 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22008 if (!SWIG_IsOK(res4)) {
22009 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa4Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
22011 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
22012 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22013 if (!SWIG_IsOK(res5)) {
22014 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa4Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
22016 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
22017 result = (Hex::Hexa *)(arg1)->addHexa4Quads(arg2,arg3,arg4,arg5);
22018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
22025 SWIGINTERN PyObject *_wrap_Document_addHexa5Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22026 PyObject *resultobj = 0;
22027 Hex::Document *arg1 = (Hex::Document *) 0 ;
22028 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
22029 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
22030 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
22031 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
22032 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
22033 Hex::Hexa *result = 0 ;
22046 PyObject * obj0 = 0 ;
22047 PyObject * obj1 = 0 ;
22048 PyObject * obj2 = 0 ;
22049 PyObject * obj3 = 0 ;
22050 PyObject * obj4 = 0 ;
22051 PyObject * obj5 = 0 ;
22053 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
22054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22055 if (!SWIG_IsOK(res1)) {
22056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa5Quads" "', argument " "1"" of type '" "Hex::Document *""'");
22058 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22060 if (!SWIG_IsOK(res2)) {
22061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa5Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
22063 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22064 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22065 if (!SWIG_IsOK(res3)) {
22066 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa5Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
22068 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22069 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22070 if (!SWIG_IsOK(res4)) {
22071 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa5Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
22073 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
22074 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22075 if (!SWIG_IsOK(res5)) {
22076 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa5Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
22078 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
22079 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
22080 if (!SWIG_IsOK(res6)) {
22081 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa5Quads" "', argument " "6"" of type '" "Hex::Quad *""'");
22083 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
22084 result = (Hex::Hexa *)(arg1)->addHexa5Quads(arg2,arg3,arg4,arg5,arg6);
22085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
22092 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22093 PyObject *resultobj = 0;
22094 Hex::Document *arg1 = (Hex::Document *) 0 ;
22098 Hex::Vector *result = 0 ;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 PyObject * obj2 = 0 ;
22110 PyObject * obj3 = 0 ;
22112 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22114 if (!SWIG_IsOK(res1)) {
22115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22117 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22118 ecode2 = SWIG_AsVal_double(obj1, &val2);
22119 if (!SWIG_IsOK(ecode2)) {
22120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22122 arg2 = static_cast< double >(val2);
22123 ecode3 = SWIG_AsVal_double(obj2, &val3);
22124 if (!SWIG_IsOK(ecode3)) {
22125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
22127 arg3 = static_cast< double >(val3);
22128 ecode4 = SWIG_AsVal_double(obj3, &val4);
22129 if (!SWIG_IsOK(ecode4)) {
22130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVector" "', argument " "4"" of type '" "double""'");
22132 arg4 = static_cast< double >(val4);
22133 result = (Hex::Vector *)(arg1)->addVector(arg2,arg3,arg4);
22134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
22141 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22142 PyObject *resultobj = 0;
22143 Hex::Document *arg1 = (Hex::Document *) 0 ;
22146 Hex::Vector *result = 0 ;
22153 PyObject * obj0 = 0 ;
22154 PyObject * obj1 = 0 ;
22155 PyObject * obj2 = 0 ;
22157 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
22158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22162 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22163 ecode2 = SWIG_AsVal_double(obj1, &val2);
22164 if (!SWIG_IsOK(ecode2)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22167 arg2 = static_cast< double >(val2);
22168 ecode3 = SWIG_AsVal_double(obj2, &val3);
22169 if (!SWIG_IsOK(ecode3)) {
22170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
22172 arg3 = static_cast< double >(val3);
22173 result = (Hex::Vector *)(arg1)->addVector(arg2,arg3);
22174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
22181 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 Hex::Document *arg1 = (Hex::Document *) 0 ;
22185 Hex::Vector *result = 0 ;
22190 PyObject * obj0 = 0 ;
22191 PyObject * obj1 = 0 ;
22193 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
22194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22195 if (!SWIG_IsOK(res1)) {
22196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22198 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22199 ecode2 = SWIG_AsVal_double(obj1, &val2);
22200 if (!SWIG_IsOK(ecode2)) {
22201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22203 arg2 = static_cast< double >(val2);
22204 result = (Hex::Vector *)(arg1)->addVector(arg2);
22205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
22212 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22213 PyObject *resultobj = 0;
22214 Hex::Document *arg1 = (Hex::Document *) 0 ;
22215 Hex::Vector *result = 0 ;
22218 PyObject * obj0 = 0 ;
22220 if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
22221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22222 if (!SWIG_IsOK(res1)) {
22223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22225 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22226 result = (Hex::Vector *)(arg1)->addVector();
22227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
22234 SWIGINTERN PyObject *_wrap_Document_addVector(PyObject *self, PyObject *args) {
22239 if (!PyTuple_Check(args)) SWIG_fail;
22240 argc = PyObject_Length(args);
22241 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
22242 argv[ii] = PyTuple_GET_ITEM(args,ii);
22247 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22248 _v = SWIG_CheckState(res);
22250 return _wrap_Document_addVector__SWIG_3(self, args);
22256 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22257 _v = SWIG_CheckState(res);
22260 int res = SWIG_AsVal_double(argv[1], NULL);
22261 _v = SWIG_CheckState(res);
22264 return _wrap_Document_addVector__SWIG_2(self, args);
22271 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22272 _v = SWIG_CheckState(res);
22275 int res = SWIG_AsVal_double(argv[1], NULL);
22276 _v = SWIG_CheckState(res);
22280 int res = SWIG_AsVal_double(argv[2], NULL);
22281 _v = SWIG_CheckState(res);
22284 return _wrap_Document_addVector__SWIG_1(self, args);
22292 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22293 _v = SWIG_CheckState(res);
22296 int res = SWIG_AsVal_double(argv[1], NULL);
22297 _v = SWIG_CheckState(res);
22301 int res = SWIG_AsVal_double(argv[2], NULL);
22302 _v = SWIG_CheckState(res);
22306 int res = SWIG_AsVal_double(argv[3], NULL);
22307 _v = SWIG_CheckState(res);
22310 return _wrap_Document_addVector__SWIG_0(self, args);
22318 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVector'.\n Possible C/C++ prototypes are:\n addVector(double,double,double)\n addVector(double,double)\n addVector(double)\n addVector()\n");
22323 SWIGINTERN PyObject *_wrap_Document_addVectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22324 PyObject *resultobj = 0;
22325 Hex::Document *arg1 = (Hex::Document *) 0 ;
22326 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22327 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22328 Hex::Vector *result = 0 ;
22335 PyObject * obj0 = 0 ;
22336 PyObject * obj1 = 0 ;
22337 PyObject * obj2 = 0 ;
22339 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
22340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22341 if (!SWIG_IsOK(res1)) {
22342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVectorVertices" "', argument " "1"" of type '" "Hex::Document *""'");
22344 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22346 if (!SWIG_IsOK(res2)) {
22347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVectorVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
22349 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22350 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22351 if (!SWIG_IsOK(res3)) {
22352 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addVectorVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
22354 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22355 result = (Hex::Vector *)(arg1)->addVectorVertices(arg2,arg3);
22356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
22363 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22364 PyObject *resultobj = 0;
22365 Hex::Document *arg1 = (Hex::Document *) 0 ;
22366 char *arg2 = (char *) 0 ;
22368 Hex::Law *result = 0 ;
22376 PyObject * obj0 = 0 ;
22377 PyObject * obj1 = 0 ;
22378 PyObject * obj2 = 0 ;
22380 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
22381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22382 if (!SWIG_IsOK(res1)) {
22383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
22385 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22386 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22387 if (!SWIG_IsOK(res2)) {
22388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "char const *""'");
22390 arg2 = reinterpret_cast< char * >(buf2);
22391 ecode3 = SWIG_AsVal_int(obj2, &val3);
22392 if (!SWIG_IsOK(ecode3)) {
22393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaw" "', argument " "3"" of type '" "int""'");
22395 arg3 = static_cast< int >(val3);
22396 result = (Hex::Law *)(arg1)->addLaw((char const *)arg2,arg3);
22397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
22398 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22401 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22406 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 Hex::Document *arg1 = (Hex::Document *) 0 ;
22418 PyObject * obj0 = 0 ;
22419 PyObject * obj1 = 0 ;
22420 PyObject * obj2 = 0 ;
22422 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
22423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22424 if (!SWIG_IsOK(res1)) {
22425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
22427 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22428 ecode2 = SWIG_AsVal_double(obj1, &val2);
22429 if (!SWIG_IsOK(ecode2)) {
22430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
22432 arg2 = static_cast< double >(val2);
22433 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22434 if (!SWIG_IsOK(ecode3)) {
22435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaws" "', argument " "3"" of type '" "bool""'");
22437 arg3 = static_cast< bool >(val3);
22438 result = (int)(arg1)->addLaws(arg2,arg3);
22439 resultobj = SWIG_From_int(static_cast< int >(result));
22446 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22447 PyObject *resultobj = 0;
22448 Hex::Document *arg1 = (Hex::Document *) 0 ;
22455 PyObject * obj0 = 0 ;
22456 PyObject * obj1 = 0 ;
22458 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
22459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22460 if (!SWIG_IsOK(res1)) {
22461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
22463 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22464 ecode2 = SWIG_AsVal_double(obj1, &val2);
22465 if (!SWIG_IsOK(ecode2)) {
22466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
22468 arg2 = static_cast< double >(val2);
22469 result = (int)(arg1)->addLaws(arg2);
22470 resultobj = SWIG_From_int(static_cast< int >(result));
22477 SWIGINTERN PyObject *_wrap_Document_addLaws(PyObject *self, PyObject *args) {
22482 if (!PyTuple_Check(args)) SWIG_fail;
22483 argc = PyObject_Length(args);
22484 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
22485 argv[ii] = PyTuple_GET_ITEM(args,ii);
22490 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22491 _v = SWIG_CheckState(res);
22494 int res = SWIG_AsVal_double(argv[1], NULL);
22495 _v = SWIG_CheckState(res);
22498 return _wrap_Document_addLaws__SWIG_1(self, args);
22505 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22506 _v = SWIG_CheckState(res);
22509 int res = SWIG_AsVal_double(argv[1], NULL);
22510 _v = SWIG_CheckState(res);
22514 int res = SWIG_AsVal_bool(argv[2], NULL);
22515 _v = SWIG_CheckState(res);
22518 return _wrap_Document_addLaws__SWIG_0(self, args);
22525 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaws'.\n Possible C/C++ prototypes are:\n addLaws(double,bool)\n addLaws(double)\n");
22530 SWIGINTERN PyObject *_wrap_Document_addHexaGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22531 PyObject *resultobj = 0;
22532 Hex::Document *arg1 = (Hex::Document *) 0 ;
22533 cpchar arg2 = (cpchar) 0 ;
22534 Hex::Group *result = 0 ;
22540 PyObject * obj0 = 0 ;
22541 PyObject * obj1 = 0 ;
22543 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
22544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22545 if (!SWIG_IsOK(res1)) {
22546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22548 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22549 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22550 if (!SWIG_IsOK(res2)) {
22551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaGroup" "', argument " "2"" of type '" "cpchar""'");
22553 arg2 = reinterpret_cast< cpchar >(buf2);
22554 result = (Hex::Group *)(arg1)->addHexaGroup(arg2);
22555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22556 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22559 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22564 SWIGINTERN PyObject *_wrap_Document_addQuadGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565 PyObject *resultobj = 0;
22566 Hex::Document *arg1 = (Hex::Document *) 0 ;
22567 cpchar arg2 = (cpchar) 0 ;
22568 Hex::Group *result = 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22577 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
22578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22579 if (!SWIG_IsOK(res1)) {
22580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22582 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22583 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22584 if (!SWIG_IsOK(res2)) {
22585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadGroup" "', argument " "2"" of type '" "cpchar""'");
22587 arg2 = reinterpret_cast< cpchar >(buf2);
22588 result = (Hex::Group *)(arg1)->addQuadGroup(arg2);
22589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22590 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22593 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22598 SWIGINTERN PyObject *_wrap_Document_addQuadNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22599 PyObject *resultobj = 0;
22600 Hex::Document *arg1 = (Hex::Document *) 0 ;
22601 cpchar arg2 = (cpchar) 0 ;
22602 Hex::Group *result = 0 ;
22608 PyObject * obj0 = 0 ;
22609 PyObject * obj1 = 0 ;
22611 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
22612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22613 if (!SWIG_IsOK(res1)) {
22614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22616 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22617 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22618 if (!SWIG_IsOK(res2)) {
22619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22621 arg2 = reinterpret_cast< cpchar >(buf2);
22622 result = (Hex::Group *)(arg1)->addQuadNodeGroup(arg2);
22623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22624 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22627 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22632 SWIGINTERN PyObject *_wrap_Document_addHexaNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22633 PyObject *resultobj = 0;
22634 Hex::Document *arg1 = (Hex::Document *) 0 ;
22635 cpchar arg2 = (cpchar) 0 ;
22636 Hex::Group *result = 0 ;
22642 PyObject * obj0 = 0 ;
22643 PyObject * obj1 = 0 ;
22645 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
22646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22650 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22651 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22652 if (!SWIG_IsOK(res2)) {
22653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22655 arg2 = reinterpret_cast< cpchar >(buf2);
22656 result = (Hex::Group *)(arg1)->addHexaNodeGroup(arg2);
22657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22658 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22661 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22666 SWIGINTERN PyObject *_wrap_Document_addEdgeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22667 PyObject *resultobj = 0;
22668 Hex::Document *arg1 = (Hex::Document *) 0 ;
22669 cpchar arg2 = (cpchar) 0 ;
22670 Hex::Group *result = 0 ;
22676 PyObject * obj0 = 0 ;
22677 PyObject * obj1 = 0 ;
22679 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
22680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22681 if (!SWIG_IsOK(res1)) {
22682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22684 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22685 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22686 if (!SWIG_IsOK(res2)) {
22687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeGroup" "', argument " "2"" of type '" "cpchar""'");
22689 arg2 = reinterpret_cast< cpchar >(buf2);
22690 result = (Hex::Group *)(arg1)->addEdgeGroup(arg2);
22691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22692 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22695 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22700 SWIGINTERN PyObject *_wrap_Document_addEdgeNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701 PyObject *resultobj = 0;
22702 Hex::Document *arg1 = (Hex::Document *) 0 ;
22703 cpchar arg2 = (cpchar) 0 ;
22704 Hex::Group *result = 0 ;
22710 PyObject * obj0 = 0 ;
22711 PyObject * obj1 = 0 ;
22713 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
22714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22715 if (!SWIG_IsOK(res1)) {
22716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22718 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22719 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22720 if (!SWIG_IsOK(res2)) {
22721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22723 arg2 = reinterpret_cast< cpchar >(buf2);
22724 result = (Hex::Group *)(arg1)->addEdgeNodeGroup(arg2);
22725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22726 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22729 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22734 SWIGINTERN PyObject *_wrap_Document_addVertexNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22735 PyObject *resultobj = 0;
22736 Hex::Document *arg1 = (Hex::Document *) 0 ;
22737 cpchar arg2 = (cpchar) 0 ;
22738 Hex::Group *result = 0 ;
22744 PyObject * obj0 = 0 ;
22745 PyObject * obj1 = 0 ;
22747 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) SWIG_fail;
22748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22749 if (!SWIG_IsOK(res1)) {
22750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertexNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22752 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22753 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22754 if (!SWIG_IsOK(res2)) {
22755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVertexNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22757 arg2 = reinterpret_cast< cpchar >(buf2);
22758 result = (Hex::Group *)(arg1)->addVertexNodeGroup(arg2);
22759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
22760 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22763 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22768 SWIGINTERN PyObject *_wrap_Document_makeTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 Hex::Document *arg1 = (Hex::Document *) 0 ;
22771 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22772 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
22773 Hex::Elements *result = 0 ;
22780 PyObject * obj0 = 0 ;
22781 PyObject * obj1 = 0 ;
22782 PyObject * obj2 = 0 ;
22784 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
22785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22786 if (!SWIG_IsOK(res1)) {
22787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
22789 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
22791 if (!SWIG_IsOK(res2)) {
22792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
22794 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22795 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
22796 if (!SWIG_IsOK(res3)) {
22797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
22799 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
22800 result = (Hex::Elements *)(arg1)->makeTranslation(arg2,arg3);
22801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
22808 SWIGINTERN PyObject *_wrap_Document_makeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22809 PyObject *resultobj = 0;
22810 Hex::Document *arg1 = (Hex::Document *) 0 ;
22811 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22812 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22814 Hex::Elements *result = 0 ;
22823 PyObject * obj0 = 0 ;
22824 PyObject * obj1 = 0 ;
22825 PyObject * obj2 = 0 ;
22826 PyObject * obj3 = 0 ;
22828 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22830 if (!SWIG_IsOK(res1)) {
22831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeScale" "', argument " "1"" of type '" "Hex::Document *""'");
22833 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
22835 if (!SWIG_IsOK(res2)) {
22836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeScale" "', argument " "2"" of type '" "Hex::Elements *""'");
22838 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22839 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22840 if (!SWIG_IsOK(res3)) {
22841 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
22843 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22844 ecode4 = SWIG_AsVal_double(obj3, &val4);
22845 if (!SWIG_IsOK(ecode4)) {
22846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeScale" "', argument " "4"" of type '" "double""'");
22848 arg4 = static_cast< double >(val4);
22849 result = (Hex::Elements *)(arg1)->makeScale(arg2,arg3,arg4);
22850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
22857 SWIGINTERN PyObject *_wrap_Document_makeRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22858 PyObject *resultobj = 0;
22859 Hex::Document *arg1 = (Hex::Document *) 0 ;
22860 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22861 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22862 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
22864 Hex::Elements *result = 0 ;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877 PyObject * obj2 = 0 ;
22878 PyObject * obj3 = 0 ;
22879 PyObject * obj4 = 0 ;
22881 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22883 if (!SWIG_IsOK(res1)) {
22884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRotation" "', argument " "1"" of type '" "Hex::Document *""'");
22886 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
22888 if (!SWIG_IsOK(res2)) {
22889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
22891 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22892 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22893 if (!SWIG_IsOK(res3)) {
22894 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
22896 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22897 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
22898 if (!SWIG_IsOK(res4)) {
22899 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
22901 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
22902 ecode5 = SWIG_AsVal_double(obj4, &val5);
22903 if (!SWIG_IsOK(ecode5)) {
22904 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRotation" "', argument " "5"" of type '" "double""'");
22906 arg5 = static_cast< double >(val5);
22907 result = (Hex::Elements *)(arg1)->makeRotation(arg2,arg3,arg4,arg5);
22908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
22915 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916 PyObject *resultobj = 0;
22917 Hex::Document *arg1 = (Hex::Document *) 0 ;
22918 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22919 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22920 Hex::Elements *result = 0 ;
22927 PyObject * obj0 = 0 ;
22928 PyObject * obj1 = 0 ;
22929 PyObject * obj2 = 0 ;
22931 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
22932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22933 if (!SWIG_IsOK(res1)) {
22934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
22936 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
22938 if (!SWIG_IsOK(res2)) {
22939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
22941 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22942 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22943 if (!SWIG_IsOK(res3)) {
22944 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
22946 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22947 result = (Hex::Elements *)(arg1)->makeSymmetryPoint(arg2,arg3);
22948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
22955 SWIGINTERN PyObject *_wrap_Document_makeSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956 PyObject *resultobj = 0;
22957 Hex::Document *arg1 = (Hex::Document *) 0 ;
22958 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22959 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22960 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
22961 Hex::Elements *result = 0 ;
22970 PyObject * obj0 = 0 ;
22971 PyObject * obj1 = 0 ;
22972 PyObject * obj2 = 0 ;
22973 PyObject * obj3 = 0 ;
22975 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
22977 if (!SWIG_IsOK(res1)) {
22978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
22980 arg1 = reinterpret_cast< Hex::Document * >(argp1);
22981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
22982 if (!SWIG_IsOK(res2)) {
22983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
22985 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22986 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22987 if (!SWIG_IsOK(res3)) {
22988 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
22990 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22991 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
22992 if (!SWIG_IsOK(res4)) {
22993 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
22995 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
22996 result = (Hex::Elements *)(arg1)->makeSymmetryLine(arg2,arg3,arg4);
22997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23004 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 PyObject *resultobj = 0;
23006 Hex::Document *arg1 = (Hex::Document *) 0 ;
23007 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23008 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23009 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23010 Hex::Elements *result = 0 ;
23019 PyObject * obj0 = 0 ;
23020 PyObject * obj1 = 0 ;
23021 PyObject * obj2 = 0 ;
23022 PyObject * obj3 = 0 ;
23024 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23026 if (!SWIG_IsOK(res1)) {
23027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
23029 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23031 if (!SWIG_IsOK(res2)) {
23032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
23034 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23035 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23036 if (!SWIG_IsOK(res3)) {
23037 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
23039 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23040 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23041 if (!SWIG_IsOK(res4)) {
23042 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
23044 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23045 result = (Hex::Elements *)(arg1)->makeSymmetryPlane(arg2,arg3,arg4);
23046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23053 SWIGINTERN PyObject *_wrap_Document_performTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23054 PyObject *resultobj = 0;
23055 Hex::Document *arg1 = (Hex::Document *) 0 ;
23056 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23057 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
23065 PyObject * obj0 = 0 ;
23066 PyObject * obj1 = 0 ;
23067 PyObject * obj2 = 0 ;
23069 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
23070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23071 if (!SWIG_IsOK(res1)) {
23072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
23074 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23075 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23076 if (!SWIG_IsOK(res2)) {
23077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
23079 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23080 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23081 if (!SWIG_IsOK(res3)) {
23082 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
23084 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
23085 result = (int)(arg1)->performTranslation(arg2,arg3);
23086 resultobj = SWIG_From_int(static_cast< int >(result));
23093 SWIGINTERN PyObject *_wrap_Document_performScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 Hex::Document *arg1 = (Hex::Document *) 0 ;
23096 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23097 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23108 PyObject * obj0 = 0 ;
23109 PyObject * obj1 = 0 ;
23110 PyObject * obj2 = 0 ;
23111 PyObject * obj3 = 0 ;
23113 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23115 if (!SWIG_IsOK(res1)) {
23116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performScale" "', argument " "1"" of type '" "Hex::Document *""'");
23118 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23120 if (!SWIG_IsOK(res2)) {
23121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performScale" "', argument " "2"" of type '" "Hex::Elements *""'");
23123 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23124 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23125 if (!SWIG_IsOK(res3)) {
23126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
23128 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23129 ecode4 = SWIG_AsVal_double(obj3, &val4);
23130 if (!SWIG_IsOK(ecode4)) {
23131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_performScale" "', argument " "4"" of type '" "double""'");
23133 arg4 = static_cast< double >(val4);
23134 result = (int)(arg1)->performScale(arg2,arg3,arg4);
23135 resultobj = SWIG_From_int(static_cast< int >(result));
23142 SWIGINTERN PyObject *_wrap_Document_performRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23143 PyObject *resultobj = 0;
23144 Hex::Document *arg1 = (Hex::Document *) 0 ;
23145 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23146 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23147 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23160 PyObject * obj0 = 0 ;
23161 PyObject * obj1 = 0 ;
23162 PyObject * obj2 = 0 ;
23163 PyObject * obj3 = 0 ;
23164 PyObject * obj4 = 0 ;
23166 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23168 if (!SWIG_IsOK(res1)) {
23169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performRotation" "', argument " "1"" of type '" "Hex::Document *""'");
23171 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23173 if (!SWIG_IsOK(res2)) {
23174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
23176 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23177 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23178 if (!SWIG_IsOK(res3)) {
23179 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
23181 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23182 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23183 if (!SWIG_IsOK(res4)) {
23184 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
23186 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23187 ecode5 = SWIG_AsVal_double(obj4, &val5);
23188 if (!SWIG_IsOK(ecode5)) {
23189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_performRotation" "', argument " "5"" of type '" "double""'");
23191 arg5 = static_cast< double >(val5);
23192 result = (int)(arg1)->performRotation(arg2,arg3,arg4,arg5);
23193 resultobj = SWIG_From_int(static_cast< int >(result));
23200 SWIGINTERN PyObject *_wrap_Document_performSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23201 PyObject *resultobj = 0;
23202 Hex::Document *arg1 = (Hex::Document *) 0 ;
23203 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23204 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23212 PyObject * obj0 = 0 ;
23213 PyObject * obj1 = 0 ;
23214 PyObject * obj2 = 0 ;
23216 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
23217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23218 if (!SWIG_IsOK(res1)) {
23219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
23221 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23223 if (!SWIG_IsOK(res2)) {
23224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
23226 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23227 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23228 if (!SWIG_IsOK(res3)) {
23229 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
23231 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23232 result = (int)(arg1)->performSymmetryPoint(arg2,arg3);
23233 resultobj = SWIG_From_int(static_cast< int >(result));
23240 SWIGINTERN PyObject *_wrap_Document_performSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23241 PyObject *resultobj = 0;
23242 Hex::Document *arg1 = (Hex::Document *) 0 ;
23243 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23244 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23245 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23255 PyObject * obj0 = 0 ;
23256 PyObject * obj1 = 0 ;
23257 PyObject * obj2 = 0 ;
23258 PyObject * obj3 = 0 ;
23260 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23262 if (!SWIG_IsOK(res1)) {
23263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
23265 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23267 if (!SWIG_IsOK(res2)) {
23268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
23270 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23271 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23272 if (!SWIG_IsOK(res3)) {
23273 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
23275 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23276 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23277 if (!SWIG_IsOK(res4)) {
23278 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
23280 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23281 result = (int)(arg1)->performSymmetryLine(arg2,arg3,arg4);
23282 resultobj = SWIG_From_int(static_cast< int >(result));
23289 SWIGINTERN PyObject *_wrap_Document_performSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23290 PyObject *resultobj = 0;
23291 Hex::Document *arg1 = (Hex::Document *) 0 ;
23292 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23293 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23294 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23304 PyObject * obj0 = 0 ;
23305 PyObject * obj1 = 0 ;
23306 PyObject * obj2 = 0 ;
23307 PyObject * obj3 = 0 ;
23309 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
23314 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
23316 if (!SWIG_IsOK(res2)) {
23317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
23319 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23320 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23321 if (!SWIG_IsOK(res3)) {
23322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
23324 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23325 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23326 if (!SWIG_IsOK(res4)) {
23327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
23329 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23330 result = (int)(arg1)->performSymmetryPlane(arg2,arg3,arg4);
23331 resultobj = SWIG_From_int(static_cast< int >(result));
23338 SWIGINTERN PyObject *_wrap_Document_disconnectQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23339 PyObject *resultobj = 0;
23340 Hex::Document *arg1 = (Hex::Document *) 0 ;
23341 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23342 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23343 Hex::Elements *result = 0 ;
23350 PyObject * obj0 = 0 ;
23351 PyObject * obj1 = 0 ;
23352 PyObject * obj2 = 0 ;
23354 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
23355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23356 if (!SWIG_IsOK(res1)) {
23357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectQuad" "', argument " "1"" of type '" "Hex::Document *""'");
23359 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23361 if (!SWIG_IsOK(res2)) {
23362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectQuad" "', argument " "2"" of type '" "Hex::Hexa *""'");
23364 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23365 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23366 if (!SWIG_IsOK(res3)) {
23367 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
23369 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23370 result = (Hex::Elements *)(arg1)->disconnectQuad(arg2,arg3);
23371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23378 SWIGINTERN PyObject *_wrap_Document_disconnectEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 Hex::Document *arg1 = (Hex::Document *) 0 ;
23381 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23382 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
23383 Hex::Elements *result = 0 ;
23390 PyObject * obj0 = 0 ;
23391 PyObject * obj1 = 0 ;
23392 PyObject * obj2 = 0 ;
23394 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
23395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdge" "', argument " "1"" of type '" "Hex::Document *""'");
23399 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23401 if (!SWIG_IsOK(res2)) {
23402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectEdge" "', argument " "2"" of type '" "Hex::Hexa *""'");
23404 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23405 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23406 if (!SWIG_IsOK(res3)) {
23407 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
23409 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
23410 result = (Hex::Elements *)(arg1)->disconnectEdge(arg2,arg3);
23411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23418 SWIGINTERN PyObject *_wrap_Document_disconnectVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23419 PyObject *resultobj = 0;
23420 Hex::Document *arg1 = (Hex::Document *) 0 ;
23421 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23422 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23423 Hex::Elements *result = 0 ;
23430 PyObject * obj0 = 0 ;
23431 PyObject * obj1 = 0 ;
23432 PyObject * obj2 = 0 ;
23434 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
23435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23436 if (!SWIG_IsOK(res1)) {
23437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectVertex" "', argument " "1"" of type '" "Hex::Document *""'");
23439 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23441 if (!SWIG_IsOK(res2)) {
23442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectVertex" "', argument " "2"" of type '" "Hex::Hexa *""'");
23444 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23445 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23446 if (!SWIG_IsOK(res3)) {
23447 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
23449 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23450 result = (Hex::Elements *)(arg1)->disconnectVertex(arg2,arg3);
23451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23458 SWIGINTERN PyObject *_wrap_Document_disconnectEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 PyObject *resultobj = 0;
23460 Hex::Document *arg1 = (Hex::Document *) 0 ;
23463 Hex::Elements *result = 0 ;
23466 PyObject * obj0 = 0 ;
23467 PyObject * obj1 = 0 ;
23468 PyObject * obj2 = 0 ;
23470 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
23471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23472 if (!SWIG_IsOK(res1)) {
23473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdges" "', argument " "1"" of type '" "Hex::Document *""'");
23475 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23477 std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
23478 int res = swig::asptr(obj1, &ptr);
23479 if (!SWIG_IsOK(res) || !ptr) {
23480 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
23483 if (SWIG_IsNewObj(res)) delete ptr;
23486 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23487 int res = swig::asptr(obj2, &ptr);
23488 if (!SWIG_IsOK(res) || !ptr) {
23489 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
23492 if (SWIG_IsNewObj(res)) delete ptr;
23494 result = (Hex::Elements *)(arg1)->disconnectEdges(arg2,arg3);
23495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23502 SWIGINTERN PyObject *_wrap_Document_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23503 PyObject *resultobj = 0;
23504 Hex::Document *arg1 = (Hex::Document *) 0 ;
23507 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23508 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23509 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
23510 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
23511 Hex::Elements *result = 0 ;
23522 PyObject * obj0 = 0 ;
23523 PyObject * obj1 = 0 ;
23524 PyObject * obj2 = 0 ;
23525 PyObject * obj3 = 0 ;
23526 PyObject * obj4 = 0 ;
23527 PyObject * obj5 = 0 ;
23528 PyObject * obj6 = 0 ;
23530 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23532 if (!SWIG_IsOK(res1)) {
23533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
23535 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23537 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
23538 int res = swig::asptr(obj1, &ptr);
23539 if (!SWIG_IsOK(res) || !ptr) {
23540 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
23543 if (SWIG_IsNewObj(res)) delete ptr;
23546 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
23547 int res = swig::asptr(obj2, &ptr);
23548 if (!SWIG_IsOK(res) || !ptr) {
23549 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
23552 if (SWIG_IsNewObj(res)) delete ptr;
23554 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23555 if (!SWIG_IsOK(res4)) {
23556 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
23558 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23559 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23560 if (!SWIG_IsOK(res5)) {
23561 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_replace" "', argument " "5"" of type '" "Hex::Vertex *""'");
23563 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23564 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23565 if (!SWIG_IsOK(res6)) {
23566 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_replace" "', argument " "6"" of type '" "Hex::Vertex *""'");
23568 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
23569 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23570 if (!SWIG_IsOK(res7)) {
23571 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
23573 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
23574 result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
23575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
23582 SWIGINTERN PyObject *_wrap_Document_mergeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23583 PyObject *resultobj = 0;
23584 Hex::Document *arg1 = (Hex::Document *) 0 ;
23585 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23586 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23594 PyObject * obj0 = 0 ;
23595 PyObject * obj1 = 0 ;
23596 PyObject * obj2 = 0 ;
23598 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
23599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23600 if (!SWIG_IsOK(res1)) {
23601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeVertices" "', argument " "1"" of type '" "Hex::Document *""'");
23603 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23605 if (!SWIG_IsOK(res2)) {
23606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
23608 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23609 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23610 if (!SWIG_IsOK(res3)) {
23611 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
23613 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23614 result = (int)(arg1)->mergeVertices(arg2,arg3);
23615 resultobj = SWIG_From_int(static_cast< int >(result));
23622 SWIGINTERN PyObject *_wrap_Document_mergeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23623 PyObject *resultobj = 0;
23624 Hex::Document *arg1 = (Hex::Document *) 0 ;
23625 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
23626 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
23627 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23628 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23640 PyObject * obj0 = 0 ;
23641 PyObject * obj1 = 0 ;
23642 PyObject * obj2 = 0 ;
23643 PyObject * obj3 = 0 ;
23644 PyObject * obj4 = 0 ;
23646 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeEdges" "', argument " "1"" of type '" "Hex::Document *""'");
23651 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23653 if (!SWIG_IsOK(res2)) {
23654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeEdges" "', argument " "2"" of type '" "Hex::Edge *""'");
23656 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
23657 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23658 if (!SWIG_IsOK(res3)) {
23659 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeEdges" "', argument " "3"" of type '" "Hex::Edge *""'");
23661 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
23662 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23663 if (!SWIG_IsOK(res4)) {
23664 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeEdges" "', argument " "4"" of type '" "Hex::Vertex *""'");
23666 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23667 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23668 if (!SWIG_IsOK(res5)) {
23669 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeEdges" "', argument " "5"" of type '" "Hex::Vertex *""'");
23671 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23672 result = (int)(arg1)->mergeEdges(arg2,arg3,arg4,arg5);
23673 resultobj = SWIG_From_int(static_cast< int >(result));
23680 SWIGINTERN PyObject *_wrap_Document_mergeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23681 PyObject *resultobj = 0;
23682 Hex::Document *arg1 = (Hex::Document *) 0 ;
23683 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23684 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23685 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23686 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23687 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
23688 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
23704 PyObject * obj0 = 0 ;
23705 PyObject * obj1 = 0 ;
23706 PyObject * obj2 = 0 ;
23707 PyObject * obj3 = 0 ;
23708 PyObject * obj4 = 0 ;
23709 PyObject * obj5 = 0 ;
23710 PyObject * obj6 = 0 ;
23712 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
23717 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23719 if (!SWIG_IsOK(res2)) {
23720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
23722 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23724 if (!SWIG_IsOK(res3)) {
23725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
23727 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23728 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23729 if (!SWIG_IsOK(res4)) {
23730 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
23732 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23733 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23734 if (!SWIG_IsOK(res5)) {
23735 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
23737 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23738 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23739 if (!SWIG_IsOK(res6)) {
23740 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_mergeQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
23742 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
23743 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23744 if (!SWIG_IsOK(res7)) {
23745 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_mergeQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
23747 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
23748 result = (int)(arg1)->mergeQuads(arg2,arg3,arg4,arg5,arg6,arg7);
23749 resultobj = SWIG_From_int(static_cast< int >(result));
23756 SWIGINTERN PyObject *_wrap_Document_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757 PyObject *resultobj = 0;
23758 Hex::Document *arg1 = (Hex::Document *) 0 ;
23761 PyObject * obj0 = 0 ;
23763 if (!PyArg_ParseTuple(args,(char *)"O:Document_clearAssociation",&obj0)) SWIG_fail;
23764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23765 if (!SWIG_IsOK(res1)) {
23766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clearAssociation" "', argument " "1"" of type '" "Hex::Document *""'");
23768 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23769 (arg1)->clearAssociation();
23770 resultobj = SWIG_Py_Void();
23777 SWIGINTERN PyObject *_wrap_Document_associateOpenedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23778 PyObject *resultobj = 0;
23779 Hex::Document *arg1 = (Hex::Document *) 0 ;
23781 Hex::NewShapes arg3 ;
23782 Hex::IntVector arg4 ;
23792 PyObject * obj0 = 0 ;
23793 PyObject * obj1 = 0 ;
23794 PyObject * obj2 = 0 ;
23795 PyObject * obj3 = 0 ;
23796 PyObject * obj4 = 0 ;
23797 PyObject * obj5 = 0 ;
23799 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23801 if (!SWIG_IsOK(res1)) {
23802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateOpenedLine" "', argument " "1"" of type '" "Hex::Document *""'");
23804 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23806 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23807 int res = swig::asptr(obj1, &ptr);
23808 if (!SWIG_IsOK(res) || !ptr) {
23809 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
23812 if (SWIG_IsNewObj(res)) delete ptr;
23815 std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
23816 int res = swig::asptr(obj2, &ptr);
23817 if (!SWIG_IsOK(res) || !ptr) {
23818 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
23821 if (SWIG_IsNewObj(res)) delete ptr;
23824 std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
23825 int res = swig::asptr(obj3, &ptr);
23826 if (!SWIG_IsOK(res) || !ptr) {
23827 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
23830 if (SWIG_IsNewObj(res)) delete ptr;
23832 ecode5 = SWIG_AsVal_double(obj4, &val5);
23833 if (!SWIG_IsOK(ecode5)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_associateOpenedLine" "', argument " "5"" of type '" "double""'");
23836 arg5 = static_cast< double >(val5);
23837 ecode6 = SWIG_AsVal_double(obj5, &val6);
23838 if (!SWIG_IsOK(ecode6)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateOpenedLine" "', argument " "6"" of type '" "double""'");
23841 arg6 = static_cast< double >(val6);
23842 result = (int)(arg1)->associateOpenedLine(arg2,arg3,arg4,arg5,arg6);
23843 resultobj = SWIG_From_int(static_cast< int >(result));
23850 SWIGINTERN PyObject *_wrap_Document_associateClosedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851 PyObject *resultobj = 0;
23852 Hex::Document *arg1 = (Hex::Document *) 0 ;
23853 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23855 Hex::NewShapes arg4 ;
23856 Hex::IntVector arg5 ;
23868 PyObject * obj0 = 0 ;
23869 PyObject * obj1 = 0 ;
23870 PyObject * obj2 = 0 ;
23871 PyObject * obj3 = 0 ;
23872 PyObject * obj4 = 0 ;
23873 PyObject * obj5 = 0 ;
23874 PyObject * obj6 = 0 ;
23876 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateClosedLine" "', argument " "1"" of type '" "Hex::Document *""'");
23881 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23883 if (!SWIG_IsOK(res2)) {
23884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_associateClosedLine" "', argument " "2"" of type '" "Hex::Vertex *""'");
23886 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23888 std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23889 int res = swig::asptr(obj2, &ptr);
23890 if (!SWIG_IsOK(res) || !ptr) {
23891 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
23894 if (SWIG_IsNewObj(res)) delete ptr;
23897 std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
23898 int res = swig::asptr(obj3, &ptr);
23899 if (!SWIG_IsOK(res) || !ptr) {
23900 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
23903 if (SWIG_IsNewObj(res)) delete ptr;
23906 std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
23907 int res = swig::asptr(obj4, &ptr);
23908 if (!SWIG_IsOK(res) || !ptr) {
23909 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
23912 if (SWIG_IsNewObj(res)) delete ptr;
23914 ecode6 = SWIG_AsVal_double(obj5, &val6);
23915 if (!SWIG_IsOK(ecode6)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateClosedLine" "', argument " "6"" of type '" "double""'");
23918 arg6 = static_cast< double >(val6);
23919 ecode7 = SWIG_AsVal_bool(obj6, &val7);
23920 if (!SWIG_IsOK(ecode7)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_associateClosedLine" "', argument " "7"" of type '" "bool""'");
23923 arg7 = static_cast< bool >(val7);
23924 result = (int)(arg1)->associateClosedLine(arg2,arg3,arg4,arg5,arg6,arg7);
23925 resultobj = SWIG_From_int(static_cast< int >(result));
23932 SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23933 PyObject *resultobj = 0;
23934 Hex::Document *arg1 = (Hex::Document *) 0 ;
23938 PyObject * obj0 = 0 ;
23940 if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
23941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countHexa" "', argument " "1"" of type '" "Hex::Document *""'");
23945 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23946 result = (int)(arg1)->countHexa();
23947 resultobj = SWIG_From_int(static_cast< int >(result));
23954 SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955 PyObject *resultobj = 0;
23956 Hex::Document *arg1 = (Hex::Document *) 0 ;
23960 PyObject * obj0 = 0 ;
23962 if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
23963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23964 if (!SWIG_IsOK(res1)) {
23965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countQuad" "', argument " "1"" of type '" "Hex::Document *""'");
23967 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23968 result = (int)(arg1)->countQuad();
23969 resultobj = SWIG_From_int(static_cast< int >(result));
23976 SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *resultobj = 0;
23978 Hex::Document *arg1 = (Hex::Document *) 0 ;
23982 PyObject * obj0 = 0 ;
23984 if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
23985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countEdge" "', argument " "1"" of type '" "Hex::Document *""'");
23989 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23990 result = (int)(arg1)->countEdge();
23991 resultobj = SWIG_From_int(static_cast< int >(result));
23998 SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23999 PyObject *resultobj = 0;
24000 Hex::Document *arg1 = (Hex::Document *) 0 ;
24004 PyObject * obj0 = 0 ;
24006 if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
24007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24008 if (!SWIG_IsOK(res1)) {
24009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24011 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24012 result = (int)(arg1)->countVertex();
24013 resultobj = SWIG_From_int(static_cast< int >(result));
24020 SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021 PyObject *resultobj = 0;
24022 Hex::Document *arg1 = (Hex::Document *) 0 ;
24026 PyObject * obj0 = 0 ;
24028 if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
24029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVector" "', argument " "1"" of type '" "Hex::Document *""'");
24033 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24034 result = (int)(arg1)->countVector();
24035 resultobj = SWIG_From_int(static_cast< int >(result));
24042 SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24043 PyObject *resultobj = 0;
24044 Hex::Document *arg1 = (Hex::Document *) 0 ;
24048 PyObject * obj0 = 0 ;
24050 if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
24051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24052 if (!SWIG_IsOK(res1)) {
24053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24055 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24056 result = (int)(arg1)->countGroup();
24057 resultobj = SWIG_From_int(static_cast< int >(result));
24064 SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *resultobj = 0;
24066 Hex::Document *arg1 = (Hex::Document *) 0 ;
24070 PyObject * obj0 = 0 ;
24072 if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
24073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24077 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24078 result = (int)(arg1)->countLaw();
24079 resultobj = SWIG_From_int(static_cast< int >(result));
24086 SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 PyObject *resultobj = 0;
24088 Hex::Document *arg1 = (Hex::Document *) 0 ;
24092 PyObject * obj0 = 0 ;
24094 if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
24095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24096 if (!SWIG_IsOK(res1)) {
24097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24099 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24100 result = (int)(arg1)->countPropagation();
24101 resultobj = SWIG_From_int(static_cast< int >(result));
24108 SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24109 PyObject *resultobj = 0;
24110 Hex::Document *arg1 = (Hex::Document *) 0 ;
24114 PyObject * obj0 = 0 ;
24116 if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
24117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countShape" "', argument " "1"" of type '" "Hex::Document *""'");
24121 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24122 result = (int)(arg1)->countShape();
24123 resultobj = SWIG_From_int(static_cast< int >(result));
24130 SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24131 PyObject *resultobj = 0;
24132 Hex::Document *arg1 = (Hex::Document *) 0 ;
24136 PyObject * obj0 = 0 ;
24138 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
24139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24140 if (!SWIG_IsOK(res1)) {
24141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24143 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24144 result = (int)(arg1)->countUsedHexa();
24145 resultobj = SWIG_From_int(static_cast< int >(result));
24152 SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24153 PyObject *resultobj = 0;
24154 Hex::Document *arg1 = (Hex::Document *) 0 ;
24158 PyObject * obj0 = 0 ;
24160 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
24161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24162 if (!SWIG_IsOK(res1)) {
24163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24165 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24166 result = (int)(arg1)->countUsedQuad();
24167 resultobj = SWIG_From_int(static_cast< int >(result));
24174 SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24175 PyObject *resultobj = 0;
24176 Hex::Document *arg1 = (Hex::Document *) 0 ;
24180 PyObject * obj0 = 0 ;
24182 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
24183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24187 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24188 result = (int)(arg1)->countUsedEdge();
24189 resultobj = SWIG_From_int(static_cast< int >(result));
24196 SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 PyObject *resultobj = 0;
24198 Hex::Document *arg1 = (Hex::Document *) 0 ;
24202 PyObject * obj0 = 0 ;
24204 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
24205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24206 if (!SWIG_IsOK(res1)) {
24207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24209 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24210 result = (int)(arg1)->countUsedVertex();
24211 resultobj = SWIG_From_int(static_cast< int >(result));
24218 SWIGINTERN PyObject *_wrap_Document_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24219 PyObject *resultobj = 0;
24220 Hex::Document *arg1 = (Hex::Document *) 0 ;
24222 Hex::Hexa *result = 0 ;
24227 PyObject * obj0 = 0 ;
24228 PyObject * obj1 = 0 ;
24230 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
24231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24232 if (!SWIG_IsOK(res1)) {
24233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24235 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24236 ecode2 = SWIG_AsVal_int(obj1, &val2);
24237 if (!SWIG_IsOK(ecode2)) {
24238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getHexa" "', argument " "2"" of type '" "int""'");
24240 arg2 = static_cast< int >(val2);
24241 result = (Hex::Hexa *)(arg1)->getHexa(arg2);
24242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
24249 SWIGINTERN PyObject *_wrap_Document_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 Hex::Document *arg1 = (Hex::Document *) 0 ;
24253 Hex::Quad *result = 0 ;
24258 PyObject * obj0 = 0 ;
24259 PyObject * obj1 = 0 ;
24261 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24266 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24267 ecode2 = SWIG_AsVal_int(obj1, &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getQuad" "', argument " "2"" of type '" "int""'");
24271 arg2 = static_cast< int >(val2);
24272 result = (Hex::Quad *)(arg1)->getQuad(arg2);
24273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
24280 SWIGINTERN PyObject *_wrap_Document_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 Hex::Document *arg1 = (Hex::Document *) 0 ;
24284 Hex::Edge *result = 0 ;
24289 PyObject * obj0 = 0 ;
24290 PyObject * obj1 = 0 ;
24292 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
24293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24294 if (!SWIG_IsOK(res1)) {
24295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24297 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24298 ecode2 = SWIG_AsVal_int(obj1, &val2);
24299 if (!SWIG_IsOK(ecode2)) {
24300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getEdge" "', argument " "2"" of type '" "int""'");
24302 arg2 = static_cast< int >(val2);
24303 result = (Hex::Edge *)(arg1)->getEdge(arg2);
24304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
24311 SWIGINTERN PyObject *_wrap_Document_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 PyObject *resultobj = 0;
24313 Hex::Document *arg1 = (Hex::Document *) 0 ;
24315 Hex::Vertex *result = 0 ;
24320 PyObject * obj0 = 0 ;
24321 PyObject * obj1 = 0 ;
24323 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
24324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24325 if (!SWIG_IsOK(res1)) {
24326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24328 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24329 ecode2 = SWIG_AsVal_int(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVertex" "', argument " "2"" of type '" "int""'");
24333 arg2 = static_cast< int >(val2);
24334 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
24335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24342 SWIGINTERN PyObject *_wrap_Document_getUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343 PyObject *resultobj = 0;
24344 Hex::Document *arg1 = (Hex::Document *) 0 ;
24346 Hex::Hexa *result = 0 ;
24351 PyObject * obj0 = 0 ;
24352 PyObject * obj1 = 0 ;
24354 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
24355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24356 if (!SWIG_IsOK(res1)) {
24357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24359 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24360 ecode2 = SWIG_AsVal_int(obj1, &val2);
24361 if (!SWIG_IsOK(ecode2)) {
24362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedHexa" "', argument " "2"" of type '" "int""'");
24364 arg2 = static_cast< int >(val2);
24365 result = (Hex::Hexa *)(arg1)->getUsedHexa(arg2);
24366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
24373 SWIGINTERN PyObject *_wrap_Document_getUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24374 PyObject *resultobj = 0;
24375 Hex::Document *arg1 = (Hex::Document *) 0 ;
24377 Hex::Quad *result = 0 ;
24382 PyObject * obj0 = 0 ;
24383 PyObject * obj1 = 0 ;
24385 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
24386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24387 if (!SWIG_IsOK(res1)) {
24388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24390 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24391 ecode2 = SWIG_AsVal_int(obj1, &val2);
24392 if (!SWIG_IsOK(ecode2)) {
24393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedQuad" "', argument " "2"" of type '" "int""'");
24395 arg2 = static_cast< int >(val2);
24396 result = (Hex::Quad *)(arg1)->getUsedQuad(arg2);
24397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
24404 SWIGINTERN PyObject *_wrap_Document_getUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 Hex::Document *arg1 = (Hex::Document *) 0 ;
24408 Hex::Edge *result = 0 ;
24413 PyObject * obj0 = 0 ;
24414 PyObject * obj1 = 0 ;
24416 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
24417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24418 if (!SWIG_IsOK(res1)) {
24419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24421 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24422 ecode2 = SWIG_AsVal_int(obj1, &val2);
24423 if (!SWIG_IsOK(ecode2)) {
24424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedEdge" "', argument " "2"" of type '" "int""'");
24426 arg2 = static_cast< int >(val2);
24427 result = (Hex::Edge *)(arg1)->getUsedEdge(arg2);
24428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
24435 SWIGINTERN PyObject *_wrap_Document_getUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24436 PyObject *resultobj = 0;
24437 Hex::Document *arg1 = (Hex::Document *) 0 ;
24439 Hex::Vertex *result = 0 ;
24444 PyObject * obj0 = 0 ;
24445 PyObject * obj1 = 0 ;
24447 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
24448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24449 if (!SWIG_IsOK(res1)) {
24450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24452 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24453 ecode2 = SWIG_AsVal_int(obj1, &val2);
24454 if (!SWIG_IsOK(ecode2)) {
24455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedVertex" "', argument " "2"" of type '" "int""'");
24457 arg2 = static_cast< int >(val2);
24458 result = (Hex::Vertex *)(arg1)->getUsedVertex(arg2);
24459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24466 SWIGINTERN PyObject *_wrap_Document_getVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467 PyObject *resultobj = 0;
24468 Hex::Document *arg1 = (Hex::Document *) 0 ;
24470 Hex::Vector *result = 0 ;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24478 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
24479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24480 if (!SWIG_IsOK(res1)) {
24481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVector" "', argument " "1"" of type '" "Hex::Document *""'");
24483 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24484 ecode2 = SWIG_AsVal_int(obj1, &val2);
24485 if (!SWIG_IsOK(ecode2)) {
24486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVector" "', argument " "2"" of type '" "int""'");
24488 arg2 = static_cast< int >(val2);
24489 result = (Hex::Vector *)(arg1)->getVector(arg2);
24490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
24497 SWIGINTERN PyObject *_wrap_Document_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24498 PyObject *resultobj = 0;
24499 Hex::Document *arg1 = (Hex::Document *) 0 ;
24501 Hex::NewShape *result = 0 ;
24506 PyObject * obj0 = 0 ;
24507 PyObject * obj1 = 0 ;
24509 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
24510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getShape" "', argument " "1"" of type '" "Hex::Document *""'");
24514 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24515 ecode2 = SWIG_AsVal_int(obj1, &val2);
24516 if (!SWIG_IsOK(ecode2)) {
24517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getShape" "', argument " "2"" of type '" "int""'");
24519 arg2 = static_cast< int >(val2);
24520 result = (Hex::NewShape *)(arg1)->getShape(arg2);
24521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
24528 SWIGINTERN PyObject *_wrap_Document_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 Hex::Document *arg1 = (Hex::Document *) 0 ;
24532 Hex::Group *result = 0 ;
24537 PyObject * obj0 = 0 ;
24538 PyObject * obj1 = 0 ;
24540 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
24541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24545 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24546 ecode2 = SWIG_AsVal_int(obj1, &val2);
24547 if (!SWIG_IsOK(ecode2)) {
24548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getGroup" "', argument " "2"" of type '" "int""'");
24550 arg2 = static_cast< int >(val2);
24551 result = (Hex::Group *)(arg1)->getGroup(arg2);
24552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
24559 SWIGINTERN PyObject *_wrap_Document_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24560 PyObject *resultobj = 0;
24561 Hex::Document *arg1 = (Hex::Document *) 0 ;
24563 Hex::Law *result = 0 ;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24571 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
24572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24573 if (!SWIG_IsOK(res1)) {
24574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24576 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24577 ecode2 = SWIG_AsVal_int(obj1, &val2);
24578 if (!SWIG_IsOK(ecode2)) {
24579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getLaw" "', argument " "2"" of type '" "int""'");
24581 arg2 = static_cast< int >(val2);
24582 result = (Hex::Law *)(arg1)->getLaw(arg2);
24583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
24590 SWIGINTERN PyObject *_wrap_Document_getPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591 PyObject *resultobj = 0;
24592 Hex::Document *arg1 = (Hex::Document *) 0 ;
24594 Hex::Propagation *result = 0 ;
24599 PyObject * obj0 = 0 ;
24600 PyObject * obj1 = 0 ;
24602 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
24603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24604 if (!SWIG_IsOK(res1)) {
24605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24607 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24608 ecode2 = SWIG_AsVal_int(obj1, &val2);
24609 if (!SWIG_IsOK(ecode2)) {
24610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getPropagation" "', argument " "2"" of type '" "int""'");
24612 arg2 = static_cast< int >(val2);
24613 result = (Hex::Propagation *)(arg1)->getPropagation(arg2);
24614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 | 0 );
24621 SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 PyObject *resultobj = 0;
24623 Hex::Document *arg1 = (Hex::Document *) 0 ;
24627 PyObject * obj0 = 0 ;
24629 if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
24630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
24634 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24635 result = (cpchar)(arg1)->getFirstExplicitShape();
24636 resultobj = SWIG_FromCharPtr((const char *)result);
24643 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24644 PyObject *resultobj = 0;
24645 Hex::Document *arg1 = (Hex::Document *) 0 ;
24649 Hex::Vertex *result = 0 ;
24658 PyObject * obj0 = 0 ;
24659 PyObject * obj1 = 0 ;
24660 PyObject * obj2 = 0 ;
24661 PyObject * obj3 = 0 ;
24663 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24665 if (!SWIG_IsOK(res1)) {
24666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24668 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24669 ecode2 = SWIG_AsVal_double(obj1, &val2);
24670 if (!SWIG_IsOK(ecode2)) {
24671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
24673 arg2 = static_cast< double >(val2);
24674 ecode3 = SWIG_AsVal_double(obj2, &val3);
24675 if (!SWIG_IsOK(ecode3)) {
24676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
24678 arg3 = static_cast< double >(val3);
24679 ecode4 = SWIG_AsVal_double(obj3, &val4);
24680 if (!SWIG_IsOK(ecode4)) {
24681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
24683 arg4 = static_cast< double >(val4);
24684 result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
24685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24692 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 Hex::Document *arg1 = (Hex::Document *) 0 ;
24695 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24696 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24697 Hex::Edge *result = 0 ;
24704 PyObject * obj0 = 0 ;
24705 PyObject * obj1 = 0 ;
24706 PyObject * obj2 = 0 ;
24708 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24710 if (!SWIG_IsOK(res1)) {
24711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24713 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24715 if (!SWIG_IsOK(res2)) {
24716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
24718 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24719 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24720 if (!SWIG_IsOK(res3)) {
24721 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
24723 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24724 result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
24725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
24732 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24733 PyObject *resultobj = 0;
24734 Hex::Document *arg1 = (Hex::Document *) 0 ;
24735 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24736 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24737 Hex::Quad *result = 0 ;
24744 PyObject * obj0 = 0 ;
24745 PyObject * obj1 = 0 ;
24746 PyObject * obj2 = 0 ;
24748 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24753 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24755 if (!SWIG_IsOK(res2)) {
24756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
24758 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24759 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24760 if (!SWIG_IsOK(res3)) {
24761 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
24763 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24764 result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
24772 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24773 PyObject *resultobj = 0;
24774 Hex::Document *arg1 = (Hex::Document *) 0 ;
24775 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24776 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24777 Hex::Quad *result = 0 ;
24784 PyObject * obj0 = 0 ;
24785 PyObject * obj1 = 0 ;
24786 PyObject * obj2 = 0 ;
24788 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24790 if (!SWIG_IsOK(res1)) {
24791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24793 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
24795 if (!SWIG_IsOK(res2)) {
24796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
24798 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24799 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
24800 if (!SWIG_IsOK(res3)) {
24801 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
24803 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
24804 result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
24812 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
24817 if (!PyTuple_Check(args)) SWIG_fail;
24818 argc = PyObject_Length(args);
24819 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
24820 argv[ii] = PyTuple_GET_ITEM(args,ii);
24825 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24826 _v = SWIG_CheckState(res);
24829 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24830 _v = SWIG_CheckState(res);
24833 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24834 _v = SWIG_CheckState(res);
24836 return _wrap_Document_findQuad__SWIG_0(self, args);
24844 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24845 _v = SWIG_CheckState(res);
24848 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24849 _v = SWIG_CheckState(res);
24852 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24853 _v = SWIG_CheckState(res);
24855 return _wrap_Document_findQuad__SWIG_1(self, args);
24862 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findQuad'.\n Possible C/C++ prototypes are:\n findQuad(Hex::Vertex *,Hex::Vertex *)\n findQuad(Hex::Edge *,Hex::Edge *)\n");
24867 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24868 PyObject *resultobj = 0;
24869 Hex::Document *arg1 = (Hex::Document *) 0 ;
24870 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24871 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24872 Hex::Hexa *result = 0 ;
24879 PyObject * obj0 = 0 ;
24880 PyObject * obj1 = 0 ;
24881 PyObject * obj2 = 0 ;
24883 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
24884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24888 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24890 if (!SWIG_IsOK(res2)) {
24891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
24893 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24894 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24895 if (!SWIG_IsOK(res3)) {
24896 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
24898 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24899 result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
24900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
24907 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24908 PyObject *resultobj = 0;
24909 Hex::Document *arg1 = (Hex::Document *) 0 ;
24910 cpchar arg2 = (cpchar) 0 ;
24911 Hex::Group *result = 0 ;
24917 PyObject * obj0 = 0 ;
24918 PyObject * obj1 = 0 ;
24920 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
24921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24922 if (!SWIG_IsOK(res1)) {
24923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24925 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24926 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24927 if (!SWIG_IsOK(res2)) {
24928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
24930 arg2 = reinterpret_cast< cpchar >(buf2);
24931 result = (Hex::Group *)(arg1)->findGroup(arg2);
24932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
24933 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24936 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24941 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24942 PyObject *resultobj = 0;
24943 Hex::Document *arg1 = (Hex::Document *) 0 ;
24944 cpchar arg2 = (cpchar) 0 ;
24945 Hex::Law *result = 0 ;
24951 PyObject * obj0 = 0 ;
24952 PyObject * obj1 = 0 ;
24954 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
24955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24959 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24960 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24961 if (!SWIG_IsOK(res2)) {
24962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
24964 arg2 = reinterpret_cast< cpchar >(buf2);
24965 result = (Hex::Law *)(arg1)->findLaw(arg2);
24966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
24967 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24970 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24975 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24976 PyObject *resultobj = 0;
24977 Hex::Document *arg1 = (Hex::Document *) 0 ;
24978 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24979 Hex::Propagation *result = 0 ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24987 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
24988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24989 if (!SWIG_IsOK(res1)) {
24990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24992 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
24994 if (!SWIG_IsOK(res2)) {
24995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
24997 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24998 result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
24999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 | 0 );
25006 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25007 PyObject *resultobj = 0;
25008 Hex::Document *arg1 = (Hex::Document *) 0 ;
25009 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
25015 PyObject * obj0 = 0 ;
25016 PyObject * obj1 = 0 ;
25018 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
25019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25020 if (!SWIG_IsOK(res1)) {
25021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25023 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25025 if (!SWIG_IsOK(res2)) {
25026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25028 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25029 result = (int)(arg1)->removeHexa(arg2);
25030 resultobj = SWIG_From_int(static_cast< int >(result));
25037 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25038 PyObject *resultobj = 0;
25039 Hex::Document *arg1 = (Hex::Document *) 0 ;
25040 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25046 PyObject * obj0 = 0 ;
25047 PyObject * obj1 = 0 ;
25049 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
25050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25054 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25056 if (!SWIG_IsOK(res2)) {
25057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
25059 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25060 result = (int)(arg1)->removeQuad(arg2);
25061 resultobj = SWIG_From_int(static_cast< int >(result));
25068 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25069 PyObject *resultobj = 0;
25070 Hex::Document *arg1 = (Hex::Document *) 0 ;
25071 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
25077 PyObject * obj0 = 0 ;
25078 PyObject * obj1 = 0 ;
25080 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
25081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25082 if (!SWIG_IsOK(res1)) {
25083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25085 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25087 if (!SWIG_IsOK(res2)) {
25088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25090 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25091 result = (int)(arg1)->removeConnectedHexa(arg2);
25092 resultobj = SWIG_From_int(static_cast< int >(result));
25099 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25100 PyObject *resultobj = 0;
25101 Hex::Document *arg1 = (Hex::Document *) 0 ;
25102 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
25108 PyObject * obj0 = 0 ;
25109 PyObject * obj1 = 0 ;
25111 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
25112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
25116 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
25118 if (!SWIG_IsOK(res2)) {
25119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
25121 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
25122 result = (int)(arg1)->removeElements(arg2);
25123 resultobj = SWIG_From_int(static_cast< int >(result));
25130 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131 PyObject *resultobj = 0;
25132 Hex::Document *arg1 = (Hex::Document *) 0 ;
25133 Hex::Group *arg2 = (Hex::Group *) 0 ;
25139 PyObject * obj0 = 0 ;
25140 PyObject * obj1 = 0 ;
25142 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
25143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25144 if (!SWIG_IsOK(res1)) {
25145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25147 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 | 0 );
25149 if (!SWIG_IsOK(res2)) {
25150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
25152 arg2 = reinterpret_cast< Hex::Group * >(argp2);
25153 result = (int)(arg1)->removeGroup(arg2);
25154 resultobj = SWIG_From_int(static_cast< int >(result));
25161 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25162 PyObject *resultobj = 0;
25163 Hex::Document *arg1 = (Hex::Document *) 0 ;
25164 Hex::Law *arg2 = (Hex::Law *) 0 ;
25170 PyObject * obj0 = 0 ;
25171 PyObject * obj1 = 0 ;
25173 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
25174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25178 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
25180 if (!SWIG_IsOK(res2)) {
25181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
25183 arg2 = reinterpret_cast< Hex::Law * >(argp2);
25184 result = (int)(arg1)->removeLaw(arg2);
25185 resultobj = SWIG_From_int(static_cast< int >(result));
25192 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 Hex::Document *arg1 = (Hex::Document *) 0 ;
25198 Hex::Elements *result = 0 ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 PyObject * obj2 = 0 ;
25210 PyObject * obj3 = 0 ;
25212 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25214 if (!SWIG_IsOK(res1)) {
25215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
25217 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25218 ecode2 = SWIG_AsVal_int(obj1, &val2);
25219 if (!SWIG_IsOK(ecode2)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
25222 arg2 = static_cast< int >(val2);
25223 ecode3 = SWIG_AsVal_int(obj2, &val3);
25224 if (!SWIG_IsOK(ecode3)) {
25225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
25227 arg3 = static_cast< int >(val3);
25228 ecode4 = SWIG_AsVal_int(obj3, &val4);
25229 if (!SWIG_IsOK(ecode4)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
25232 arg4 = static_cast< int >(val4);
25233 result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
25234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25241 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25242 PyObject *resultobj = 0;
25243 Hex::Document *arg1 = (Hex::Document *) 0 ;
25244 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25245 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25246 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25247 Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25254 Hex::Elements *result = 0 ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 PyObject * obj2 = 0 ;
25280 PyObject * obj3 = 0 ;
25281 PyObject * obj4 = 0 ;
25282 PyObject * obj5 = 0 ;
25283 PyObject * obj6 = 0 ;
25284 PyObject * obj7 = 0 ;
25285 PyObject * obj8 = 0 ;
25286 PyObject * obj9 = 0 ;
25287 PyObject * obj10 = 0 ;
25289 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25291 if (!SWIG_IsOK(res1)) {
25292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
25294 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25296 if (!SWIG_IsOK(res2)) {
25297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25299 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25300 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25301 if (!SWIG_IsOK(res3)) {
25302 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25304 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25305 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25306 if (!SWIG_IsOK(res4)) {
25307 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25309 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25310 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25311 if (!SWIG_IsOK(res5)) {
25312 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
25314 arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25315 ecode6 = SWIG_AsVal_double(obj5, &val6);
25316 if (!SWIG_IsOK(ecode6)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
25319 arg6 = static_cast< double >(val6);
25320 ecode7 = SWIG_AsVal_double(obj6, &val7);
25321 if (!SWIG_IsOK(ecode7)) {
25322 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
25324 arg7 = static_cast< double >(val7);
25325 ecode8 = SWIG_AsVal_double(obj7, &val8);
25326 if (!SWIG_IsOK(ecode8)) {
25327 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
25329 arg8 = static_cast< double >(val8);
25330 ecode9 = SWIG_AsVal_int(obj8, &val9);
25331 if (!SWIG_IsOK(ecode9)) {
25332 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
25334 arg9 = static_cast< int >(val9);
25335 ecode10 = SWIG_AsVal_int(obj9, &val10);
25336 if (!SWIG_IsOK(ecode10)) {
25337 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
25339 arg10 = static_cast< int >(val10);
25340 ecode11 = SWIG_AsVal_int(obj10, &val11);
25341 if (!SWIG_IsOK(ecode11)) {
25342 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
25344 arg11 = static_cast< int >(val11);
25345 result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25353 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *resultobj = 0;
25355 Hex::Document *arg1 = (Hex::Document *) 0 ;
25356 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25357 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25358 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25359 Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25360 Hex::RealVector arg6 ;
25361 Hex::RealVector arg7 ;
25362 Hex::RealVector arg8 ;
25363 Hex::Elements *result = 0 ;
25374 PyObject * obj0 = 0 ;
25375 PyObject * obj1 = 0 ;
25376 PyObject * obj2 = 0 ;
25377 PyObject * obj3 = 0 ;
25378 PyObject * obj4 = 0 ;
25379 PyObject * obj5 = 0 ;
25380 PyObject * obj6 = 0 ;
25381 PyObject * obj7 = 0 ;
25383 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
25388 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25390 if (!SWIG_IsOK(res2)) {
25391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
25393 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25394 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25395 if (!SWIG_IsOK(res3)) {
25396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
25398 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25399 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25400 if (!SWIG_IsOK(res4)) {
25401 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
25403 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25404 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25405 if (!SWIG_IsOK(res5)) {
25406 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
25408 arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25410 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25411 int res = swig::asptr(obj5, &ptr);
25412 if (!SWIG_IsOK(res) || !ptr) {
25413 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
25416 if (SWIG_IsNewObj(res)) delete ptr;
25419 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25420 int res = swig::asptr(obj6, &ptr);
25421 if (!SWIG_IsOK(res) || !ptr) {
25422 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
25425 if (SWIG_IsNewObj(res)) delete ptr;
25428 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25429 int res = swig::asptr(obj7, &ptr);
25430 if (!SWIG_IsOK(res) || !ptr) {
25431 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
25434 if (SWIG_IsNewObj(res)) delete ptr;
25436 result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
25437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25444 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 Hex::Document *arg1 = (Hex::Document *) 0 ;
25450 Hex::Elements *result = 0 ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 PyObject * obj2 = 0 ;
25462 PyObject * obj3 = 0 ;
25464 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25466 if (!SWIG_IsOK(res1)) {
25467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
25469 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25470 ecode2 = SWIG_AsVal_int(obj1, &val2);
25471 if (!SWIG_IsOK(ecode2)) {
25472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
25474 arg2 = static_cast< int >(val2);
25475 ecode3 = SWIG_AsVal_int(obj2, &val3);
25476 if (!SWIG_IsOK(ecode3)) {
25477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
25479 arg3 = static_cast< int >(val3);
25480 ecode4 = SWIG_AsVal_int(obj3, &val4);
25481 if (!SWIG_IsOK(ecode4)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
25484 arg4 = static_cast< int >(val4);
25485 result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
25486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25493 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495 Hex::Document *arg1 = (Hex::Document *) 0 ;
25496 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25497 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25498 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25506 Hex::Elements *result = 0 ;
25529 PyObject * obj0 = 0 ;
25530 PyObject * obj1 = 0 ;
25531 PyObject * obj2 = 0 ;
25532 PyObject * obj3 = 0 ;
25533 PyObject * obj4 = 0 ;
25534 PyObject * obj5 = 0 ;
25535 PyObject * obj6 = 0 ;
25536 PyObject * obj7 = 0 ;
25537 PyObject * obj8 = 0 ;
25538 PyObject * obj9 = 0 ;
25539 PyObject * obj10 = 0 ;
25541 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
25546 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25548 if (!SWIG_IsOK(res2)) {
25549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25551 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25552 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25553 if (!SWIG_IsOK(res3)) {
25554 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25556 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25557 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25558 if (!SWIG_IsOK(res4)) {
25559 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25561 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25562 ecode5 = SWIG_AsVal_double(obj4, &val5);
25563 if (!SWIG_IsOK(ecode5)) {
25564 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
25566 arg5 = static_cast< double >(val5);
25567 ecode6 = SWIG_AsVal_double(obj5, &val6);
25568 if (!SWIG_IsOK(ecode6)) {
25569 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
25571 arg6 = static_cast< double >(val6);
25572 ecode7 = SWIG_AsVal_double(obj6, &val7);
25573 if (!SWIG_IsOK(ecode7)) {
25574 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
25576 arg7 = static_cast< double >(val7);
25577 ecode8 = SWIG_AsVal_double(obj7, &val8);
25578 if (!SWIG_IsOK(ecode8)) {
25579 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
25581 arg8 = static_cast< double >(val8);
25582 ecode9 = SWIG_AsVal_int(obj8, &val9);
25583 if (!SWIG_IsOK(ecode9)) {
25584 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
25586 arg9 = static_cast< int >(val9);
25587 ecode10 = SWIG_AsVal_int(obj9, &val10);
25588 if (!SWIG_IsOK(ecode10)) {
25589 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
25591 arg10 = static_cast< int >(val10);
25592 ecode11 = SWIG_AsVal_int(obj10, &val11);
25593 if (!SWIG_IsOK(ecode11)) {
25594 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
25596 arg11 = static_cast< int >(val11);
25597 result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25605 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *resultobj = 0;
25607 Hex::Document *arg1 = (Hex::Document *) 0 ;
25608 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25609 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25610 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25611 Hex::RealVector arg5 ;
25612 Hex::RealVector arg6 ;
25613 Hex::RealVector arg7 ;
25614 Hex::Elements *result = 0 ;
25623 PyObject * obj0 = 0 ;
25624 PyObject * obj1 = 0 ;
25625 PyObject * obj2 = 0 ;
25626 PyObject * obj3 = 0 ;
25627 PyObject * obj4 = 0 ;
25628 PyObject * obj5 = 0 ;
25629 PyObject * obj6 = 0 ;
25631 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25633 if (!SWIG_IsOK(res1)) {
25634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
25636 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25638 if (!SWIG_IsOK(res2)) {
25639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
25641 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25642 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25643 if (!SWIG_IsOK(res3)) {
25644 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
25646 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25647 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25648 if (!SWIG_IsOK(res4)) {
25649 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
25651 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25653 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25654 int res = swig::asptr(obj4, &ptr);
25655 if (!SWIG_IsOK(res) || !ptr) {
25656 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
25659 if (SWIG_IsNewObj(res)) delete ptr;
25662 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25663 int res = swig::asptr(obj5, &ptr);
25664 if (!SWIG_IsOK(res) || !ptr) {
25665 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
25668 if (SWIG_IsNewObj(res)) delete ptr;
25671 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25672 int res = swig::asptr(obj6, &ptr);
25673 if (!SWIG_IsOK(res) || !ptr) {
25674 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
25677 if (SWIG_IsNewObj(res)) delete ptr;
25679 result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
25680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25687 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25688 PyObject *resultobj = 0;
25689 Hex::Document *arg1 = (Hex::Document *) 0 ;
25693 Hex::Elements *result = 0 ;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 PyObject * obj2 = 0 ;
25705 PyObject * obj3 = 0 ;
25707 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25709 if (!SWIG_IsOK(res1)) {
25710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
25712 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25713 ecode2 = SWIG_AsVal_int(obj1, &val2);
25714 if (!SWIG_IsOK(ecode2)) {
25715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
25717 arg2 = static_cast< int >(val2);
25718 ecode3 = SWIG_AsVal_int(obj2, &val3);
25719 if (!SWIG_IsOK(ecode3)) {
25720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
25722 arg3 = static_cast< int >(val3);
25723 ecode4 = SWIG_AsVal_int(obj3, &val4);
25724 if (!SWIG_IsOK(ecode4)) {
25725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
25727 arg4 = static_cast< int >(val4);
25728 result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
25729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25736 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737 PyObject *resultobj = 0;
25738 Hex::Document *arg1 = (Hex::Document *) 0 ;
25739 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25740 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25741 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25749 Hex::Elements *result = 0 ;
25772 PyObject * obj0 = 0 ;
25773 PyObject * obj1 = 0 ;
25774 PyObject * obj2 = 0 ;
25775 PyObject * obj3 = 0 ;
25776 PyObject * obj4 = 0 ;
25777 PyObject * obj5 = 0 ;
25778 PyObject * obj6 = 0 ;
25779 PyObject * obj7 = 0 ;
25780 PyObject * obj8 = 0 ;
25781 PyObject * obj9 = 0 ;
25782 PyObject * obj10 = 0 ;
25784 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
25789 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25791 if (!SWIG_IsOK(res2)) {
25792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25794 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25795 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25796 if (!SWIG_IsOK(res3)) {
25797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25799 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25800 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25801 if (!SWIG_IsOK(res4)) {
25802 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25804 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25805 ecode5 = SWIG_AsVal_double(obj4, &val5);
25806 if (!SWIG_IsOK(ecode5)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
25809 arg5 = static_cast< double >(val5);
25810 ecode6 = SWIG_AsVal_double(obj5, &val6);
25811 if (!SWIG_IsOK(ecode6)) {
25812 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
25814 arg6 = static_cast< double >(val6);
25815 ecode7 = SWIG_AsVal_double(obj6, &val7);
25816 if (!SWIG_IsOK(ecode7)) {
25817 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
25819 arg7 = static_cast< double >(val7);
25820 ecode8 = SWIG_AsVal_double(obj7, &val8);
25821 if (!SWIG_IsOK(ecode8)) {
25822 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
25824 arg8 = static_cast< double >(val8);
25825 ecode9 = SWIG_AsVal_int(obj8, &val9);
25826 if (!SWIG_IsOK(ecode9)) {
25827 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
25829 arg9 = static_cast< int >(val9);
25830 ecode10 = SWIG_AsVal_int(obj9, &val10);
25831 if (!SWIG_IsOK(ecode10)) {
25832 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
25834 arg10 = static_cast< int >(val10);
25835 ecode11 = SWIG_AsVal_int(obj10, &val11);
25836 if (!SWIG_IsOK(ecode11)) {
25837 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
25839 arg11 = static_cast< int >(val11);
25840 result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25848 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25849 PyObject *resultobj = 0;
25850 Hex::Document *arg1 = (Hex::Document *) 0 ;
25851 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25852 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25853 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25854 Hex::RealVector arg5 ;
25855 Hex::RealVector arg6 ;
25856 Hex::RealVector arg7 ;
25857 Hex::Elements *result = 0 ;
25866 PyObject * obj0 = 0 ;
25867 PyObject * obj1 = 0 ;
25868 PyObject * obj2 = 0 ;
25869 PyObject * obj3 = 0 ;
25870 PyObject * obj4 = 0 ;
25871 PyObject * obj5 = 0 ;
25872 PyObject * obj6 = 0 ;
25874 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
25879 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25881 if (!SWIG_IsOK(res2)) {
25882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
25884 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25885 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25886 if (!SWIG_IsOK(res3)) {
25887 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
25889 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25890 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
25891 if (!SWIG_IsOK(res4)) {
25892 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
25894 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25896 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25897 int res = swig::asptr(obj4, &ptr);
25898 if (!SWIG_IsOK(res) || !ptr) {
25899 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
25902 if (SWIG_IsNewObj(res)) delete ptr;
25905 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25906 int res = swig::asptr(obj5, &ptr);
25907 if (!SWIG_IsOK(res) || !ptr) {
25908 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
25911 if (SWIG_IsNewObj(res)) delete ptr;
25914 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25915 int res = swig::asptr(obj6, &ptr);
25916 if (!SWIG_IsOK(res) || !ptr) {
25917 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
25920 if (SWIG_IsNewObj(res)) delete ptr;
25922 result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
25923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25930 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25931 PyObject *resultobj = 0;
25932 Hex::Document *arg1 = (Hex::Document *) 0 ;
25935 Hex::Elements *result = 0 ;
25942 PyObject * obj0 = 0 ;
25943 PyObject * obj1 = 0 ;
25944 PyObject * obj2 = 0 ;
25946 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
25947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25951 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25952 ecode2 = SWIG_AsVal_int(obj1, &val2);
25953 if (!SWIG_IsOK(ecode2)) {
25954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25956 arg2 = static_cast< int >(val2);
25957 ecode3 = SWIG_AsVal_int(obj2, &val3);
25958 if (!SWIG_IsOK(ecode3)) {
25959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
25961 arg3 = static_cast< int >(val3);
25962 result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
25963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
25970 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25971 PyObject *resultobj = 0;
25972 Hex::Document *arg1 = (Hex::Document *) 0 ;
25974 Hex::Elements *result = 0 ;
25979 PyObject * obj0 = 0 ;
25980 PyObject * obj1 = 0 ;
25982 if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
25983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25984 if (!SWIG_IsOK(res1)) {
25985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25987 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25988 ecode2 = SWIG_AsVal_int(obj1, &val2);
25989 if (!SWIG_IsOK(ecode2)) {
25990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25992 arg2 = static_cast< int >(val2);
25993 result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
25994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26001 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
26006 if (!PyTuple_Check(args)) SWIG_fail;
26007 argc = PyObject_Length(args);
26008 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26009 argv[ii] = PyTuple_GET_ITEM(args,ii);
26014 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26015 _v = SWIG_CheckState(res);
26018 int res = SWIG_AsVal_int(argv[1], NULL);
26019 _v = SWIG_CheckState(res);
26022 return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
26029 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26030 _v = SWIG_CheckState(res);
26033 int res = SWIG_AsVal_int(argv[1], NULL);
26034 _v = SWIG_CheckState(res);
26038 int res = SWIG_AsVal_int(argv[2], NULL);
26039 _v = SWIG_CheckState(res);
26042 return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
26049 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalTop'.\n Possible C/C++ prototypes are:\n makeSphericalTop(int,int)\n makeSphericalTop(int)\n");
26054 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26055 PyObject *resultobj = 0;
26056 Hex::Document *arg1 = (Hex::Document *) 0 ;
26057 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26058 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26059 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26063 Hex::Elements *result = 0 ;
26078 PyObject * obj0 = 0 ;
26079 PyObject * obj1 = 0 ;
26080 PyObject * obj2 = 0 ;
26081 PyObject * obj3 = 0 ;
26082 PyObject * obj4 = 0 ;
26083 PyObject * obj5 = 0 ;
26084 PyObject * obj6 = 0 ;
26086 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26091 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26093 if (!SWIG_IsOK(res2)) {
26094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26096 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26097 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26098 if (!SWIG_IsOK(res3)) {
26099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26101 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26102 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26103 if (!SWIG_IsOK(res4)) {
26104 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26106 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26107 ecode5 = SWIG_AsVal_double(obj4, &val5);
26108 if (!SWIG_IsOK(ecode5)) {
26109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26111 arg5 = static_cast< double >(val5);
26112 ecode6 = SWIG_AsVal_int(obj5, &val6);
26113 if (!SWIG_IsOK(ecode6)) {
26114 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26116 arg6 = static_cast< int >(val6);
26117 ecode7 = SWIG_AsVal_int(obj6, &val7);
26118 if (!SWIG_IsOK(ecode7)) {
26119 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
26121 arg7 = static_cast< int >(val7);
26122 result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
26123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26130 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 Hex::Document *arg1 = (Hex::Document *) 0 ;
26133 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26134 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26135 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26138 Hex::Elements *result = 0 ;
26151 PyObject * obj0 = 0 ;
26152 PyObject * obj1 = 0 ;
26153 PyObject * obj2 = 0 ;
26154 PyObject * obj3 = 0 ;
26155 PyObject * obj4 = 0 ;
26156 PyObject * obj5 = 0 ;
26158 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26160 if (!SWIG_IsOK(res1)) {
26161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26163 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26165 if (!SWIG_IsOK(res2)) {
26166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26168 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26169 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26170 if (!SWIG_IsOK(res3)) {
26171 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26173 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26174 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26175 if (!SWIG_IsOK(res4)) {
26176 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26178 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26179 ecode5 = SWIG_AsVal_double(obj4, &val5);
26180 if (!SWIG_IsOK(ecode5)) {
26181 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26183 arg5 = static_cast< double >(val5);
26184 ecode6 = SWIG_AsVal_int(obj5, &val6);
26185 if (!SWIG_IsOK(ecode6)) {
26186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26188 arg6 = static_cast< int >(val6);
26189 result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26197 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
26202 if (!PyTuple_Check(args)) SWIG_fail;
26203 argc = PyObject_Length(args);
26204 for (ii = 0; (ii < argc) && (ii < 7); ii++) {
26205 argv[ii] = PyTuple_GET_ITEM(args,ii);
26210 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26211 _v = SWIG_CheckState(res);
26214 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26215 _v = SWIG_CheckState(res);
26218 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26219 _v = SWIG_CheckState(res);
26222 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26223 _v = SWIG_CheckState(res);
26226 int res = SWIG_AsVal_double(argv[4], NULL);
26227 _v = SWIG_CheckState(res);
26231 int res = SWIG_AsVal_int(argv[5], NULL);
26232 _v = SWIG_CheckState(res);
26235 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
26246 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26247 _v = SWIG_CheckState(res);
26250 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26251 _v = SWIG_CheckState(res);
26254 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26255 _v = SWIG_CheckState(res);
26258 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26259 _v = SWIG_CheckState(res);
26262 int res = SWIG_AsVal_double(argv[4], NULL);
26263 _v = SWIG_CheckState(res);
26267 int res = SWIG_AsVal_int(argv[5], NULL);
26268 _v = SWIG_CheckState(res);
26272 int res = SWIG_AsVal_int(argv[6], NULL);
26273 _v = SWIG_CheckState(res);
26276 return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
26287 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalUni'.\n Possible C/C++ prototypes are:\n makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
26292 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293 PyObject *resultobj = 0;
26294 Hex::Document *arg1 = (Hex::Document *) 0 ;
26295 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26296 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26297 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26298 Hex::RealVector arg5 ;
26300 Hex::Elements *result = 0 ;
26311 PyObject * obj0 = 0 ;
26312 PyObject * obj1 = 0 ;
26313 PyObject * obj2 = 0 ;
26314 PyObject * obj3 = 0 ;
26315 PyObject * obj4 = 0 ;
26316 PyObject * obj5 = 0 ;
26318 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26320 if (!SWIG_IsOK(res1)) {
26321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26323 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26325 if (!SWIG_IsOK(res2)) {
26326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26328 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26329 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26330 if (!SWIG_IsOK(res3)) {
26331 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26333 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26334 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26335 if (!SWIG_IsOK(res4)) {
26336 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26338 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26340 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26341 int res = swig::asptr(obj4, &ptr);
26342 if (!SWIG_IsOK(res) || !ptr) {
26343 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26346 if (SWIG_IsNewObj(res)) delete ptr;
26348 ecode6 = SWIG_AsVal_int(obj5, &val6);
26349 if (!SWIG_IsOK(ecode6)) {
26350 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
26352 arg6 = static_cast< int >(val6);
26353 result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
26354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26361 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26362 PyObject *resultobj = 0;
26363 Hex::Document *arg1 = (Hex::Document *) 0 ;
26364 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26365 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26366 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26367 Hex::RealVector arg5 ;
26368 Hex::Elements *result = 0 ;
26377 PyObject * obj0 = 0 ;
26378 PyObject * obj1 = 0 ;
26379 PyObject * obj2 = 0 ;
26380 PyObject * obj3 = 0 ;
26381 PyObject * obj4 = 0 ;
26383 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26385 if (!SWIG_IsOK(res1)) {
26386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26388 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26390 if (!SWIG_IsOK(res2)) {
26391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26393 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26394 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26395 if (!SWIG_IsOK(res3)) {
26396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26398 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26399 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26400 if (!SWIG_IsOK(res4)) {
26401 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26403 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26405 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26406 int res = swig::asptr(obj4, &ptr);
26407 if (!SWIG_IsOK(res) || !ptr) {
26408 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26411 if (SWIG_IsNewObj(res)) delete ptr;
26413 result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
26414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26421 SWIGINTERN PyObject *_wrap_Document_makeSpherical(PyObject *self, PyObject *args) {
26426 if (!PyTuple_Check(args)) SWIG_fail;
26427 argc = PyObject_Length(args);
26428 for (ii = 0; (ii < argc) && (ii < 6); ii++) {
26429 argv[ii] = PyTuple_GET_ITEM(args,ii);
26434 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26435 _v = SWIG_CheckState(res);
26438 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26439 _v = SWIG_CheckState(res);
26442 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26443 _v = SWIG_CheckState(res);
26446 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26447 _v = SWIG_CheckState(res);
26449 int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26450 _v = SWIG_CheckState(res);
26452 return _wrap_Document_makeSpherical__SWIG_1(self, args);
26462 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26463 _v = SWIG_CheckState(res);
26466 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26467 _v = SWIG_CheckState(res);
26470 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26471 _v = SWIG_CheckState(res);
26474 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26475 _v = SWIG_CheckState(res);
26477 int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26478 _v = SWIG_CheckState(res);
26481 int res = SWIG_AsVal_int(argv[5], NULL);
26482 _v = SWIG_CheckState(res);
26485 return _wrap_Document_makeSpherical__SWIG_0(self, args);
26495 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSpherical'.\n Possible C/C++ prototypes are:\n makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
26500 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26501 PyObject *resultobj = 0;
26502 Hex::Document *arg1 = (Hex::Document *) 0 ;
26506 Hex::Elements *result = 0 ;
26515 PyObject * obj0 = 0 ;
26516 PyObject * obj1 = 0 ;
26517 PyObject * obj2 = 0 ;
26518 PyObject * obj3 = 0 ;
26520 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26522 if (!SWIG_IsOK(res1)) {
26523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
26525 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26526 ecode2 = SWIG_AsVal_int(obj1, &val2);
26527 if (!SWIG_IsOK(ecode2)) {
26528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
26530 arg2 = static_cast< int >(val2);
26531 ecode3 = SWIG_AsVal_int(obj2, &val3);
26532 if (!SWIG_IsOK(ecode3)) {
26533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
26535 arg3 = static_cast< int >(val3);
26536 ecode4 = SWIG_AsVal_int(obj3, &val4);
26537 if (!SWIG_IsOK(ecode4)) {
26538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
26540 arg4 = static_cast< int >(val4);
26541 result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
26542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26549 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *resultobj = 0;
26551 Hex::Document *arg1 = (Hex::Document *) 0 ;
26552 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26553 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26554 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26558 Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
26562 Hex::Elements *result = 0 ;
26585 PyObject * obj0 = 0 ;
26586 PyObject * obj1 = 0 ;
26587 PyObject * obj2 = 0 ;
26588 PyObject * obj3 = 0 ;
26589 PyObject * obj4 = 0 ;
26590 PyObject * obj5 = 0 ;
26591 PyObject * obj6 = 0 ;
26592 PyObject * obj7 = 0 ;
26593 PyObject * obj8 = 0 ;
26594 PyObject * obj9 = 0 ;
26595 PyObject * obj10 = 0 ;
26597 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26599 if (!SWIG_IsOK(res1)) {
26600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
26602 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26604 if (!SWIG_IsOK(res2)) {
26605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26607 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26608 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26609 if (!SWIG_IsOK(res3)) {
26610 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26612 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26613 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26614 if (!SWIG_IsOK(res4)) {
26615 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26617 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26618 ecode5 = SWIG_AsVal_double(obj4, &val5);
26619 if (!SWIG_IsOK(ecode5)) {
26620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
26622 arg5 = static_cast< double >(val5);
26623 ecode6 = SWIG_AsVal_double(obj5, &val6);
26624 if (!SWIG_IsOK(ecode6)) {
26625 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
26627 arg6 = static_cast< double >(val6);
26628 ecode7 = SWIG_AsVal_double(obj6, &val7);
26629 if (!SWIG_IsOK(ecode7)) {
26630 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
26632 arg7 = static_cast< double >(val7);
26633 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26634 if (!SWIG_IsOK(res8)) {
26635 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
26637 arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
26638 ecode9 = SWIG_AsVal_int(obj8, &val9);
26639 if (!SWIG_IsOK(ecode9)) {
26640 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
26642 arg9 = static_cast< int >(val9);
26643 ecode10 = SWIG_AsVal_int(obj9, &val10);
26644 if (!SWIG_IsOK(ecode10)) {
26645 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
26647 arg10 = static_cast< int >(val10);
26648 ecode11 = SWIG_AsVal_int(obj10, &val11);
26649 if (!SWIG_IsOK(ecode11)) {
26650 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
26652 arg11 = static_cast< int >(val11);
26653 result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26661 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26662 PyObject *resultobj = 0;
26663 Hex::Document *arg1 = (Hex::Document *) 0 ;
26664 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26665 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26666 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26667 Hex::RealVector arg5 ;
26668 Hex::RealVector arg6 ;
26669 Hex::RealVector arg7 ;
26670 Hex::Elements *result = 0 ;
26679 PyObject * obj0 = 0 ;
26680 PyObject * obj1 = 0 ;
26681 PyObject * obj2 = 0 ;
26682 PyObject * obj3 = 0 ;
26683 PyObject * obj4 = 0 ;
26684 PyObject * obj5 = 0 ;
26685 PyObject * obj6 = 0 ;
26687 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26689 if (!SWIG_IsOK(res1)) {
26690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
26692 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26694 if (!SWIG_IsOK(res2)) {
26695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
26697 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26698 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26699 if (!SWIG_IsOK(res3)) {
26700 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
26702 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26703 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26704 if (!SWIG_IsOK(res4)) {
26705 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
26707 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26709 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26710 int res = swig::asptr(obj4, &ptr);
26711 if (!SWIG_IsOK(res) || !ptr) {
26712 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
26715 if (SWIG_IsNewObj(res)) delete ptr;
26718 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26719 int res = swig::asptr(obj5, &ptr);
26720 if (!SWIG_IsOK(res) || !ptr) {
26721 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
26724 if (SWIG_IsNewObj(res)) delete ptr;
26727 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26728 int res = swig::asptr(obj6, &ptr);
26729 if (!SWIG_IsOK(res) || !ptr) {
26730 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
26733 if (SWIG_IsNewObj(res)) delete ptr;
26735 result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
26736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26743 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *resultobj = 0;
26745 Hex::Document *arg1 = (Hex::Document *) 0 ;
26749 Hex::Elements *result = 0 ;
26758 PyObject * obj0 = 0 ;
26759 PyObject * obj1 = 0 ;
26760 PyObject * obj2 = 0 ;
26761 PyObject * obj3 = 0 ;
26763 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26765 if (!SWIG_IsOK(res1)) {
26766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
26768 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26769 ecode2 = SWIG_AsVal_int(obj1, &val2);
26770 if (!SWIG_IsOK(ecode2)) {
26771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
26773 arg2 = static_cast< int >(val2);
26774 ecode3 = SWIG_AsVal_int(obj2, &val3);
26775 if (!SWIG_IsOK(ecode3)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
26778 arg3 = static_cast< int >(val3);
26779 ecode4 = SWIG_AsVal_int(obj3, &val4);
26780 if (!SWIG_IsOK(ecode4)) {
26781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
26783 arg4 = static_cast< int >(val4);
26784 result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
26785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26792 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26793 PyObject *resultobj = 0;
26794 Hex::Document *arg1 = (Hex::Document *) 0 ;
26795 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26796 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26797 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26802 Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
26806 Hex::Elements *result = 0 ;
26831 PyObject * obj0 = 0 ;
26832 PyObject * obj1 = 0 ;
26833 PyObject * obj2 = 0 ;
26834 PyObject * obj3 = 0 ;
26835 PyObject * obj4 = 0 ;
26836 PyObject * obj5 = 0 ;
26837 PyObject * obj6 = 0 ;
26838 PyObject * obj7 = 0 ;
26839 PyObject * obj8 = 0 ;
26840 PyObject * obj9 = 0 ;
26841 PyObject * obj10 = 0 ;
26842 PyObject * obj11 = 0 ;
26844 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
26845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26846 if (!SWIG_IsOK(res1)) {
26847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
26849 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26851 if (!SWIG_IsOK(res2)) {
26852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26854 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26855 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26856 if (!SWIG_IsOK(res3)) {
26857 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26859 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26860 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26861 if (!SWIG_IsOK(res4)) {
26862 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26864 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26865 ecode5 = SWIG_AsVal_double(obj4, &val5);
26866 if (!SWIG_IsOK(ecode5)) {
26867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
26869 arg5 = static_cast< double >(val5);
26870 ecode6 = SWIG_AsVal_double(obj5, &val6);
26871 if (!SWIG_IsOK(ecode6)) {
26872 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
26874 arg6 = static_cast< double >(val6);
26875 ecode7 = SWIG_AsVal_double(obj6, &val7);
26876 if (!SWIG_IsOK(ecode7)) {
26877 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
26879 arg7 = static_cast< double >(val7);
26880 ecode8 = SWIG_AsVal_double(obj7, &val8);
26881 if (!SWIG_IsOK(ecode8)) {
26882 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
26884 arg8 = static_cast< double >(val8);
26885 res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26886 if (!SWIG_IsOK(res9)) {
26887 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
26889 arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
26890 ecode10 = SWIG_AsVal_int(obj9, &val10);
26891 if (!SWIG_IsOK(ecode10)) {
26892 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
26894 arg10 = static_cast< int >(val10);
26895 ecode11 = SWIG_AsVal_int(obj10, &val11);
26896 if (!SWIG_IsOK(ecode11)) {
26897 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
26899 arg11 = static_cast< int >(val11);
26900 ecode12 = SWIG_AsVal_int(obj11, &val12);
26901 if (!SWIG_IsOK(ecode12)) {
26902 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
26904 arg12 = static_cast< int >(val12);
26905 result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26913 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26914 PyObject *resultobj = 0;
26915 Hex::Document *arg1 = (Hex::Document *) 0 ;
26916 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26917 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26918 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26919 Hex::RealVector arg5 ;
26920 Hex::RealVector arg6 ;
26921 Hex::RealVector arg7 ;
26922 Hex::Elements *result = 0 ;
26931 PyObject * obj0 = 0 ;
26932 PyObject * obj1 = 0 ;
26933 PyObject * obj2 = 0 ;
26934 PyObject * obj3 = 0 ;
26935 PyObject * obj4 = 0 ;
26936 PyObject * obj5 = 0 ;
26937 PyObject * obj6 = 0 ;
26939 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26941 if (!SWIG_IsOK(res1)) {
26942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
26944 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26946 if (!SWIG_IsOK(res2)) {
26947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
26949 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26950 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26951 if (!SWIG_IsOK(res3)) {
26952 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
26954 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26955 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26956 if (!SWIG_IsOK(res4)) {
26957 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
26959 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26961 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26962 int res = swig::asptr(obj4, &ptr);
26963 if (!SWIG_IsOK(res) || !ptr) {
26964 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
26967 if (SWIG_IsNewObj(res)) delete ptr;
26970 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26971 int res = swig::asptr(obj5, &ptr);
26972 if (!SWIG_IsOK(res) || !ptr) {
26973 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
26976 if (SWIG_IsNewObj(res)) delete ptr;
26979 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26980 int res = swig::asptr(obj6, &ptr);
26981 if (!SWIG_IsOK(res) || !ptr) {
26982 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
26985 if (SWIG_IsNewObj(res)) delete ptr;
26987 result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
26988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26995 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26996 PyObject *resultobj = 0;
26997 Hex::Document *arg1 = (Hex::Document *) 0 ;
26998 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26999 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27002 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27003 Hex::Vector *arg7 = (Hex::Vector *) 0 ;
27006 Hex::BiCylinder *result = 0 ;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 PyObject * obj2 = 0 ;
27028 PyObject * obj3 = 0 ;
27029 PyObject * obj4 = 0 ;
27030 PyObject * obj5 = 0 ;
27031 PyObject * obj6 = 0 ;
27032 PyObject * obj7 = 0 ;
27033 PyObject * obj8 = 0 ;
27035 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
27036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27037 if (!SWIG_IsOK(res1)) {
27038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
27040 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27042 if (!SWIG_IsOK(res2)) {
27043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
27045 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27046 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27047 if (!SWIG_IsOK(res3)) {
27048 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
27050 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27051 ecode4 = SWIG_AsVal_double(obj3, &val4);
27052 if (!SWIG_IsOK(ecode4)) {
27053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
27055 arg4 = static_cast< double >(val4);
27056 ecode5 = SWIG_AsVal_double(obj4, &val5);
27057 if (!SWIG_IsOK(ecode5)) {
27058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
27060 arg5 = static_cast< double >(val5);
27061 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27062 if (!SWIG_IsOK(res6)) {
27063 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
27065 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27066 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27067 if (!SWIG_IsOK(res7)) {
27068 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
27070 arg7 = reinterpret_cast< Hex::Vector * >(argp7);
27071 ecode8 = SWIG_AsVal_double(obj7, &val8);
27072 if (!SWIG_IsOK(ecode8)) {
27073 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
27075 arg8 = static_cast< double >(val8);
27076 ecode9 = SWIG_AsVal_double(obj8, &val9);
27077 if (!SWIG_IsOK(ecode9)) {
27078 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
27080 arg9 = static_cast< double >(val9);
27081 result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
27082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
27089 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 PyObject *resultobj = 0;
27091 Hex::Document *arg1 = (Hex::Document *) 0 ;
27092 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27093 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27097 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27098 Hex::Vector *arg8 = (Hex::Vector *) 0 ;
27102 Hex::BiCylinder *result = 0 ;
27125 PyObject * obj0 = 0 ;
27126 PyObject * obj1 = 0 ;
27127 PyObject * obj2 = 0 ;
27128 PyObject * obj3 = 0 ;
27129 PyObject * obj4 = 0 ;
27130 PyObject * obj5 = 0 ;
27131 PyObject * obj6 = 0 ;
27132 PyObject * obj7 = 0 ;
27133 PyObject * obj8 = 0 ;
27134 PyObject * obj9 = 0 ;
27135 PyObject * obj10 = 0 ;
27137 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
27138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27139 if (!SWIG_IsOK(res1)) {
27140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
27142 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27144 if (!SWIG_IsOK(res2)) {
27145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
27147 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27148 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27149 if (!SWIG_IsOK(res3)) {
27150 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
27152 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27153 ecode4 = SWIG_AsVal_double(obj3, &val4);
27154 if (!SWIG_IsOK(ecode4)) {
27155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
27157 arg4 = static_cast< double >(val4);
27158 ecode5 = SWIG_AsVal_double(obj4, &val5);
27159 if (!SWIG_IsOK(ecode5)) {
27160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
27162 arg5 = static_cast< double >(val5);
27163 ecode6 = SWIG_AsVal_double(obj5, &val6);
27164 if (!SWIG_IsOK(ecode6)) {
27165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
27167 arg6 = static_cast< double >(val6);
27168 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27169 if (!SWIG_IsOK(res7)) {
27170 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
27172 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27173 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27174 if (!SWIG_IsOK(res8)) {
27175 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
27177 arg8 = reinterpret_cast< Hex::Vector * >(argp8);
27178 ecode9 = SWIG_AsVal_double(obj8, &val9);
27179 if (!SWIG_IsOK(ecode9)) {
27180 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
27182 arg9 = static_cast< double >(val9);
27183 ecode10 = SWIG_AsVal_double(obj9, &val10);
27184 if (!SWIG_IsOK(ecode10)) {
27185 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
27187 arg10 = static_cast< double >(val10);
27188 ecode11 = SWIG_AsVal_double(obj10, &val11);
27189 if (!SWIG_IsOK(ecode11)) {
27190 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
27192 arg11 = static_cast< double >(val11);
27193 result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
27194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
27201 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27202 PyObject *resultobj = 0;
27203 Hex::Document *arg1 = (Hex::Document *) 0 ;
27204 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27206 Hex::Elements *result = 0 ;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 PyObject * obj2 = 0 ;
27217 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
27218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27219 if (!SWIG_IsOK(res1)) {
27220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
27222 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27224 if (!SWIG_IsOK(res2)) {
27225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
27227 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27228 ecode3 = SWIG_AsVal_int(obj2, &val3);
27229 if (!SWIG_IsOK(ecode3)) {
27230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
27232 arg3 = static_cast< int >(val3);
27233 result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
27234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27241 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27242 PyObject *resultobj = 0;
27243 Hex::Document *arg1 = (Hex::Document *) 0 ;
27244 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27245 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27248 Hex::Elements *result = 0 ;
27259 PyObject * obj0 = 0 ;
27260 PyObject * obj1 = 0 ;
27261 PyObject * obj2 = 0 ;
27262 PyObject * obj3 = 0 ;
27263 PyObject * obj4 = 0 ;
27265 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27267 if (!SWIG_IsOK(res1)) {
27268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27270 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27272 if (!SWIG_IsOK(res2)) {
27273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27275 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27276 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27277 if (!SWIG_IsOK(res3)) {
27278 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27280 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27281 ecode4 = SWIG_AsVal_double(obj3, &val4);
27282 if (!SWIG_IsOK(ecode4)) {
27283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
27285 arg4 = static_cast< double >(val4);
27286 ecode5 = SWIG_AsVal_int(obj4, &val5);
27287 if (!SWIG_IsOK(ecode5)) {
27288 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
27290 arg5 = static_cast< int >(val5);
27291 result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
27292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27299 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27300 PyObject *resultobj = 0;
27301 Hex::Document *arg1 = (Hex::Document *) 0 ;
27302 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27303 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27304 Hex::RealVector arg4 ;
27305 Hex::Elements *result = 0 ;
27312 PyObject * obj0 = 0 ;
27313 PyObject * obj1 = 0 ;
27314 PyObject * obj2 = 0 ;
27315 PyObject * obj3 = 0 ;
27317 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27319 if (!SWIG_IsOK(res1)) {
27320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27322 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27324 if (!SWIG_IsOK(res2)) {
27325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27327 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27328 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27329 if (!SWIG_IsOK(res3)) {
27330 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
27332 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27334 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27335 int res = swig::asptr(obj3, &ptr);
27336 if (!SWIG_IsOK(res) || !ptr) {
27337 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
27340 if (SWIG_IsNewObj(res)) delete ptr;
27342 result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
27343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27350 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 PyObject *resultobj = 0;
27352 Hex::Document *arg1 = (Hex::Document *) 0 ;
27355 Hex::Elements *result = 0 ;
27360 PyObject * obj0 = 0 ;
27361 PyObject * obj1 = 0 ;
27362 PyObject * obj2 = 0 ;
27364 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
27365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
27369 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27371 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27372 int res = swig::asptr(obj1, &ptr);
27373 if (!SWIG_IsOK(res) || !ptr) {
27374 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
27377 if (SWIG_IsNewObj(res)) delete ptr;
27379 ecode3 = SWIG_AsVal_int(obj2, &val3);
27380 if (!SWIG_IsOK(ecode3)) {
27381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
27383 arg3 = static_cast< int >(val3);
27384 result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
27385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27392 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27393 PyObject *resultobj = 0;
27394 Hex::Document *arg1 = (Hex::Document *) 0 ;
27396 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27399 Hex::Elements *result = 0 ;
27408 PyObject * obj0 = 0 ;
27409 PyObject * obj1 = 0 ;
27410 PyObject * obj2 = 0 ;
27411 PyObject * obj3 = 0 ;
27412 PyObject * obj4 = 0 ;
27414 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27416 if (!SWIG_IsOK(res1)) {
27417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27419 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27421 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27422 int res = swig::asptr(obj1, &ptr);
27423 if (!SWIG_IsOK(res) || !ptr) {
27424 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27427 if (SWIG_IsNewObj(res)) delete ptr;
27429 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27430 if (!SWIG_IsOK(res3)) {
27431 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27433 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27434 ecode4 = SWIG_AsVal_double(obj3, &val4);
27435 if (!SWIG_IsOK(ecode4)) {
27436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
27438 arg4 = static_cast< double >(val4);
27439 ecode5 = SWIG_AsVal_int(obj4, &val5);
27440 if (!SWIG_IsOK(ecode5)) {
27441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
27443 arg5 = static_cast< int >(val5);
27444 result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
27445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27452 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27453 PyObject *resultobj = 0;
27454 Hex::Document *arg1 = (Hex::Document *) 0 ;
27456 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27457 Hex::RealVector arg4 ;
27458 Hex::Elements *result = 0 ;
27463 PyObject * obj0 = 0 ;
27464 PyObject * obj1 = 0 ;
27465 PyObject * obj2 = 0 ;
27466 PyObject * obj3 = 0 ;
27468 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27470 if (!SWIG_IsOK(res1)) {
27471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27473 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27475 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27476 int res = swig::asptr(obj1, &ptr);
27477 if (!SWIG_IsOK(res) || !ptr) {
27478 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27481 if (SWIG_IsNewObj(res)) delete ptr;
27483 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27484 if (!SWIG_IsOK(res3)) {
27485 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
27487 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27489 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27490 int res = swig::asptr(obj3, &ptr);
27491 if (!SWIG_IsOK(res) || !ptr) {
27492 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
27495 if (SWIG_IsNewObj(res)) delete ptr;
27497 result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
27498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27505 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506 PyObject *resultobj = 0;
27507 Hex::Document *arg1 = (Hex::Document *) 0 ;
27508 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27509 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27510 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27513 Hex::Elements *result = 0 ;
27526 PyObject * obj0 = 0 ;
27527 PyObject * obj1 = 0 ;
27528 PyObject * obj2 = 0 ;
27529 PyObject * obj3 = 0 ;
27530 PyObject * obj4 = 0 ;
27531 PyObject * obj5 = 0 ;
27533 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27535 if (!SWIG_IsOK(res1)) {
27536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27538 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27540 if (!SWIG_IsOK(res2)) {
27541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27543 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27544 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27545 if (!SWIG_IsOK(res3)) {
27546 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27548 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27549 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27550 if (!SWIG_IsOK(res4)) {
27551 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27553 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27554 ecode5 = SWIG_AsVal_double(obj4, &val5);
27555 if (!SWIG_IsOK(ecode5)) {
27556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
27558 arg5 = static_cast< double >(val5);
27559 ecode6 = SWIG_AsVal_int(obj5, &val6);
27560 if (!SWIG_IsOK(ecode6)) {
27561 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
27563 arg6 = static_cast< int >(val6);
27564 result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
27565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27572 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 Hex::Document *arg1 = (Hex::Document *) 0 ;
27575 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27576 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27577 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27578 Hex::RealVector arg5 ;
27579 Hex::Elements *result = 0 ;
27588 PyObject * obj0 = 0 ;
27589 PyObject * obj1 = 0 ;
27590 PyObject * obj2 = 0 ;
27591 PyObject * obj3 = 0 ;
27592 PyObject * obj4 = 0 ;
27594 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27596 if (!SWIG_IsOK(res1)) {
27597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27599 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27601 if (!SWIG_IsOK(res2)) {
27602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27604 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27605 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27606 if (!SWIG_IsOK(res3)) {
27607 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
27609 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27610 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27611 if (!SWIG_IsOK(res4)) {
27612 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
27614 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27616 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27617 int res = swig::asptr(obj4, &ptr);
27618 if (!SWIG_IsOK(res) || !ptr) {
27619 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
27622 if (SWIG_IsNewObj(res)) delete ptr;
27624 result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
27625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27632 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633 PyObject *resultobj = 0;
27634 Hex::Document *arg1 = (Hex::Document *) 0 ;
27636 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27637 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27640 Hex::Elements *result = 0 ;
27651 PyObject * obj0 = 0 ;
27652 PyObject * obj1 = 0 ;
27653 PyObject * obj2 = 0 ;
27654 PyObject * obj3 = 0 ;
27655 PyObject * obj4 = 0 ;
27656 PyObject * obj5 = 0 ;
27658 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27660 if (!SWIG_IsOK(res1)) {
27661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27663 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27665 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27666 int res = swig::asptr(obj1, &ptr);
27667 if (!SWIG_IsOK(res) || !ptr) {
27668 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27671 if (SWIG_IsNewObj(res)) delete ptr;
27673 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27674 if (!SWIG_IsOK(res3)) {
27675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27677 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27678 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27679 if (!SWIG_IsOK(res4)) {
27680 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27682 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27683 ecode5 = SWIG_AsVal_double(obj4, &val5);
27684 if (!SWIG_IsOK(ecode5)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
27687 arg5 = static_cast< double >(val5);
27688 ecode6 = SWIG_AsVal_int(obj5, &val6);
27689 if (!SWIG_IsOK(ecode6)) {
27690 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
27692 arg6 = static_cast< int >(val6);
27693 result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
27694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27701 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 Hex::Document *arg1 = (Hex::Document *) 0 ;
27705 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27706 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27707 Hex::RealVector arg5 ;
27708 Hex::Elements *result = 0 ;
27715 PyObject * obj0 = 0 ;
27716 PyObject * obj1 = 0 ;
27717 PyObject * obj2 = 0 ;
27718 PyObject * obj3 = 0 ;
27719 PyObject * obj4 = 0 ;
27721 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27723 if (!SWIG_IsOK(res1)) {
27724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27726 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27728 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27729 int res = swig::asptr(obj1, &ptr);
27730 if (!SWIG_IsOK(res) || !ptr) {
27731 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27734 if (SWIG_IsNewObj(res)) delete ptr;
27736 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27737 if (!SWIG_IsOK(res3)) {
27738 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
27740 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27741 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
27742 if (!SWIG_IsOK(res4)) {
27743 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
27745 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27747 std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27748 int res = swig::asptr(obj4, &ptr);
27749 if (!SWIG_IsOK(res) || !ptr) {
27750 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
27753 if (SWIG_IsNewObj(res)) delete ptr;
27755 result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
27756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27763 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764 PyObject *resultobj = 0;
27765 Hex::Document *arg1 = (Hex::Document *) 0 ;
27766 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27767 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27768 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27769 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27770 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27771 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27773 Hex::Elements *result = 0 ;
27790 PyObject * obj0 = 0 ;
27791 PyObject * obj1 = 0 ;
27792 PyObject * obj2 = 0 ;
27793 PyObject * obj3 = 0 ;
27794 PyObject * obj4 = 0 ;
27795 PyObject * obj5 = 0 ;
27796 PyObject * obj6 = 0 ;
27797 PyObject * obj7 = 0 ;
27799 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27801 if (!SWIG_IsOK(res1)) {
27802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27804 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27806 if (!SWIG_IsOK(res2)) {
27807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27809 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27810 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27811 if (!SWIG_IsOK(res3)) {
27812 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27814 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27816 if (!SWIG_IsOK(res4)) {
27817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27819 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27820 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27821 if (!SWIG_IsOK(res5)) {
27822 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27824 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27825 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27826 if (!SWIG_IsOK(res6)) {
27827 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27829 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27830 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27831 if (!SWIG_IsOK(res7)) {
27832 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27834 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27835 ecode8 = SWIG_AsVal_int(obj7, &val8);
27836 if (!SWIG_IsOK(ecode8)) {
27837 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
27839 arg8 = static_cast< int >(val8);
27840 result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27848 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27849 PyObject *resultobj = 0;
27850 Hex::Document *arg1 = (Hex::Document *) 0 ;
27852 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27853 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27854 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27855 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27856 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27858 Hex::Elements *result = 0 ;
27873 PyObject * obj0 = 0 ;
27874 PyObject * obj1 = 0 ;
27875 PyObject * obj2 = 0 ;
27876 PyObject * obj3 = 0 ;
27877 PyObject * obj4 = 0 ;
27878 PyObject * obj5 = 0 ;
27879 PyObject * obj6 = 0 ;
27880 PyObject * obj7 = 0 ;
27882 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27887 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27889 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27890 int res = swig::asptr(obj1, &ptr);
27891 if (!SWIG_IsOK(res) || !ptr) {
27892 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27895 if (SWIG_IsNewObj(res)) delete ptr;
27897 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27898 if (!SWIG_IsOK(res3)) {
27899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27901 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27902 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27903 if (!SWIG_IsOK(res4)) {
27904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27906 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27907 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27908 if (!SWIG_IsOK(res5)) {
27909 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27911 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27912 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27913 if (!SWIG_IsOK(res6)) {
27914 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27916 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27917 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27918 if (!SWIG_IsOK(res7)) {
27919 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27921 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27922 ecode8 = SWIG_AsVal_int(obj7, &val8);
27923 if (!SWIG_IsOK(ecode8)) {
27924 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
27926 arg8 = static_cast< int >(val8);
27927 result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
27935 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27936 PyObject *resultobj = 0;
27937 Hex::Document *arg1 = (Hex::Document *) 0 ;
27938 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27939 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27940 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27941 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27942 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27943 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27944 Hex::RealVector *arg8 = 0 ;
27945 Hex::Elements *result = 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 PyObject * obj2 = 0 ;
27965 PyObject * obj3 = 0 ;
27966 PyObject * obj4 = 0 ;
27967 PyObject * obj5 = 0 ;
27968 PyObject * obj6 = 0 ;
27969 PyObject * obj7 = 0 ;
27971 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27973 if (!SWIG_IsOK(res1)) {
27974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27976 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27978 if (!SWIG_IsOK(res2)) {
27979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27981 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27982 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27983 if (!SWIG_IsOK(res3)) {
27984 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
27986 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27987 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27988 if (!SWIG_IsOK(res4)) {
27989 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
27991 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27992 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27993 if (!SWIG_IsOK(res5)) {
27994 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
27996 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27997 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27998 if (!SWIG_IsOK(res6)) {
27999 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
28001 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28002 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28003 if (!SWIG_IsOK(res7)) {
28004 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
28006 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28007 res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
28008 if (!SWIG_IsOK(res8)) {
28009 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
28012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
28014 arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
28015 result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
28016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28023 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 Hex::Document *arg1 = (Hex::Document *) 0 ;
28027 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28028 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
28029 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
28030 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28031 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28032 Hex::RealVector *arg8 = 0 ;
28033 Hex::Elements *result = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 PyObject * obj2 = 0 ;
28051 PyObject * obj3 = 0 ;
28052 PyObject * obj4 = 0 ;
28053 PyObject * obj5 = 0 ;
28054 PyObject * obj6 = 0 ;
28055 PyObject * obj7 = 0 ;
28057 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28059 if (!SWIG_IsOK(res1)) {
28060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28062 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28064 std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
28065 int res = swig::asptr(obj1, &ptr);
28066 if (!SWIG_IsOK(res) || !ptr) {
28067 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
28070 if (SWIG_IsNewObj(res)) delete ptr;
28072 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
28073 if (!SWIG_IsOK(res3)) {
28074 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28076 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28077 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28078 if (!SWIG_IsOK(res4)) {
28079 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
28081 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
28082 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28083 if (!SWIG_IsOK(res5)) {
28084 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
28086 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
28087 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28088 if (!SWIG_IsOK(res6)) {
28089 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
28091 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28092 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28093 if (!SWIG_IsOK(res7)) {
28094 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
28096 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28097 res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
28098 if (!SWIG_IsOK(res8)) {
28099 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28104 arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
28105 result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
28106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28113 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28114 PyObject *resultobj = 0;
28115 Hex::Document *arg1 = (Hex::Document *) 0 ;
28116 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28118 Hex::Elements *result = 0 ;
28125 PyObject * obj0 = 0 ;
28126 PyObject * obj1 = 0 ;
28127 PyObject * obj2 = 0 ;
28129 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
28130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28131 if (!SWIG_IsOK(res1)) {
28132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
28134 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28136 if (!SWIG_IsOK(res2)) {
28137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
28139 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28140 ecode3 = SWIG_AsVal_int(obj2, &val3);
28141 if (!SWIG_IsOK(ecode3)) {
28142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
28144 arg3 = static_cast< int >(val3);
28145 result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
28146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28153 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 PyObject *resultobj = 0;
28155 Hex::Document *arg1 = (Hex::Document *) 0 ;
28156 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28157 Hex::RealVector *arg3 = 0 ;
28158 Hex::Elements *result = 0 ;
28165 PyObject * obj0 = 0 ;
28166 PyObject * obj1 = 0 ;
28167 PyObject * obj2 = 0 ;
28169 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
28170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28171 if (!SWIG_IsOK(res1)) {
28172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
28174 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28176 if (!SWIG_IsOK(res2)) {
28177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
28179 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28180 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
28181 if (!SWIG_IsOK(res3)) {
28182 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28185 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28187 arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
28188 result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
28189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28196 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28197 PyObject *resultobj = 0;
28198 Hex::Document *arg1 = (Hex::Document *) 0 ;
28199 cpchar arg2 = (cpchar) 0 ;
28200 Hex::EnumGroup arg3 ;
28201 Hex::Group *result = 0 ;
28209 PyObject * obj0 = 0 ;
28210 PyObject * obj1 = 0 ;
28211 PyObject * obj2 = 0 ;
28213 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
28214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28215 if (!SWIG_IsOK(res1)) {
28216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28218 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28219 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28220 if (!SWIG_IsOK(res2)) {
28221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
28223 arg2 = reinterpret_cast< cpchar >(buf2);
28224 ecode3 = SWIG_AsVal_int(obj2, &val3);
28225 if (!SWIG_IsOK(ecode3)) {
28226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
28228 arg3 = static_cast< Hex::EnumGroup >(val3);
28229 result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
28230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
28231 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28234 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28239 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28240 PyObject *resultobj = 0;
28241 Hex::Document *arg1 = (Hex::Document *) 0 ;
28245 PyObject * obj0 = 0 ;
28247 if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
28248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28249 if (!SWIG_IsOK(res1)) {
28250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
28252 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28253 result = (bool)(arg1)->isSaved();
28254 resultobj = SWIG_From_bool(static_cast< bool >(result));
28261 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262 PyObject *resultobj = 0;
28263 Hex::Document *arg1 = (Hex::Document *) 0 ;
28264 pfile arg2 = (pfile) 0 ;
28270 PyObject * obj0 = 0 ;
28271 PyObject * obj1 = 0 ;
28273 if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
28274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28275 if (!SWIG_IsOK(res1)) {
28276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
28278 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 | 0 );
28280 if (!SWIG_IsOK(res2)) {
28281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
28283 arg2 = reinterpret_cast< pfile >(argp2);
28284 result = (int)(arg1)->appendXml(arg2);
28285 resultobj = SWIG_From_int(static_cast< int >(result));
28292 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28293 PyObject *resultobj = 0;
28294 Hex::Document *arg1 = (Hex::Document *) 0 ;
28298 PyObject * obj0 = 0 ;
28300 if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
28301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
28305 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28306 result = (cpchar)(arg1)->getXml();
28307 resultobj = SWIG_FromCharPtr((const char *)result);
28314 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 PyObject *resultobj = 0;
28316 Hex::Document *arg1 = (Hex::Document *) 0 ;
28320 PyObject * obj0 = 0 ;
28322 if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
28323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28324 if (!SWIG_IsOK(res1)) {
28325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
28327 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28328 result = (int)(arg1)->getLevel();
28329 resultobj = SWIG_From_int(static_cast< int >(result));
28336 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *resultobj = 0;
28338 Hex::Document *arg1 = (Hex::Document *) 0 ;
28340 Hex::Vertex *result = 0 ;
28345 PyObject * obj0 = 0 ;
28346 PyObject * obj1 = 0 ;
28348 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
28349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
28353 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28354 ecode2 = SWIG_AsVal_int(obj1, &val2);
28355 if (!SWIG_IsOK(ecode2)) {
28356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
28358 arg2 = static_cast< int >(val2);
28359 result = (Hex::Vertex *)(arg1)->findVertex(arg2);
28360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28367 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
28372 if (!PyTuple_Check(args)) SWIG_fail;
28373 argc = PyObject_Length(args);
28374 for (ii = 0; (ii < argc) && (ii < 4); ii++) {
28375 argv[ii] = PyTuple_GET_ITEM(args,ii);
28380 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28381 _v = SWIG_CheckState(res);
28384 int res = SWIG_AsVal_int(argv[1], NULL);
28385 _v = SWIG_CheckState(res);
28388 return _wrap_Document_findVertex__SWIG_1(self, args);
28395 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28396 _v = SWIG_CheckState(res);
28399 int res = SWIG_AsVal_double(argv[1], NULL);
28400 _v = SWIG_CheckState(res);
28404 int res = SWIG_AsVal_double(argv[2], NULL);
28405 _v = SWIG_CheckState(res);
28409 int res = SWIG_AsVal_double(argv[3], NULL);
28410 _v = SWIG_CheckState(res);
28413 return _wrap_Document_findVertex__SWIG_0(self, args);
28421 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findVertex'.\n Possible C/C++ prototypes are:\n findVertex(double,double,double)\n findVertex(int)\n");
28426 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427 PyObject *resultobj = 0;
28428 Hex::Document *arg1 = (Hex::Document *) 0 ;
28429 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28430 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 PyObject * obj2 = 0 ;
28442 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
28443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28444 if (!SWIG_IsOK(res1)) {
28445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28447 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
28449 if (!SWIG_IsOK(res2)) {
28450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
28452 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28453 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
28454 if (!SWIG_IsOK(res3)) {
28455 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28457 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28458 result = (int)(arg1)->closeQuads(arg2,arg3);
28459 resultobj = SWIG_From_int(static_cast< int >(result));
28466 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28467 PyObject *resultobj = 0;
28468 Hex::Document *arg1 = (Hex::Document *) 0 ;
28469 Hex::Law *arg2 = (Hex::Law *) 0 ;
28470 Hex::Law *result = 0 ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28478 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
28479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28480 if (!SWIG_IsOK(res1)) {
28481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28483 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
28485 if (!SWIG_IsOK(res2)) {
28486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28488 arg2 = reinterpret_cast< Hex::Law * >(argp2);
28489 result = (Hex::Law *)(arg1)->addLaw(arg2);
28490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
28497 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
28502 if (!PyTuple_Check(args)) SWIG_fail;
28503 argc = PyObject_Length(args);
28504 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
28505 argv[ii] = PyTuple_GET_ITEM(args,ii);
28510 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28511 _v = SWIG_CheckState(res);
28514 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
28515 _v = SWIG_CheckState(res);
28517 return _wrap_Document_addLaw__SWIG_1(self, args);
28524 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28525 _v = SWIG_CheckState(res);
28527 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
28528 _v = SWIG_CheckState(res);
28531 int res = SWIG_AsVal_int(argv[2], NULL);
28532 _v = SWIG_CheckState(res);
28535 return _wrap_Document_addLaw__SWIG_0(self, args);
28542 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaw'.\n Possible C/C++ prototypes are:\n addLaw(char const *,int)\n addLaw(Hex::Law *)\n");
28547 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548 PyObject *resultobj = 0;
28549 Hex::Document *arg1 = (Hex::Document *) 0 ;
28553 PyObject * obj0 = 0 ;
28555 if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
28556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28557 if (!SWIG_IsOK(res1)) {
28558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
28560 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28561 result = (int)(arg1)->checkAssociations();
28562 resultobj = SWIG_From_int(static_cast< int >(result));
28569 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570 PyObject *resultobj = 0;
28571 Hex::Document *arg1 = (Hex::Document *) 0 ;
28573 char *arg3 = (char *) 0 ;
28574 Hex::NewShape *result = 0 ;
28582 PyObject * obj0 = 0 ;
28583 PyObject * obj1 = 0 ;
28584 PyObject * obj2 = 0 ;
28586 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
28587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28588 if (!SWIG_IsOK(res1)) {
28589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
28591 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28592 ecode2 = SWIG_AsVal_long(obj1, &val2);
28593 if (!SWIG_IsOK(ecode2)) {
28594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
28596 arg2 = static_cast< long >(val2);
28597 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
28598 if (!SWIG_IsOK(res3)) {
28599 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
28601 arg3 = reinterpret_cast< char * >(buf3);
28602 result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
28603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
28604 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28607 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28612 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28613 PyObject *resultobj = 0;
28614 Hex::Document *arg1 = (Hex::Document *) 0 ;
28617 PyObject * obj0 = 0 ;
28619 if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
28620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN | 0 );
28621 if (!SWIG_IsOK(res1)) {
28622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
28624 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28627 resultobj = SWIG_Py_Void();
28634 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28636 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28637 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
28638 return SWIG_Py_Void();
28641 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *resultobj = 0;
28643 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28644 Hex::Edges *result = 0 ;
28647 PyObject * obj0 = 0 ;
28649 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
28650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28651 if (!SWIG_IsOK(res1)) {
28652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
28654 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28656 Hex::Edges const &_result_ref = (arg1)->getEdges();
28657 result = (Hex::Edges *) &_result_ref;
28659 resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > >(*result));
28666 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28667 PyObject *resultobj = 0;
28668 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28669 Hex::Law *result = 0 ;
28672 PyObject * obj0 = 0 ;
28674 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
28675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28676 if (!SWIG_IsOK(res1)) {
28677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28679 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28680 result = (Hex::Law *)(arg1)->getLaw();
28681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
28688 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28694 PyObject * obj0 = 0 ;
28696 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
28697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28698 if (!SWIG_IsOK(res1)) {
28699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28701 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28702 result = (bool)(arg1)->getWay();
28703 resultobj = SWIG_From_bool(static_cast< bool >(result));
28710 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28711 PyObject *resultobj = 0;
28712 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28718 PyObject * obj0 = 0 ;
28719 PyObject * obj1 = 0 ;
28721 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
28722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28726 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28728 if (!SWIG_IsOK(ecode2)) {
28729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
28731 arg2 = static_cast< bool >(val2);
28732 (arg1)->setWay(arg2);
28733 resultobj = SWIG_Py_Void();
28740 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28743 Hex::Law *arg2 = (Hex::Law *) 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28752 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
28753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28757 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
28759 if (!SWIG_IsOK(res2)) {
28760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28762 arg2 = reinterpret_cast< Hex::Law * >(argp2);
28763 result = (int)(arg1)->setLaw(arg2);
28764 resultobj = SWIG_From_int(static_cast< int >(result));
28771 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28772 PyObject *resultobj = 0;
28773 Hex::Document *arg1 = (Hex::Document *) 0 ;
28774 Hex::Propagation *result = 0 ;
28777 PyObject * obj0 = 0 ;
28779 if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
28780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28781 if (!SWIG_IsOK(res1)) {
28782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
28784 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28785 result = (Hex::Propagation *)new Hex::Propagation(arg1);
28786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW | 0 );
28793 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28796 Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
28801 PyObject * obj0 = 0 ;
28802 PyObject * obj1 = 0 ;
28804 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
28805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
28809 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 | 0 );
28811 if (!SWIG_IsOK(res2)) {
28812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
28814 arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
28815 (arg1)->saveXml(arg2);
28816 resultobj = SWIG_Py_Void();
28823 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28826 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28831 PyObject * obj0 = 0 ;
28832 PyObject * obj1 = 0 ;
28834 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
28835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
28839 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28841 if (!SWIG_IsOK(res2)) {
28842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
28844 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28845 (arg1)->addEdge(arg2);
28846 resultobj = SWIG_Py_Void();
28853 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28854 PyObject *resultobj = 0;
28855 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28858 PyObject * obj0 = 0 ;
28860 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
28861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28862 if (!SWIG_IsOK(res1)) {
28863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28865 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28867 resultobj = SWIG_Py_Void();
28874 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28875 PyObject *resultobj = 0;
28876 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28879 PyObject * obj0 = 0 ;
28881 if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
28882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN | 0 );
28883 if (!SWIG_IsOK(res1)) {
28884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
28886 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28889 resultobj = SWIG_Py_Void();
28896 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28898 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28899 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
28900 return SWIG_Py_Void();
28903 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28904 PyObject *resultobj = 0;
28905 Hex::Hex *result = 0 ;
28907 if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
28908 result = (Hex::Hex *)Hex::hex_instance();
28909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 | 0 );
28916 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28917 PyObject *resultobj = 0;
28918 Hex::Hex *result = 0 ;
28920 if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
28921 result = (Hex::Hex *)Hex::Hex::getInstance();
28922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 | 0 );
28929 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28930 PyObject *resultobj = 0;
28931 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28935 PyObject * obj0 = 0 ;
28937 if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
28938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28942 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28943 result = (int)(arg1)->countDocument();
28944 resultobj = SWIG_From_int(static_cast< int >(result));
28951 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28952 PyObject *resultobj = 0;
28953 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28955 Hex::Document *result = 0 ;
28960 PyObject * obj0 = 0 ;
28961 PyObject * obj1 = 0 ;
28963 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
28964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
28965 if (!SWIG_IsOK(res1)) {
28966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28968 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28969 ecode2 = SWIG_AsVal_int(obj1, &val2);
28970 if (!SWIG_IsOK(ecode2)) {
28971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
28973 arg2 = static_cast< int >(val2);
28974 result = (Hex::Document *)(arg1)->getDocument(arg2);
28975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
28982 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 PyObject *resultobj = 0;
28984 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28985 Hex::Document *arg2 = (Hex::Document *) 0 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28993 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28998 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 | 0 );
29000 if (!SWIG_IsOK(res2)) {
29001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
29003 arg2 = reinterpret_cast< Hex::Document * >(argp2);
29004 (arg1)->removeDocument(arg2);
29005 resultobj = SWIG_Py_Void();
29012 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 PyObject *resultobj = 0;
29014 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29015 cpchar arg2 = (cpchar) 0 ;
29016 Hex::Document *result = 0 ;
29022 PyObject * obj0 = 0 ;
29023 PyObject * obj1 = 0 ;
29025 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
29026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29027 if (!SWIG_IsOK(res1)) {
29028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29030 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29031 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29032 if (!SWIG_IsOK(res2)) {
29033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
29035 arg2 = reinterpret_cast< cpchar >(buf2);
29036 result = (Hex::Document *)(arg1)->addDocument(arg2);
29037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
29038 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29041 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29046 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29047 PyObject *resultobj = 0;
29048 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29049 Hex::Document *result = 0 ;
29052 PyObject * obj0 = 0 ;
29054 if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
29055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29056 if (!SWIG_IsOK(res1)) {
29057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29059 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29060 result = (Hex::Document *)(arg1)->addDocument();
29061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
29068 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
29073 if (!PyTuple_Check(args)) SWIG_fail;
29074 argc = PyObject_Length(args);
29075 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29076 argv[ii] = PyTuple_GET_ITEM(args,ii);
29081 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29082 _v = SWIG_CheckState(res);
29084 return _wrap_Hex_addDocument__SWIG_1(self, args);
29090 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29091 _v = SWIG_CheckState(res);
29093 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29094 _v = SWIG_CheckState(res);
29096 return _wrap_Hex_addDocument__SWIG_0(self, args);
29102 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_addDocument'.\n Possible C/C++ prototypes are:\n addDocument(cpchar)\n addDocument()\n");
29107 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *resultobj = 0;
29109 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29110 cpchar arg2 = (cpchar) 0 ;
29111 Hex::Document *result = 0 ;
29117 PyObject * obj0 = 0 ;
29118 PyObject * obj1 = 0 ;
29120 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
29121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29122 if (!SWIG_IsOK(res1)) {
29123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29125 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29126 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29127 if (!SWIG_IsOK(res2)) {
29128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
29130 arg2 = reinterpret_cast< cpchar >(buf2);
29131 result = (Hex::Document *)(arg1)->loadDocument(arg2);
29132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
29133 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29136 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29141 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142 PyObject *resultobj = 0;
29143 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29144 cpchar arg2 = (cpchar) 0 ;
29145 Hex::Document *result = 0 ;
29151 PyObject * obj0 = 0 ;
29152 PyObject * obj1 = 0 ;
29154 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29156 if (!SWIG_IsOK(res1)) {
29157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29159 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29160 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29161 if (!SWIG_IsOK(res2)) {
29162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
29164 arg2 = reinterpret_cast< cpchar >(buf2);
29165 result = (Hex::Document *)(arg1)->findDocument(arg2);
29166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
29167 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29170 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29175 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29176 PyObject *resultobj = 0;
29177 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29179 Hex::Document *result = 0 ;
29184 PyObject * obj0 = 0 ;
29185 PyObject * obj1 = 0 ;
29187 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29189 if (!SWIG_IsOK(res1)) {
29190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29192 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 | 0);
29194 if (!SWIG_IsOK(res2)) {
29195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29200 arg2 = reinterpret_cast< string * >(argp2);
29201 result = (Hex::Document *)(arg1)->findDocument((string const &)*arg2);
29202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
29209 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
29214 if (!PyTuple_Check(args)) SWIG_fail;
29215 argc = PyObject_Length(args);
29216 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29217 argv[ii] = PyTuple_GET_ITEM(args,ii);
29222 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29223 _v = SWIG_CheckState(res);
29225 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
29226 _v = SWIG_CheckState(res);
29228 return _wrap_Hex_findDocument__SWIG_1(self, args);
29235 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29236 _v = SWIG_CheckState(res);
29238 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29239 _v = SWIG_CheckState(res);
29241 return _wrap_Hex_findDocument__SWIG_0(self, args);
29247 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_findDocument'.\n Possible C/C++ prototypes are:\n findDocument(cpchar)\n findDocument(string const &)\n");
29252 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29253 PyObject *resultobj = 0;
29254 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29257 PyObject * obj0 = 0 ;
29259 if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
29264 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29266 resultobj = SWIG_Py_Void();
29273 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274 PyObject *resultobj = 0;
29275 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29279 PyObject * obj0 = 0 ;
29281 if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
29282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29283 if (!SWIG_IsOK(res1)) {
29284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
29286 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29287 result = (int)(arg1)->sizeofMessage();
29288 resultobj = SWIG_From_int(static_cast< int >(result));
29295 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 PyObject *resultobj = 0;
29297 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29304 PyObject * obj0 = 0 ;
29305 PyObject * obj1 = 0 ;
29307 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
29308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
29309 if (!SWIG_IsOK(res1)) {
29310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
29312 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29313 ecode2 = SWIG_AsVal_int(obj1, &val2);
29314 if (!SWIG_IsOK(ecode2)) {
29315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
29317 arg2 = static_cast< int >(val2);
29318 result = (cpchar)(arg1)->getMessageLine(arg2);
29319 resultobj = SWIG_FromCharPtr((const char *)result);
29326 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29327 PyObject *resultobj = 0;
29328 Hex::Hex *result = 0 ;
29330 if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
29331 result = (Hex::Hex *)new Hex::Hex();
29332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW | 0 );
29339 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29340 PyObject *resultobj = 0;
29341 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29344 PyObject * obj0 = 0 ;
29346 if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
29347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN | 0 );
29348 if (!SWIG_IsOK(res1)) {
29349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
29351 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29354 resultobj = SWIG_Py_Void();
29361 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29363 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
29364 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
29365 return SWIG_Py_Void();
29368 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29369 PyObject *resultobj = 0;
29371 if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
29373 resultobj = SWIG_Py_Void();
29380 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29381 PyObject *resultobj = 0;
29382 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29384 Hex::Hexa *result = 0 ;
29389 PyObject * obj0 = 0 ;
29390 PyObject * obj1 = 0 ;
29392 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29397 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29398 ecode2 = SWIG_AsVal_int(obj1, &val2);
29399 if (!SWIG_IsOK(ecode2)) {
29400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
29402 arg2 = static_cast< int >(val2);
29403 result = (Hex::Hexa *)(arg1)->getHexa(arg2);
29404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
29411 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29412 PyObject *resultobj = 0;
29413 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29415 Hex::Quad *result = 0 ;
29420 PyObject * obj0 = 0 ;
29421 PyObject * obj1 = 0 ;
29423 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
29424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29428 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29429 ecode2 = SWIG_AsVal_int(obj1, &val2);
29430 if (!SWIG_IsOK(ecode2)) {
29431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
29433 arg2 = static_cast< int >(val2);
29434 result = (Hex::Quad *)(arg1)->getQuad(arg2);
29435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
29442 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29443 PyObject *resultobj = 0;
29444 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29446 Hex::Edge *result = 0 ;
29451 PyObject * obj0 = 0 ;
29452 PyObject * obj1 = 0 ;
29454 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
29455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29459 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
29464 arg2 = static_cast< int >(val2);
29465 result = (Hex::Edge *)(arg1)->getEdge(arg2);
29466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
29473 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29477 Hex::Vertex *result = 0 ;
29482 PyObject * obj0 = 0 ;
29483 PyObject * obj1 = 0 ;
29485 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
29486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29487 if (!SWIG_IsOK(res1)) {
29488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29490 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29491 ecode2 = SWIG_AsVal_int(obj1, &val2);
29492 if (!SWIG_IsOK(ecode2)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
29495 arg2 = static_cast< int >(val2);
29496 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
29497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29504 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29505 PyObject *resultobj = 0;
29506 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29510 Hex::Hexa *result = 0 ;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 PyObject * obj2 = 0 ;
29522 PyObject * obj3 = 0 ;
29524 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29526 if (!SWIG_IsOK(res1)) {
29527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29529 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29530 ecode2 = SWIG_AsVal_int(obj1, &val2);
29531 if (!SWIG_IsOK(ecode2)) {
29532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
29534 arg2 = static_cast< int >(val2);
29535 ecode3 = SWIG_AsVal_int(obj2, &val3);
29536 if (!SWIG_IsOK(ecode3)) {
29537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
29539 arg3 = static_cast< int >(val3);
29540 ecode4 = SWIG_AsVal_int(obj3, &val4);
29541 if (!SWIG_IsOK(ecode4)) {
29542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
29544 arg4 = static_cast< int >(val4);
29545 result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
29546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
29553 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29554 PyObject *resultobj = 0;
29555 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29559 Hex::Quad *result = 0 ;
29568 PyObject * obj0 = 0 ;
29569 PyObject * obj1 = 0 ;
29570 PyObject * obj2 = 0 ;
29571 PyObject * obj3 = 0 ;
29573 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29578 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29579 ecode2 = SWIG_AsVal_int(obj1, &val2);
29580 if (!SWIG_IsOK(ecode2)) {
29581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
29583 arg2 = static_cast< int >(val2);
29584 ecode3 = SWIG_AsVal_int(obj2, &val3);
29585 if (!SWIG_IsOK(ecode3)) {
29586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
29588 arg3 = static_cast< int >(val3);
29589 ecode4 = SWIG_AsVal_int(obj3, &val4);
29590 if (!SWIG_IsOK(ecode4)) {
29591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
29593 arg4 = static_cast< int >(val4);
29594 result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
29595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
29602 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603 PyObject *resultobj = 0;
29604 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29608 Hex::Quad *result = 0 ;
29617 PyObject * obj0 = 0 ;
29618 PyObject * obj1 = 0 ;
29619 PyObject * obj2 = 0 ;
29620 PyObject * obj3 = 0 ;
29622 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29624 if (!SWIG_IsOK(res1)) {
29625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29627 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29628 ecode2 = SWIG_AsVal_int(obj1, &val2);
29629 if (!SWIG_IsOK(ecode2)) {
29630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
29632 arg2 = static_cast< int >(val2);
29633 ecode3 = SWIG_AsVal_int(obj2, &val3);
29634 if (!SWIG_IsOK(ecode3)) {
29635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
29637 arg3 = static_cast< int >(val3);
29638 ecode4 = SWIG_AsVal_int(obj3, &val4);
29639 if (!SWIG_IsOK(ecode4)) {
29640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
29642 arg4 = static_cast< int >(val4);
29643 result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
29644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
29651 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652 PyObject *resultobj = 0;
29653 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29657 Hex::Quad *result = 0 ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 PyObject * obj2 = 0 ;
29669 PyObject * obj3 = 0 ;
29671 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
29676 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29677 ecode2 = SWIG_AsVal_int(obj1, &val2);
29678 if (!SWIG_IsOK(ecode2)) {
29679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
29681 arg2 = static_cast< int >(val2);
29682 ecode3 = SWIG_AsVal_int(obj2, &val3);
29683 if (!SWIG_IsOK(ecode3)) {
29684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
29686 arg3 = static_cast< int >(val3);
29687 ecode4 = SWIG_AsVal_int(obj3, &val4);
29688 if (!SWIG_IsOK(ecode4)) {
29689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
29691 arg4 = static_cast< int >(val4);
29692 result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
29693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
29700 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 PyObject *resultobj = 0;
29702 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29706 Hex::Edge *result = 0 ;
29715 PyObject * obj0 = 0 ;
29716 PyObject * obj1 = 0 ;
29717 PyObject * obj2 = 0 ;
29718 PyObject * obj3 = 0 ;
29720 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29722 if (!SWIG_IsOK(res1)) {
29723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
29725 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29726 ecode2 = SWIG_AsVal_int(obj1, &val2);
29727 if (!SWIG_IsOK(ecode2)) {
29728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
29730 arg2 = static_cast< int >(val2);
29731 ecode3 = SWIG_AsVal_int(obj2, &val3);
29732 if (!SWIG_IsOK(ecode3)) {
29733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
29735 arg3 = static_cast< int >(val3);
29736 ecode4 = SWIG_AsVal_int(obj3, &val4);
29737 if (!SWIG_IsOK(ecode4)) {
29738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
29740 arg4 = static_cast< int >(val4);
29741 result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
29742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
29749 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29750 PyObject *resultobj = 0;
29751 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29755 Hex::Edge *result = 0 ;
29764 PyObject * obj0 = 0 ;
29765 PyObject * obj1 = 0 ;
29766 PyObject * obj2 = 0 ;
29767 PyObject * obj3 = 0 ;
29769 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29774 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29775 ecode2 = SWIG_AsVal_int(obj1, &val2);
29776 if (!SWIG_IsOK(ecode2)) {
29777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
29779 arg2 = static_cast< int >(val2);
29780 ecode3 = SWIG_AsVal_int(obj2, &val3);
29781 if (!SWIG_IsOK(ecode3)) {
29782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
29784 arg3 = static_cast< int >(val3);
29785 ecode4 = SWIG_AsVal_int(obj3, &val4);
29786 if (!SWIG_IsOK(ecode4)) {
29787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
29789 arg4 = static_cast< int >(val4);
29790 result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
29791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
29798 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29799 PyObject *resultobj = 0;
29800 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29804 Hex::Edge *result = 0 ;
29813 PyObject * obj0 = 0 ;
29814 PyObject * obj1 = 0 ;
29815 PyObject * obj2 = 0 ;
29816 PyObject * obj3 = 0 ;
29818 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
29823 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29824 ecode2 = SWIG_AsVal_int(obj1, &val2);
29825 if (!SWIG_IsOK(ecode2)) {
29826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
29828 arg2 = static_cast< int >(val2);
29829 ecode3 = SWIG_AsVal_int(obj2, &val3);
29830 if (!SWIG_IsOK(ecode3)) {
29831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
29833 arg3 = static_cast< int >(val3);
29834 ecode4 = SWIG_AsVal_int(obj3, &val4);
29835 if (!SWIG_IsOK(ecode4)) {
29836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
29838 arg4 = static_cast< int >(val4);
29839 result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
29840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
29847 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *resultobj = 0;
29849 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29853 Hex::Vertex *result = 0 ;
29862 PyObject * obj0 = 0 ;
29863 PyObject * obj1 = 0 ;
29864 PyObject * obj2 = 0 ;
29865 PyObject * obj3 = 0 ;
29867 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29869 if (!SWIG_IsOK(res1)) {
29870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29872 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29873 ecode2 = SWIG_AsVal_int(obj1, &val2);
29874 if (!SWIG_IsOK(ecode2)) {
29875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
29877 arg2 = static_cast< int >(val2);
29878 ecode3 = SWIG_AsVal_int(obj2, &val3);
29879 if (!SWIG_IsOK(ecode3)) {
29880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
29882 arg3 = static_cast< int >(val3);
29883 ecode4 = SWIG_AsVal_int(obj3, &val4);
29884 if (!SWIG_IsOK(ecode4)) {
29885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
29887 arg4 = static_cast< int >(val4);
29888 result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
29889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29896 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29897 PyObject *resultobj = 0;
29898 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29902 PyObject * obj0 = 0 ;
29904 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
29905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29906 if (!SWIG_IsOK(res1)) {
29907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29909 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29910 result = (int)(arg1)->countHexa();
29911 resultobj = SWIG_From_int(static_cast< int >(result));
29918 SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29919 PyObject *resultobj = 0;
29920 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29924 PyObject * obj0 = 0 ;
29926 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
29927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29928 if (!SWIG_IsOK(res1)) {
29929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29931 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29932 result = (int)(arg1)->countQuad();
29933 resultobj = SWIG_From_int(static_cast< int >(result));
29940 SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29941 PyObject *resultobj = 0;
29942 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29946 PyObject * obj0 = 0 ;
29948 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
29949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29950 if (!SWIG_IsOK(res1)) {
29951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29953 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29954 result = (int)(arg1)->countEdge();
29955 resultobj = SWIG_From_int(static_cast< int >(result));
29962 SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29963 PyObject *resultobj = 0;
29964 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29968 PyObject * obj0 = 0 ;
29970 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
29971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29972 if (!SWIG_IsOK(res1)) {
29973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29975 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29976 result = (int)(arg1)->countVertex();
29977 resultobj = SWIG_From_int(static_cast< int >(result));
29984 SWIGINTERN PyObject *_wrap_Elements_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985 PyObject *resultobj = 0;
29986 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29987 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29988 Hex::Vertex *result = 0 ;
29993 PyObject * obj0 = 0 ;
29994 PyObject * obj1 = 0 ;
29996 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
29997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
29998 if (!SWIG_IsOK(res1)) {
29999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30001 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30003 if (!SWIG_IsOK(res2)) {
30004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
30006 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30007 result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
30008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30015 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 PyObject *resultobj = 0;
30017 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30018 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30024 PyObject * obj0 = 0 ;
30025 PyObject * obj1 = 0 ;
30027 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
30028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
30029 if (!SWIG_IsOK(res1)) {
30030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30032 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30034 if (!SWIG_IsOK(res2)) {
30035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
30037 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30038 result = (int)(arg1)->findVertex(arg2);
30039 resultobj = SWIG_From_int(static_cast< int >(result));
30046 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30047 PyObject *resultobj = 0;
30048 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30051 PyObject * obj0 = 0 ;
30053 if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
30054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
30058 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30059 (arg1)->clearAssociation();
30060 resultobj = SWIG_Py_Void();
30067 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30068 PyObject *resultobj = 0;
30069 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30070 cpchar arg2 = (cpchar) 0 ;
30077 PyObject * obj0 = 0 ;
30078 PyObject * obj1 = 0 ;
30080 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
30081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
30085 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30086 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30087 if (!SWIG_IsOK(res2)) {
30088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
30090 arg2 = reinterpret_cast< cpchar >(buf2);
30091 result = (int)(arg1)->saveVtk(arg2);
30092 resultobj = SWIG_From_int(static_cast< int >(result));
30093 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30096 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30101 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30102 PyObject *resultobj = 0;
30103 Hex::Document *arg1 = (Hex::Document *) 0 ;
30104 Hex::Elements *result = 0 ;
30107 PyObject * obj0 = 0 ;
30109 if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
30110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
30114 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30115 result = (Hex::Elements *)new Hex::Elements(arg1);
30116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW | 0 );
30123 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30124 PyObject *resultobj = 0;
30125 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30128 PyObject * obj0 = 0 ;
30130 if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
30131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN | 0 );
30132 if (!SWIG_IsOK(res1)) {
30133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
30135 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30138 resultobj = SWIG_Py_Void();
30145 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30147 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30148 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
30149 return SWIG_Py_Void();
30152 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153 PyObject *resultobj = 0;
30154 Hex::Document *arg1 = (Hex::Document *) 0 ;
30155 Hex::BiCylinder *result = 0 ;
30158 PyObject * obj0 = 0 ;
30160 if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
30161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30162 if (!SWIG_IsOK(res1)) {
30163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
30165 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30166 result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
30167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW | 0 );
30174 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30175 PyObject *resultobj = 0;
30176 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30181 Hex::Hexa *result = 0 ;
30192 PyObject * obj0 = 0 ;
30193 PyObject * obj1 = 0 ;
30194 PyObject * obj2 = 0 ;
30195 PyObject * obj3 = 0 ;
30196 PyObject * obj4 = 0 ;
30198 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30200 if (!SWIG_IsOK(res1)) {
30201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30203 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30204 ecode2 = SWIG_AsVal_int(obj1, &val2);
30205 if (!SWIG_IsOK(ecode2)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
30208 arg2 = static_cast< int >(val2);
30209 ecode3 = SWIG_AsVal_int(obj2, &val3);
30210 if (!SWIG_IsOK(ecode3)) {
30211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
30213 arg3 = static_cast< int >(val3);
30214 ecode4 = SWIG_AsVal_int(obj3, &val4);
30215 if (!SWIG_IsOK(ecode4)) {
30216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
30218 arg4 = static_cast< int >(val4);
30219 ecode5 = SWIG_AsVal_int(obj4, &val5);
30220 if (!SWIG_IsOK(ecode5)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
30223 arg5 = static_cast< int >(val5);
30224 result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
30225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
30232 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30233 PyObject *resultobj = 0;
30234 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30239 Hex::Quad *result = 0 ;
30250 PyObject * obj0 = 0 ;
30251 PyObject * obj1 = 0 ;
30252 PyObject * obj2 = 0 ;
30253 PyObject * obj3 = 0 ;
30254 PyObject * obj4 = 0 ;
30256 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30261 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30262 ecode2 = SWIG_AsVal_int(obj1, &val2);
30263 if (!SWIG_IsOK(ecode2)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
30266 arg2 = static_cast< int >(val2);
30267 ecode3 = SWIG_AsVal_int(obj2, &val3);
30268 if (!SWIG_IsOK(ecode3)) {
30269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
30271 arg3 = static_cast< int >(val3);
30272 ecode4 = SWIG_AsVal_int(obj3, &val4);
30273 if (!SWIG_IsOK(ecode4)) {
30274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
30276 arg4 = static_cast< int >(val4);
30277 ecode5 = SWIG_AsVal_int(obj4, &val5);
30278 if (!SWIG_IsOK(ecode5)) {
30279 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
30281 arg5 = static_cast< int >(val5);
30282 result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
30283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
30290 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30291 PyObject *resultobj = 0;
30292 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30297 Hex::Quad *result = 0 ;
30308 PyObject * obj0 = 0 ;
30309 PyObject * obj1 = 0 ;
30310 PyObject * obj2 = 0 ;
30311 PyObject * obj3 = 0 ;
30312 PyObject * obj4 = 0 ;
30314 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30316 if (!SWIG_IsOK(res1)) {
30317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30319 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30320 ecode2 = SWIG_AsVal_int(obj1, &val2);
30321 if (!SWIG_IsOK(ecode2)) {
30322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
30324 arg2 = static_cast< int >(val2);
30325 ecode3 = SWIG_AsVal_int(obj2, &val3);
30326 if (!SWIG_IsOK(ecode3)) {
30327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
30329 arg3 = static_cast< int >(val3);
30330 ecode4 = SWIG_AsVal_int(obj3, &val4);
30331 if (!SWIG_IsOK(ecode4)) {
30332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
30334 arg4 = static_cast< int >(val4);
30335 ecode5 = SWIG_AsVal_int(obj4, &val5);
30336 if (!SWIG_IsOK(ecode5)) {
30337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
30339 arg5 = static_cast< int >(val5);
30340 result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
30341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
30348 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30349 PyObject *resultobj = 0;
30350 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30355 Hex::Quad *result = 0 ;
30366 PyObject * obj0 = 0 ;
30367 PyObject * obj1 = 0 ;
30368 PyObject * obj2 = 0 ;
30369 PyObject * obj3 = 0 ;
30370 PyObject * obj4 = 0 ;
30372 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30374 if (!SWIG_IsOK(res1)) {
30375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30377 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30378 ecode2 = SWIG_AsVal_int(obj1, &val2);
30379 if (!SWIG_IsOK(ecode2)) {
30380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
30382 arg2 = static_cast< int >(val2);
30383 ecode3 = SWIG_AsVal_int(obj2, &val3);
30384 if (!SWIG_IsOK(ecode3)) {
30385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
30387 arg3 = static_cast< int >(val3);
30388 ecode4 = SWIG_AsVal_int(obj3, &val4);
30389 if (!SWIG_IsOK(ecode4)) {
30390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
30392 arg4 = static_cast< int >(val4);
30393 ecode5 = SWIG_AsVal_int(obj4, &val5);
30394 if (!SWIG_IsOK(ecode5)) {
30395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
30397 arg5 = static_cast< int >(val5);
30398 result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
30399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
30406 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 PyObject *resultobj = 0;
30408 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30413 Hex::Edge *result = 0 ;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 PyObject * obj2 = 0 ;
30427 PyObject * obj3 = 0 ;
30428 PyObject * obj4 = 0 ;
30430 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30435 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30436 ecode2 = SWIG_AsVal_int(obj1, &val2);
30437 if (!SWIG_IsOK(ecode2)) {
30438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
30440 arg2 = static_cast< int >(val2);
30441 ecode3 = SWIG_AsVal_int(obj2, &val3);
30442 if (!SWIG_IsOK(ecode3)) {
30443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
30445 arg3 = static_cast< int >(val3);
30446 ecode4 = SWIG_AsVal_int(obj3, &val4);
30447 if (!SWIG_IsOK(ecode4)) {
30448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
30450 arg4 = static_cast< int >(val4);
30451 ecode5 = SWIG_AsVal_int(obj4, &val5);
30452 if (!SWIG_IsOK(ecode5)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
30455 arg5 = static_cast< int >(val5);
30456 result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
30457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
30464 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30465 PyObject *resultobj = 0;
30466 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30471 Hex::Edge *result = 0 ;
30482 PyObject * obj0 = 0 ;
30483 PyObject * obj1 = 0 ;
30484 PyObject * obj2 = 0 ;
30485 PyObject * obj3 = 0 ;
30486 PyObject * obj4 = 0 ;
30488 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30490 if (!SWIG_IsOK(res1)) {
30491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30493 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30494 ecode2 = SWIG_AsVal_int(obj1, &val2);
30495 if (!SWIG_IsOK(ecode2)) {
30496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
30498 arg2 = static_cast< int >(val2);
30499 ecode3 = SWIG_AsVal_int(obj2, &val3);
30500 if (!SWIG_IsOK(ecode3)) {
30501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
30503 arg3 = static_cast< int >(val3);
30504 ecode4 = SWIG_AsVal_int(obj3, &val4);
30505 if (!SWIG_IsOK(ecode4)) {
30506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
30508 arg4 = static_cast< int >(val4);
30509 ecode5 = SWIG_AsVal_int(obj4, &val5);
30510 if (!SWIG_IsOK(ecode5)) {
30511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
30513 arg5 = static_cast< int >(val5);
30514 result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
30515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
30522 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30523 PyObject *resultobj = 0;
30524 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30529 Hex::Edge *result = 0 ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 PyObject * obj2 = 0 ;
30543 PyObject * obj3 = 0 ;
30544 PyObject * obj4 = 0 ;
30546 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30551 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30552 ecode2 = SWIG_AsVal_int(obj1, &val2);
30553 if (!SWIG_IsOK(ecode2)) {
30554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
30556 arg2 = static_cast< int >(val2);
30557 ecode3 = SWIG_AsVal_int(obj2, &val3);
30558 if (!SWIG_IsOK(ecode3)) {
30559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
30561 arg3 = static_cast< int >(val3);
30562 ecode4 = SWIG_AsVal_int(obj3, &val4);
30563 if (!SWIG_IsOK(ecode4)) {
30564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
30566 arg4 = static_cast< int >(val4);
30567 ecode5 = SWIG_AsVal_int(obj4, &val5);
30568 if (!SWIG_IsOK(ecode5)) {
30569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
30571 arg5 = static_cast< int >(val5);
30572 result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
30573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
30580 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30581 PyObject *resultobj = 0;
30582 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30587 Hex::Vertex *result = 0 ;
30598 PyObject * obj0 = 0 ;
30599 PyObject * obj1 = 0 ;
30600 PyObject * obj2 = 0 ;
30601 PyObject * obj3 = 0 ;
30602 PyObject * obj4 = 0 ;
30604 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30606 if (!SWIG_IsOK(res1)) {
30607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30609 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30610 ecode2 = SWIG_AsVal_int(obj1, &val2);
30611 if (!SWIG_IsOK(ecode2)) {
30612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
30614 arg2 = static_cast< int >(val2);
30615 ecode3 = SWIG_AsVal_int(obj2, &val3);
30616 if (!SWIG_IsOK(ecode3)) {
30617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
30619 arg3 = static_cast< int >(val3);
30620 ecode4 = SWIG_AsVal_int(obj3, &val4);
30621 if (!SWIG_IsOK(ecode4)) {
30622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
30624 arg4 = static_cast< int >(val4);
30625 ecode5 = SWIG_AsVal_int(obj4, &val5);
30626 if (!SWIG_IsOK(ecode5)) {
30627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
30629 arg5 = static_cast< int >(val5);
30630 result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
30631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30638 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 PyObject *resultobj = 0;
30640 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30643 PyObject * obj0 = 0 ;
30645 if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
30646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN | 0 );
30647 if (!SWIG_IsOK(res1)) {
30648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30650 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30653 resultobj = SWIG_Py_Void();
30660 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30662 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30663 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
30664 return SWIG_Py_Void();
30667 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30668 PyObject *resultobj = 0;
30669 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30673 PyObject * obj0 = 0 ;
30675 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
30676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30677 if (!SWIG_IsOK(res1)) {
30678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30680 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30681 result = (int)(arg1)->countVertex();
30682 resultobj = SWIG_From_int(static_cast< int >(result));
30689 SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30690 PyObject *resultobj = 0;
30691 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30695 PyObject * obj0 = 0 ;
30697 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
30698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30702 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30703 result = (int)(arg1)->countEdge();
30704 resultobj = SWIG_From_int(static_cast< int >(result));
30711 SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712 PyObject *resultobj = 0;
30713 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30717 PyObject * obj0 = 0 ;
30719 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
30720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30721 if (!SWIG_IsOK(res1)) {
30722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30724 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30725 result = (int)(arg1)->countFace();
30726 resultobj = SWIG_From_int(static_cast< int >(result));
30733 SWIGINTERN PyObject *_wrap_NewShape_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30734 PyObject *resultobj = 0;
30735 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30745 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
30746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30750 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30751 ecode2 = SWIG_AsVal_int(obj1, &val2);
30752 if (!SWIG_IsOK(ecode2)) {
30753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
30755 arg2 = static_cast< int >(val2);
30756 result = (int)(arg1)->getVertex(arg2);
30757 resultobj = SWIG_From_int(static_cast< int >(result));
30764 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30765 PyObject *resultobj = 0;
30766 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30773 PyObject * obj0 = 0 ;
30774 PyObject * obj1 = 0 ;
30776 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
30777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30778 if (!SWIG_IsOK(res1)) {
30779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30781 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30782 ecode2 = SWIG_AsVal_int(obj1, &val2);
30783 if (!SWIG_IsOK(ecode2)) {
30784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
30786 arg2 = static_cast< int >(val2);
30787 result = (int)(arg1)->getEdge(arg2);
30788 resultobj = SWIG_From_int(static_cast< int >(result));
30795 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30796 PyObject *resultobj = 0;
30797 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30804 PyObject * obj0 = 0 ;
30805 PyObject * obj1 = 0 ;
30807 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
30808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30809 if (!SWIG_IsOK(res1)) {
30810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30812 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30813 ecode2 = SWIG_AsVal_int(obj1, &val2);
30814 if (!SWIG_IsOK(ecode2)) {
30815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
30817 arg2 = static_cast< int >(val2);
30818 result = (int)(arg1)->getFace(arg2);
30819 resultobj = SWIG_From_int(static_cast< int >(result));
30826 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30827 PyObject *resultobj = 0;
30828 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30835 PyObject * obj0 = 0 ;
30836 PyObject * obj1 = 0 ;
30838 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
30839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30840 if (!SWIG_IsOK(res1)) {
30841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30843 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30844 ecode2 = SWIG_AsVal_int(obj1, &val2);
30845 if (!SWIG_IsOK(ecode2)) {
30846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
30848 arg2 = static_cast< int >(val2);
30849 result = (cpchar)(arg1)->getNameVertex(arg2);
30850 resultobj = SWIG_FromCharPtr((const char *)result);
30857 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30858 PyObject *resultobj = 0;
30859 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30866 PyObject * obj0 = 0 ;
30867 PyObject * obj1 = 0 ;
30869 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
30870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30871 if (!SWIG_IsOK(res1)) {
30872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30874 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30875 ecode2 = SWIG_AsVal_int(obj1, &val2);
30876 if (!SWIG_IsOK(ecode2)) {
30877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
30879 arg2 = static_cast< int >(val2);
30880 result = (cpchar)(arg1)->getNameEdge(arg2);
30881 resultobj = SWIG_FromCharPtr((const char *)result);
30888 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30889 PyObject *resultobj = 0;
30890 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30897 PyObject * obj0 = 0 ;
30898 PyObject * obj1 = 0 ;
30900 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
30901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
30902 if (!SWIG_IsOK(res1)) {
30903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30905 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30906 ecode2 = SWIG_AsVal_int(obj1, &val2);
30907 if (!SWIG_IsOK(ecode2)) {
30908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
30910 arg2 = static_cast< int >(val2);
30911 result = (cpchar)(arg1)->getNameFace(arg2);
30912 resultobj = SWIG_FromCharPtr((const char *)result);
30919 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30920 PyObject *resultobj = 0;
30921 Hex::Document *arg1 = (Hex::Document *) 0 ;
30922 Hex::EnumShape arg2 ;
30923 Hex::NewShape *result = 0 ;
30928 PyObject * obj0 = 0 ;
30929 PyObject * obj1 = 0 ;
30931 if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
30932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30936 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30937 ecode2 = SWIG_AsVal_int(obj1, &val2);
30938 if (!SWIG_IsOK(ecode2)) {
30939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
30941 arg2 = static_cast< Hex::EnumShape >(val2);
30942 result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
30943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW | 0 );
30950 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951 PyObject *resultobj = 0;
30952 Hex::Document *arg1 = (Hex::Document *) 0 ;
30953 Hex::NewShape *result = 0 ;
30956 PyObject * obj0 = 0 ;
30958 if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
30959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30960 if (!SWIG_IsOK(res1)) {
30961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30963 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30964 result = (Hex::NewShape *)new Hex::NewShape(arg1);
30965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW | 0 );
30972 SWIGINTERN PyObject *_wrap_new_NewShape(PyObject *self, PyObject *args) {
30977 if (!PyTuple_Check(args)) SWIG_fail;
30978 argc = PyObject_Length(args);
30979 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30980 argv[ii] = PyTuple_GET_ITEM(args,ii);
30985 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30986 _v = SWIG_CheckState(res);
30988 return _wrap_new_NewShape__SWIG_1(self, args);
30994 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30995 _v = SWIG_CheckState(res);
30998 int res = SWIG_AsVal_int(argv[1], NULL);
30999 _v = SWIG_CheckState(res);
31002 return _wrap_new_NewShape__SWIG_0(self, args);
31008 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewShape'.\n Possible C/C++ prototypes are:\n Hex::NewShape(Hex::Document *,Hex::EnumShape)\n Hex::NewShape(Hex::Document *)\n");
31013 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31018 PyObject * obj0 = 0 ;
31020 if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
31021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN | 0 );
31022 if (!SWIG_IsOK(res1)) {
31023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
31025 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31028 resultobj = SWIG_Py_Void();
31035 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31037 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31038 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
31039 return SWIG_Py_Void();
31042 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 Hex::Group *arg1 = (Hex::Group *) 0 ;
31045 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31051 PyObject * obj0 = 0 ;
31052 PyObject * obj1 = 0 ;
31054 if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
31055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31056 if (!SWIG_IsOK(res1)) {
31057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
31059 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
31061 if (!SWIG_IsOK(res2)) {
31062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31064 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31065 result = (int)(arg1)->addElement(arg2);
31066 resultobj = SWIG_From_int(static_cast< int >(result));
31073 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 Hex::Group *arg1 = (Hex::Group *) 0 ;
31079 PyObject * obj0 = 0 ;
31081 if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
31082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
31086 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31087 result = (int)(arg1)->countElement();
31088 resultobj = SWIG_From_int(static_cast< int >(result));
31095 SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31096 PyObject *resultobj = 0;
31097 Hex::Group *arg1 = (Hex::Group *) 0 ;
31098 Hex::EnumGroup result;
31101 PyObject * obj0 = 0 ;
31103 if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
31104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31105 if (!SWIG_IsOK(res1)) {
31106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
31108 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31109 result = (Hex::EnumGroup)(arg1)->getKind();
31110 resultobj = SWIG_From_int(static_cast< int >(result));
31117 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31118 PyObject *resultobj = 0;
31119 Hex::Group *arg1 = (Hex::Group *) 0 ;
31126 PyObject * obj0 = 0 ;
31127 PyObject * obj1 = 0 ;
31129 if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31134 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31135 ecode2 = SWIG_AsVal_int(obj1, &val2);
31136 if (!SWIG_IsOK(ecode2)) {
31137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
31139 arg2 = static_cast< int >(val2);
31140 result = (int)(arg1)->removeElement(arg2);
31141 resultobj = SWIG_From_int(static_cast< int >(result));
31148 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31149 PyObject *resultobj = 0;
31150 Hex::Group *arg1 = (Hex::Group *) 0 ;
31153 PyObject * obj0 = 0 ;
31155 if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
31156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31157 if (!SWIG_IsOK(res1)) {
31158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
31160 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31161 (arg1)->clearElement();
31162 resultobj = SWIG_Py_Void();
31169 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31170 PyObject *resultobj = 0;
31171 Hex::Group *arg1 = (Hex::Group *) 0 ;
31172 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31178 PyObject * obj0 = 0 ;
31179 PyObject * obj1 = 0 ;
31181 if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31186 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
31188 if (!SWIG_IsOK(res2)) {
31189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31191 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31192 result = (int)(arg1)->removeElement(arg2);
31193 resultobj = SWIG_From_int(static_cast< int >(result));
31200 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
31205 if (!PyTuple_Check(args)) SWIG_fail;
31206 argc = PyObject_Length(args);
31207 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31208 argv[ii] = PyTuple_GET_ITEM(args,ii);
31213 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31214 _v = SWIG_CheckState(res);
31217 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
31218 _v = SWIG_CheckState(res);
31220 return _wrap_Group_removeElement__SWIG_1(self, args);
31227 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31228 _v = SWIG_CheckState(res);
31231 int res = SWIG_AsVal_int(argv[1], NULL);
31232 _v = SWIG_CheckState(res);
31235 return _wrap_Group_removeElement__SWIG_0(self, args);
31241 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeElement'.\n Possible C/C++ prototypes are:\n removeElement(int)\n removeElement(Hex::EltBase *)\n");
31246 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *resultobj = 0;
31248 Hex::Group *arg1 = (Hex::Group *) 0 ;
31250 Hex::EltBase *result = 0 ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31258 if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
31259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
31260 if (!SWIG_IsOK(res1)) {
31261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
31263 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31264 ecode2 = SWIG_AsVal_int(obj1, &val2);
31265 if (!SWIG_IsOK(ecode2)) {
31266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
31268 arg2 = static_cast< int >(val2);
31269 result = (Hex::EltBase *)(arg1)->getElement(arg2);
31270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
31277 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31278 PyObject *resultobj = 0;
31279 Hex::Document *arg1 = (Hex::Document *) 0 ;
31280 cpchar arg2 = (cpchar) 0 ;
31281 Hex::EnumGroup arg3 ;
31282 Hex::Group *result = 0 ;
31290 PyObject * obj0 = 0 ;
31291 PyObject * obj1 = 0 ;
31292 PyObject * obj2 = 0 ;
31294 if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
31295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31296 if (!SWIG_IsOK(res1)) {
31297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
31299 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31300 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31301 if (!SWIG_IsOK(res2)) {
31302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
31304 arg2 = reinterpret_cast< cpchar >(buf2);
31305 ecode3 = SWIG_AsVal_int(obj2, &val3);
31306 if (!SWIG_IsOK(ecode3)) {
31307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
31309 arg3 = static_cast< Hex::EnumGroup >(val3);
31310 result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
31311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW | 0 );
31312 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31315 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31320 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321 PyObject *resultobj = 0;
31322 Hex::Group *arg1 = (Hex::Group *) 0 ;
31325 PyObject * obj0 = 0 ;
31327 if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
31328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
31332 arg1 = reinterpret_cast< Hex::Group * >(argp1);
31335 resultobj = SWIG_Py_Void();
31342 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31344 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31345 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
31346 return SWIG_Py_Void();
31349 static PyMethodDef SwigMethods[] = {
31350 { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
31351 { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
31352 { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
31353 { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
31354 { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
31355 { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
31356 { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
31357 { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
31358 { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
31359 { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
31360 { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
31361 { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
31362 { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
31363 { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
31364 { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
31365 { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
31366 { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
31367 { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
31368 { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
31369 { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
31370 { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
31371 { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
31372 { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
31373 { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
31374 { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
31375 { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
31376 { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
31377 { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
31378 { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
31379 { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
31380 { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
31381 { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
31382 { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
31383 { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
31384 { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
31385 { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
31386 { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
31387 { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
31388 { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
31389 { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
31390 { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
31391 { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
31392 { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
31393 { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
31394 { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
31395 { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
31396 { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
31397 { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
31398 { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
31399 { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
31400 { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
31401 { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
31402 { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
31403 { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
31404 { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
31405 { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
31406 { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
31407 { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
31408 { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
31409 { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
31410 { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
31411 { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
31412 { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
31413 { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
31414 { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
31415 { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
31416 { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
31417 { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
31418 { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
31419 { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
31420 { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
31421 { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
31422 { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
31423 { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
31424 { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
31425 { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
31426 { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
31427 { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
31428 { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
31429 { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
31430 { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
31431 { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
31432 { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
31433 { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
31434 { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
31435 { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
31436 { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
31437 { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
31438 { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
31439 { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
31440 { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
31441 { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
31442 { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
31443 { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
31444 { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
31445 { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
31446 { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
31447 { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
31448 { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
31449 { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
31450 { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
31451 { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
31452 { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
31453 { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
31454 { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
31455 { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
31456 { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
31457 { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
31458 { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
31459 { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
31460 { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
31461 { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
31462 { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
31463 { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
31464 { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
31465 { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
31466 { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
31467 { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
31468 { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
31469 { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
31470 { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
31471 { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
31472 { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
31473 { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
31474 { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
31475 { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
31476 { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
31477 { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
31478 { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
31479 { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
31480 { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
31481 { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
31482 { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
31483 { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
31484 { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
31485 { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
31486 { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
31487 { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
31488 { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
31489 { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
31490 { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
31491 { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
31492 { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
31493 { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
31494 { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
31495 { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
31496 { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
31497 { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
31498 { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
31499 { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
31500 { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
31501 { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
31502 { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
31503 { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
31504 { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
31505 { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
31506 { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
31507 { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
31508 { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
31509 { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
31510 { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
31511 { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
31512 { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
31513 { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
31514 { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
31515 { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
31516 { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
31517 { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
31518 { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
31519 { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
31520 { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
31521 { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
31522 { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
31523 { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
31524 { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
31525 { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
31526 { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
31527 { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
31528 { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
31529 { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
31530 { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
31531 { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
31532 { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
31533 { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
31534 { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
31535 { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
31536 { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
31537 { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
31538 { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
31539 { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
31540 { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
31541 { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
31542 { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
31543 { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
31544 { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
31545 { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
31546 { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
31547 { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
31548 { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
31549 { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
31550 { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
31551 { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
31552 { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
31553 { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
31554 { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
31555 { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
31556 { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
31557 { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
31558 { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
31559 { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
31560 { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
31561 { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
31562 { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
31563 { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
31564 { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
31565 { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
31566 { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
31567 { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
31568 { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
31569 { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
31570 { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
31571 { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
31572 { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
31573 { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
31574 { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
31575 { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
31576 { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
31577 { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
31578 { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
31579 { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
31580 { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
31581 { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
31582 { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
31583 { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
31584 { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
31585 { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
31586 { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
31587 { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
31588 { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
31589 { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
31590 { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
31591 { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
31592 { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
31593 { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
31594 { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
31595 { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
31596 { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
31597 { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
31598 { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
31599 { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
31600 { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
31601 { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
31602 { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
31603 { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
31604 { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
31605 { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
31606 { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
31607 { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
31608 { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
31609 { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
31610 { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
31611 { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
31612 { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
31613 { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
31614 { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
31615 { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
31616 { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
31617 { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
31618 { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
31619 { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
31620 { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
31621 { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
31622 { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
31623 { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
31624 { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
31625 { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
31626 { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
31627 { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
31628 { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
31629 { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
31630 { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
31631 { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
31632 { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
31633 { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
31634 { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
31635 { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
31636 { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
31637 { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
31638 { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
31639 { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
31640 { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
31641 { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
31642 { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
31643 { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
31644 { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
31645 { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
31646 { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
31647 { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
31648 { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
31649 { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
31650 { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
31651 { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
31652 { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
31653 { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
31654 { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
31655 { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
31656 { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
31657 { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
31658 { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
31659 { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
31660 { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
31661 { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
31662 { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
31663 { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
31664 { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
31665 { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
31666 { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
31667 { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
31668 { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
31669 { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
31670 { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
31671 { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
31672 { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
31673 { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
31674 { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
31675 { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
31676 { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
31677 { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
31678 { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
31679 { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
31680 { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
31681 { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
31682 { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
31683 { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
31684 { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
31685 { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
31686 { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
31687 { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
31688 { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
31689 { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
31690 { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
31691 { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
31692 { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
31693 { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
31694 { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
31695 { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
31696 { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
31697 { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
31698 { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
31699 { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
31700 { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
31701 { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
31702 { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
31703 { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
31704 { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
31705 { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
31706 { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
31707 { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
31708 { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
31709 { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
31710 { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
31711 { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
31712 { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
31713 { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
31714 { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
31715 { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
31716 { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
31717 { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
31718 { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
31719 { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
31721 { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
31722 { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
31723 { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
31724 { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
31725 { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
31726 { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
31727 { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
31728 { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
31729 { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
31730 { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
31731 { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
31732 { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
31733 { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
31734 { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
31735 { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
31736 { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
31737 { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
31738 { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
31739 { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
31740 { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
31741 { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
31742 { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
31743 { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
31744 { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
31745 { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
31746 { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
31747 { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
31748 { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
31749 { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
31750 { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
31751 { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
31752 { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
31753 { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
31754 { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
31755 { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
31756 { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
31757 { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
31758 { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
31759 { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
31760 { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
31761 { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
31762 { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
31763 { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
31764 { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
31765 { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
31766 { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
31767 { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
31768 { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
31769 { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
31770 { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
31771 { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
31772 { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
31773 { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
31774 { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
31775 { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
31776 { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
31777 { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
31778 { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
31779 { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
31780 { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
31781 { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
31782 { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
31783 { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
31784 { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
31785 { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
31786 { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
31787 { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
31788 { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
31789 { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
31790 { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
31791 { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
31792 { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
31793 { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
31794 { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
31795 { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
31796 { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
31797 { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
31798 { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
31799 { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
31800 { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
31801 { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
31802 { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
31803 { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
31804 { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
31805 { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
31806 { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
31807 { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
31808 { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
31809 { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
31810 { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
31811 { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
31812 { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
31813 { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
31814 { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
31815 { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
31816 { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
31817 { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
31818 { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
31819 { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
31820 { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
31821 { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
31822 { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
31823 { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
31824 { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
31825 { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
31826 { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
31827 { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
31828 { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
31829 { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
31830 { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
31831 { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
31832 { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
31833 { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
31834 { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
31835 { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
31836 { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
31837 { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
31838 { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
31839 { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
31840 { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
31841 { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
31842 { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
31843 { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
31844 { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
31845 { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
31846 { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
31847 { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
31848 { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
31849 { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
31850 { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
31851 { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
31852 { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
31853 { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
31854 { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
31855 { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
31856 { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
31857 { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
31858 { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
31859 { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
31860 { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
31861 { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
31862 { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
31863 { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
31864 { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
31865 { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
31866 { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
31867 { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
31868 { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
31869 { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
31870 { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
31871 { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
31872 { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
31873 { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
31874 { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
31875 { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
31876 { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
31877 { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
31878 { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
31879 { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
31880 { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
31881 { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
31882 { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
31883 { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
31884 { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
31885 { (char *)"what", _wrap_what, METH_VARARGS, NULL},
31886 { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
31887 { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
31888 { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
31889 { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
31890 { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
31891 { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
31892 { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
31893 { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
31894 { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
31895 { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
31896 { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
31897 { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
31898 { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
31899 { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
31900 { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
31901 { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
31902 { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
31903 { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
31904 { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
31905 { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
31906 { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
31907 { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
31908 { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
31909 { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
31910 { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
31911 { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
31912 { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
31913 { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
31914 { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
31915 { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
31916 { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
31917 { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
31918 { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
31919 { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
31920 { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
31921 { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
31922 { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
31923 { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
31924 { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
31925 { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
31926 { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
31927 { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
31928 { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
31929 { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
31930 { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
31931 { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
31932 { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
31933 { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
31934 { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
31935 { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
31936 { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
31937 { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
31938 { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
31939 { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
31940 { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
31941 { NULL, NULL, 0, NULL }
31945 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31947 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x) {
31948 return (void *)((Hex::EltBase *) ((Hex::Vector *) x));
31950 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x) {
31951 return (void *)((Hex::EltBase *) ((Hex::NewShape *) x));
31953 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x) {
31954 return (void *)((Hex::EltBase *) ((Hex::Group *) x));
31956 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x) {
31957 return (void *)((Hex::EltBase *) ((Hex::Propagation *) x));
31959 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x) {
31960 return (void *)((Hex::EltBase *) ((Hex::Vertex *) x));
31962 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x) {
31963 return (void *)((Hex::EltBase *) ((Hex::Hexa *) x));
31965 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x) {
31966 return (void *)((Hex::EltBase *) ((Hex::Edge *) x));
31968 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x) {
31969 return (void *)((Hex::EltBase *) ((Hex::Quad *) x));
31971 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x) {
31972 return (void *)((Hex::EltBase *) ((Hex::Elements *) x));
31974 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x) {
31975 return (void *)((Hex::EltBase *) ((Hex::Document *) x));
31977 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x) {
31978 return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
31980 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x) {
31981 return (void *)((Hex::Elements *) ((Hex::BiCylinder *) x));
31983 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
31984 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
31985 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
31986 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "Hex::Edge *", 0, 0, (void*)0, 0};
31987 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
31988 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31989 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
31990 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
31991 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31992 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *", 0, 0, (void*)0, 0};
31993 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
31994 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "Hex::NewShape *", 0, 0, (void*)0, 0};
31995 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
31996 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "Hex::Quad *", 0, 0, (void*)0, 0};
31997 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
31998 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
31999 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "Hex::Vertex *", 0, 0, (void*)0, 0};
32000 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
32001 static swig_type_info _swigt__p_a_Hex__DIM3__double = {"_p_a_Hex__DIM3__double", "double (*)[Hex::DIM3]|Hex::Real3 *", 0, 0, (void*)0, 0};
32002 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
32003 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
32004 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
32005 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
32006 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
32007 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
32008 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
32009 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
32010 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
32011 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
32012 static swig_type_info _swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t = {"_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t", "std::vector<Hex::AssoEdge *,std::allocator<Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
32013 static swig_type_info _swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t = {"_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t", "std::vector<Hex::EdgeShape *,std::allocator<Hex::EdgeShape * > > *|Hex::EdgeShapes *", 0, 0, (void*)0, 0};
32014 static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t", "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *|Hex::Edges *", 0, 0, (void*)0, 0};
32015 static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type", "std::allocator<Hex::Edge * > *|std::vector<Hex::Edge * >::allocator_type *", 0, 0, (void*)0, 0};
32016 static swig_type_info _swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t = {"_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t", "std::vector<Hex::EltBase *,std::allocator<Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
32017 static swig_type_info _swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t = {"_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t", "std::vector<Hex::FaceShape *,std::allocator<Hex::FaceShape * > > *|Hex::FaceShapes *", 0, 0, (void*)0, 0};
32018 static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t", "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *|Hex::Hexas *", 0, 0, (void*)0, 0};
32019 static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type", "std::allocator<Hex::Hexa * > *|std::vector<Hex::Hexa * >::allocator_type *", 0, 0, (void*)0, 0};
32020 static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t", "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *|Hex::NewShapes *", 0, 0, (void*)0, 0};
32021 static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type", "std::allocator<Hex::NewShape * > *|std::vector<Hex::NewShape * >::allocator_type *", 0, 0, (void*)0, 0};
32022 static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t", "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *|Hex::Quads *", 0, 0, (void*)0, 0};
32023 static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type", "std::allocator<Hex::Quad * > *|std::vector<Hex::Quad * >::allocator_type *", 0, 0, (void*)0, 0};
32024 static swig_type_info _swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t = {"_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t", "std::vector<Hex::Shape *,std::allocator<Hex::Shape * > > *|Hex::Shapes *", 0, 0, (void*)0, 0};
32025 static swig_type_info _swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t = {"_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t", "std::vector<Hex::SubShape *,std::allocator<Hex::SubShape * > > *|Hex::SubShapes *", 0, 0, (void*)0, 0};
32026 static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t", "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *|Hex::Vertices *", 0, 0, (void*)0, 0};
32027 static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type", "std::allocator<Hex::Vertex * > *|std::vector<Hex::Vertex * >::allocator_type *", 0, 0, (void*)0, 0};
32028 static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t", "std::vector<double,std::allocator<double > > *|Hex::RealVector *", 0, 0, (void*)0, 0};
32029 static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type", "std::allocator<double > *|std::vector<double >::allocator_type *", 0, 0, (void*)0, 0};
32030 static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t = {"_p_std__vectorTint_std__allocatorTint_t_t", "std::vector<int,std::allocator<int > > *|Hex::IntVector *", 0, 0, (void*)0, 0};
32031 static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type = {"_p_std__vectorTint_std__allocatorTint_t_t__allocator_type", "std::allocator<int > *|std::vector<int >::allocator_type *", 0, 0, (void*)0, 0};
32032 static swig_type_info _swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t = {"_p_std__vectorTstd__string_std__allocatorTstd__string_t_t", "std::vector<std::string,std::allocator<std::string > > *|Hex::TabText *", 0, 0, (void*)0, 0};
32033 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
32034 static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
32035 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
32036 static swig_type_info _swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type = {"_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type", "Hex::Edge *|std::vector<Hex::Edge * >::value_type", 0, 0, (void*)0, 0};
32037 static swig_type_info _swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type = {"_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type", "Hex::Hexa *|std::vector<Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
32038 static swig_type_info _swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type = {"_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type", "Hex::NewShape *|std::vector<Hex::NewShape * >::value_type", 0, 0, (void*)0, 0};
32039 static swig_type_info _swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type = {"_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type", "Hex::Quad *|std::vector<Hex::Quad * >::value_type", 0, 0, (void*)0, 0};
32040 static swig_type_info _swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type = {"_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type", "Hex::Vertex *|std::vector<Hex::Vertex * >::value_type", 0, 0, (void*)0, 0};
32042 static swig_type_info *swig_type_initial[] = {
32044 &_swigt__p_Hex__BiCylinder,
32045 &_swigt__p_Hex__Document,
32046 &_swigt__p_Hex__Edge,
32047 &_swigt__p_Hex__Elements,
32048 &_swigt__p_Hex__EltBase,
32049 &_swigt__p_Hex__Group,
32050 &_swigt__p_Hex__Hex,
32051 &_swigt__p_Hex__Hex__EltBase,
32052 &_swigt__p_Hex__Hexa,
32053 &_swigt__p_Hex__Law,
32054 &_swigt__p_Hex__NewShape,
32055 &_swigt__p_Hex__Propagation,
32056 &_swigt__p_Hex__Quad,
32057 &_swigt__p_Hex__Shape,
32058 &_swigt__p_Hex__Vector,
32059 &_swigt__p_Hex__Vertex,
32060 &_swigt__p_Hex__XmlWriter,
32061 &_swigt__p_a_Hex__DIM3__double,
32062 &_swigt__p_allocator_type,
32064 &_swigt__p_const_reference,
32065 &_swigt__p_difference_type,
32068 &_swigt__p_p_PyObject,
32069 &_swigt__p_reference,
32070 &_swigt__p_size_type,
32071 &_swigt__p_std__invalid_argument,
32072 &_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32073 &_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32074 &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32075 &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32076 &_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32077 &_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32078 &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32079 &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32080 &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32081 &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32082 &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32083 &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32084 &_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32085 &_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32086 &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32087 &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32088 &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32089 &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32090 &_swigt__p_std__vectorTint_std__allocatorTint_t_t,
32091 &_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32092 &_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32094 &_swigt__p_swig__PySwigIterator,
32095 &_swigt__p_value_type,
32096 &_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32097 &_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32098 &_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32099 &_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32100 &_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32103 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
32104 static swig_cast_info _swigc__p_Hex__BiCylinder[] = { {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
32105 static swig_cast_info _swigc__p_Hex__Document[] = { {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
32106 static swig_cast_info _swigc__p_Hex__Edge[] = { {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32107 static swig_cast_info _swigc__p_Hex__Elements[] = { {&_swigt__p_Hex__Elements, 0, 0, 0}, {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__Elements, 0, 0},{0, 0, 0, 0}};
32108 static swig_cast_info _swigc__p_Hex__EltBase[] = { {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Elements, _p_Hex__ElementsTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
32109 static swig_cast_info _swigc__p_Hex__Group[] = { {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
32110 static swig_cast_info _swigc__p_Hex__Hex[] = { {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
32111 static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = { {&_swigt__p_Hex__Group, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Elements, 0, 0, 0}, {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0}, {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Propagation, 0, 0, 0}, {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, 0, 0, 0}, {&_swigt__p_Hex__BiCylinder, 0, 0, 0}, {&_swigt__p_Hex__Document, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32112 static swig_cast_info _swigc__p_Hex__Hexa[] = { {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
32113 static swig_cast_info _swigc__p_Hex__Law[] = { {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
32114 static swig_cast_info _swigc__p_Hex__NewShape[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
32115 static swig_cast_info _swigc__p_Hex__Propagation[] = { {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
32116 static swig_cast_info _swigc__p_Hex__Quad[] = { {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
32117 static swig_cast_info _swigc__p_Hex__Shape[] = { {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
32118 static swig_cast_info _swigc__p_Hex__Vector[] = { {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
32119 static swig_cast_info _swigc__p_Hex__Vertex[] = { {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
32120 static swig_cast_info _swigc__p_Hex__XmlWriter[] = { {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
32121 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = { {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
32122 static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32123 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
32124 static swig_cast_info _swigc__p_const_reference[] = { {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
32125 static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
32126 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
32127 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
32128 static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
32129 static swig_cast_info _swigc__p_reference[] = { {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
32130 static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
32131 static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
32132 static swig_cast_info _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t[] = { {&_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32133 static swig_cast_info _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32134 static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t[] = { {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32135 static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32136 static swig_cast_info _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t[] = { {&_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32137 static swig_cast_info _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32138 static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t[] = { {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32139 static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32140 static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32141 static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32142 static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t[] = { {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32143 static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32144 static swig_cast_info _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t[] = { {&_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32145 static swig_cast_info _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32146 static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t[] = { {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32147 static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32148 static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t[] = { {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t, 0, 0, 0},{0, 0, 0, 0}};
32149 static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type[] = { {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32150 static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t[] = { {&_swigt__p_std__vectorTint_std__allocatorTint_t_t, 0, 0, 0},{0, 0, 0, 0}};
32151 static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type[] = { {&_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32152 static swig_cast_info _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t[] = { {&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
32153 static swig_cast_info _swigc__p_string[] = { {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
32154 static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
32155 static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
32156 static swig_cast_info _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32157 static swig_cast_info _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
32158 static swig_cast_info _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
32159 static swig_cast_info _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
32160 static swig_cast_info _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
32162 static swig_cast_info *swig_cast_initial[] = {
32164 _swigc__p_Hex__BiCylinder,
32165 _swigc__p_Hex__Document,
32166 _swigc__p_Hex__Edge,
32167 _swigc__p_Hex__Elements,
32168 _swigc__p_Hex__EltBase,
32169 _swigc__p_Hex__Group,
32170 _swigc__p_Hex__Hex,
32171 _swigc__p_Hex__Hex__EltBase,
32172 _swigc__p_Hex__Hexa,
32173 _swigc__p_Hex__Law,
32174 _swigc__p_Hex__NewShape,
32175 _swigc__p_Hex__Propagation,
32176 _swigc__p_Hex__Quad,
32177 _swigc__p_Hex__Shape,
32178 _swigc__p_Hex__Vector,
32179 _swigc__p_Hex__Vertex,
32180 _swigc__p_Hex__XmlWriter,
32181 _swigc__p_a_Hex__DIM3__double,
32182 _swigc__p_allocator_type,
32184 _swigc__p_const_reference,
32185 _swigc__p_difference_type,
32188 _swigc__p_p_PyObject,
32189 _swigc__p_reference,
32190 _swigc__p_size_type,
32191 _swigc__p_std__invalid_argument,
32192 _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32193 _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32194 _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32195 _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32196 _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32197 _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32198 _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32199 _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32200 _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32201 _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32202 _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32203 _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32204 _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32205 _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32206 _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32207 _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32208 _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32209 _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32210 _swigc__p_std__vectorTint_std__allocatorTint_t_t,
32211 _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32212 _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32214 _swigc__p_swig__PySwigIterator,
32215 _swigc__p_value_type,
32216 _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32217 _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32218 _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32219 _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32220 _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32224 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32226 static swig_const_info swig_const_table[] = {
32227 {0, 0, 0, 0.0, 0, 0}};
32232 /* -----------------------------------------------------------------------------
32233 * Type initialization:
32234 * This problem is tough by the requirement that no dynamic
32235 * memory is used. Also, since swig_type_info structures store pointers to
32236 * swig_cast_info structures and swig_cast_info structures store pointers back
32237 * to swig_type_info structures, we need some lookup code at initialization.
32238 * The idea is that swig generates all the structures that are needed.
32239 * The runtime then collects these partially filled structures.
32240 * The SWIG_InitializeModule function takes these initial arrays out of
32241 * swig_module, and does all the lookup, filling in the swig_module.types
32242 * array with the correct data and linking the correct swig_cast_info
32243 * structures together.
32245 * The generated swig_type_info structures are assigned staticly to an initial
32246 * array. We just loop through that array, and handle each type individually.
32247 * First we lookup if this type has been already loaded, and if so, use the
32248 * loaded structure instead of the generated one. Then we have to fill in the
32249 * cast linked list. The cast data is initially stored in something like a
32250 * two-dimensional array. Each row corresponds to a type (there are the same
32251 * number of rows as there are in the swig_type_initial array). Each entry in
32252 * a column is one of the swig_cast_info structures for that type.
32253 * The cast_initial array is actually an array of arrays, because each row has
32254 * a variable number of columns. So to actually build the cast linked list,
32255 * we find the array of casts associated with the type, and loop through it
32256 * adding the casts to the list. The one last trick we need to do is making
32257 * sure the type pointer in the swig_cast_info struct is correct.
32259 * First off, we lookup the cast->type name to see if it is already loaded.
32260 * There are three cases to handle:
32261 * 1) If the cast->type has already been loaded AND the type we are adding
32262 * casting info to has not been loaded (it is in this module), THEN we
32263 * replace the cast->type pointer with the type pointer that has already
32265 * 2) If BOTH types (the one we are adding casting info to, and the
32266 * cast->type) are loaded, THEN the cast info has already been loaded by
32267 * the previous module so we just ignore it.
32268 * 3) Finally, if cast->type has not already been loaded, then we add that
32269 * swig_cast_info to the linked list (because the cast->type) pointer will
32271 * ----------------------------------------------------------------------------- */
32281 #define SWIGRUNTIME_DEBUG
32286 SWIG_InitializeModule(void *clientdata) {
32288 swig_module_info *module_head, *iter;
32291 clientdata = clientdata;
32293 /* check to see if the circular list has been setup, if not, set it up */
32294 if (swig_module.next==0) {
32295 /* Initialize the swig_module */
32296 swig_module.type_initial = swig_type_initial;
32297 swig_module.cast_initial = swig_cast_initial;
32298 swig_module.next = &swig_module;
32301 /* Try and load any already created modules */
32302 module_head = SWIG_GetModule(clientdata);
32303 if (!module_head) {
32304 /* This is the first module loaded for this interpreter */
32305 /* so set the swig module into the interpreter */
32306 SWIG_SetModule(clientdata, &swig_module);
32307 module_head = &swig_module;
32309 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
32313 if (iter==&swig_module) {
32318 } while (iter!= module_head);
32320 /* if the is found in the list, then all is done and we may leave */
32322 /* otherwise we must add out module into the list */
32323 swig_module.next = module_head->next;
32324 module_head->next = &swig_module;
32327 /* Now work on filling in swig_module.types */
32328 #ifdef SWIGRUNTIME_DEBUG
32329 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32331 for (i = 0; i < swig_module.size; ++i) {
32332 swig_type_info *type = 0;
32333 swig_type_info *ret;
32334 swig_cast_info *cast;
32336 #ifdef SWIGRUNTIME_DEBUG
32337 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32340 /* if there is another module already loaded */
32341 if (swig_module.next != &swig_module) {
32342 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
32345 /* Overwrite clientdata field */
32346 #ifdef SWIGRUNTIME_DEBUG
32347 printf("SWIG_InitializeModule: found type %s\n", type->name);
32349 if (swig_module.type_initial[i]->clientdata) {
32350 type->clientdata = swig_module.type_initial[i]->clientdata;
32351 #ifdef SWIGRUNTIME_DEBUG
32352 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32356 type = swig_module.type_initial[i];
32359 /* Insert casting types */
32360 cast = swig_module.cast_initial[i];
32361 while (cast->type) {
32362 /* Don't need to add information already in the list */
32364 #ifdef SWIGRUNTIME_DEBUG
32365 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32367 if (swig_module.next != &swig_module) {
32368 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32369 #ifdef SWIGRUNTIME_DEBUG
32370 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32374 if (type == swig_module.type_initial[i]) {
32375 #ifdef SWIGRUNTIME_DEBUG
32376 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32381 /* Check for casting already in the list */
32382 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32383 #ifdef SWIGRUNTIME_DEBUG
32384 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32386 if (!ocast) ret = 0;
32391 #ifdef SWIGRUNTIME_DEBUG
32392 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32395 type->cast->prev = cast;
32396 cast->next = type->cast;
32402 /* Set entry in modules->types array equal to the type */
32403 swig_module.types[i] = type;
32405 swig_module.types[i] = 0;
32407 #ifdef SWIGRUNTIME_DEBUG
32408 printf("**** SWIG_InitializeModule: Cast List ******\n");
32409 for (i = 0; i < swig_module.size; ++i) {
32411 swig_cast_info *cast = swig_module.cast_initial[i];
32412 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32413 while (cast->type) {
32414 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
32418 printf("---- Total casts: %d\n",j);
32420 printf("**** SWIG_InitializeModule: Cast List ******\n");
32424 /* This function will propagate the clientdata field of type to
32425 * any new swig_type_info structures that have been added into the list
32426 * of equivalent types. It is like calling
32427 * SWIG_TypeClientData(type, clientdata) a second time.
32430 SWIG_PropagateClientData(void) {
32432 swig_cast_info *equiv;
32433 static int init_run = 0;
32435 if (init_run) return;
32438 for (i = 0; i < swig_module.size; i++) {
32439 if (swig_module.types[i]->clientdata) {
32440 equiv = swig_module.types[i]->cast;
32442 if (!equiv->converter) {
32443 if (equiv->type && !equiv->type->clientdata)
32444 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32446 equiv = equiv->next;
32466 /* Python-specific SWIG API */
32467 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32468 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32469 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32471 /* -----------------------------------------------------------------------------
32472 * global variable support code.
32473 * ----------------------------------------------------------------------------- */
32475 typedef struct swig_globalvar {
32476 char *name; /* Name of global variable */
32477 PyObject *(*get_attr)(void); /* Return the current value */
32478 int (*set_attr)(PyObject *); /* Set the value */
32479 struct swig_globalvar *next;
32482 typedef struct swig_varlinkobject {
32484 swig_globalvar *vars;
32485 } swig_varlinkobject;
32487 SWIGINTERN PyObject *
32488 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
32489 return PyString_FromString("<Swig global variables>");
32492 SWIGINTERN PyObject *
32493 swig_varlink_str(swig_varlinkobject *v) {
32494 PyObject *str = PyString_FromString("(");
32495 swig_globalvar *var;
32496 for (var = v->vars; var; var=var->next) {
32497 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
32498 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
32500 PyString_ConcatAndDel(&str,PyString_FromString(")"));
32505 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
32506 PyObject *str = swig_varlink_str(v);
32507 fprintf(fp,"Swig global variables ");
32508 fprintf(fp,"%s\n", PyString_AsString(str));
32514 swig_varlink_dealloc(swig_varlinkobject *v) {
32515 swig_globalvar *var = v->vars;
32517 swig_globalvar *n = var->next;
32524 SWIGINTERN PyObject *
32525 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32526 PyObject *res = NULL;
32527 swig_globalvar *var = v->vars;
32529 if (strcmp(var->name,n) == 0) {
32530 res = (*var->get_attr)();
32535 if (res == NULL && !PyErr_Occurred()) {
32536 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32542 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32544 swig_globalvar *var = v->vars;
32546 if (strcmp(var->name,n) == 0) {
32547 res = (*var->set_attr)(p);
32552 if (res == 1 && !PyErr_Occurred()) {
32553 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32558 SWIGINTERN PyTypeObject*
32559 swig_varlink_type(void) {
32560 static char varlink__doc__[] = "Swig var link object";
32561 static PyTypeObject varlink_type;
32562 static int type_init = 0;
32564 const PyTypeObject tmp
32566 PyObject_HEAD_INIT(NULL)
32567 0, /* Number of items in variable part (ob_size) */
32568 (char *)"swigvarlink", /* Type name (tp_name) */
32569 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32570 0, /* Itemsize (tp_itemsize) */
32571 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
32572 (printfunc) swig_varlink_print, /* Print (tp_print) */
32573 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32574 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32575 0, /* tp_compare */
32576 (reprfunc) swig_varlink_repr, /* tp_repr */
32577 0, /* tp_as_number */
32578 0, /* tp_as_sequence */
32579 0, /* tp_as_mapping */
32582 (reprfunc)swig_varlink_str, /* tp_str */
32583 0, /* tp_getattro */
32584 0, /* tp_setattro */
32585 0, /* tp_as_buffer */
32587 varlink__doc__, /* tp_doc */
32588 0, /* tp_traverse */
32590 0, /* tp_richcompare */
32591 0, /* tp_weaklistoffset */
32592 #if PY_VERSION_HEX >= 0x02020000
32593 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32595 #if PY_VERSION_HEX >= 0x02030000
32598 #ifdef COUNT_ALLOCS
32599 0,0,0,0 /* tp_alloc -> tp_next */
32602 varlink_type = tmp;
32603 varlink_type.ob_type = &PyType_Type;
32606 return &varlink_type;
32609 /* Create a variable linking object for use later */
32610 SWIGINTERN PyObject *
32611 SWIG_Python_newvarlink(void) {
32612 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
32616 return ((PyObject*) result);
32620 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32621 swig_varlinkobject *v = (swig_varlinkobject *) p;
32622 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32624 size_t size = strlen(name)+1;
32625 gv->name = (char *)malloc(size);
32627 strncpy(gv->name,name,size);
32628 gv->get_attr = get_attr;
32629 gv->set_attr = set_attr;
32630 gv->next = v->vars;
32636 SWIGINTERN PyObject *
32637 SWIG_globals(void) {
32638 static PyObject *_SWIG_globals = 0;
32639 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
32640 return _SWIG_globals;
32643 /* -----------------------------------------------------------------------------
32644 * constants/methods manipulation
32645 * ----------------------------------------------------------------------------- */
32647 /* Install Constants */
32649 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32652 for (i = 0; constants[i].type; ++i) {
32653 switch(constants[i].type) {
32654 case SWIG_PY_POINTER:
32655 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32657 case SWIG_PY_BINARY:
32658 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32665 PyDict_SetItemString(d, constants[i].name, obj);
32671 /* -----------------------------------------------------------------------------*/
32672 /* Fix SwigMethods to carry the callback ptrs when needed */
32673 /* -----------------------------------------------------------------------------*/
32676 SWIG_Python_FixMethods(PyMethodDef *methods,
32677 swig_const_info *const_table,
32678 swig_type_info **types,
32679 swig_type_info **types_initial) {
32681 for (i = 0; methods[i].ml_name; ++i) {
32682 const char *c = methods[i].ml_doc;
32683 if (c && (c = strstr(c, "swig_ptr: "))) {
32685 swig_const_info *ci = 0;
32686 const char *name = c + 10;
32687 for (j = 0; const_table[j].type; ++j) {
32688 if (strncmp(const_table[j].name, name,
32689 strlen(const_table[j].name)) == 0) {
32690 ci = &(const_table[j]);
32695 size_t shift = (ci->ptype) - types;
32696 swig_type_info *ty = types_initial[shift];
32697 size_t ldoc = (c - methods[i].ml_doc);
32698 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32699 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32702 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
32704 strncpy(buff, methods[i].ml_doc, ldoc);
32706 strncpy(buff, "swig_ptr: ", 10);
32708 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32709 methods[i].ml_doc = ndoc;
32721 /* -----------------------------------------------------------------------------*
32722 * Partial Init method
32723 * -----------------------------------------------------------------------------*/
32728 SWIGEXPORT void SWIG_init(void) {
32731 /* Fix SwigMethods to carry the callback ptrs when needed */
32732 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
32734 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32735 d = PyModule_GetDict(m);
32737 SWIG_InitializeModule(0);
32738 SWIG_InstallConstants(d,swig_const_table);
32741 SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
32742 SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
32743 SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
32744 SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
32745 SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
32746 SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
32747 SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
32748 SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
32749 SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
32750 SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
32751 SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
32752 SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
32753 SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
32754 SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
32755 SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
32756 SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
32757 SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
32758 SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
32759 SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
32760 SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
32761 SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
32762 SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
32763 SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
32764 SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
32765 SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
32766 SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
32767 SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
32768 SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
32769 SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
32770 SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
32771 SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
32772 SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
32773 SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
32774 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
32775 SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",ABR_TYPES_get, ABR_TYPES_set);
32776 SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
32777 SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
32778 SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
32779 SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
32780 SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
32781 SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
32782 SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
32783 SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
32784 SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
32785 SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
32786 SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
32787 SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
32788 SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
32789 SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
32790 SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
32791 SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
32792 SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
32793 SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
32794 SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
32795 SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
32796 SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
32797 SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
32798 SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
32799 SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
32800 SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
32801 SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
32802 SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
32803 SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
32804 SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
32805 SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
32806 SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
32807 SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
32808 SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
32809 SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
32810 SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
32811 SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
32812 SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
32813 SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
32814 SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
32815 SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
32816 SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
32817 SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
32818 SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
32819 SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
32820 SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
32821 SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
32822 SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
32823 SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
32824 SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
32825 SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
32826 SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
32827 SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
32828 SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
32829 SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
32830 SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
32831 SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
32832 SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
32833 SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
32834 SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
32835 SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
32836 SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
32837 SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
32838 SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
32839 SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
32840 SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
32841 SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
32842 SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
32843 SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
32844 SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
32845 SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
32846 SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
32847 SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
32848 SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
32849 SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
32850 SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
32851 SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
32852 SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
32853 SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
32854 SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
32855 SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
32856 SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
32857 SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
32858 SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
32859 SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
32860 SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
32861 SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
32862 SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
32863 SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
32864 SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
32865 SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
32866 SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
32867 SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
32868 SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
32869 SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
32870 SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
32871 SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
32872 SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
32873 SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
32874 SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
32875 SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
32876 SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
32877 SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
32878 SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
32879 SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
32880 SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
32881 SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
32882 SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
32883 SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
32884 SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Epsil_get, Epsil_set);
32885 SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",UnEpsil_get, UnEpsil_set);
32886 SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Epsil2_get, Epsil2_set);