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 * ----------------------------------------------------------------------------- */
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22 struct SwigMovePointer {
24 SwigMovePointer(T *p) : ptr(p) { }
25 ~SwigMovePointer() { delete ptr; }
26 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
28 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
31 SwigValueWrapper() : pointer(0) { }
32 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33 operator T&() const { return *pointer.ptr; }
34 T *operator&() { return pointer.ptr; }
37 template <typename T> T SwigValueInit() {
42 /* -----------------------------------------------------------------------------
43 * This section contains generic SWIG labels for method/variable
44 * declarations/attributes, and other compiler dependent labels.
45 * ----------------------------------------------------------------------------- */
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
56 # define SWIGTEMPLATEDISAMBIGUATOR
60 /* inline attribute */
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
78 # define SWIGUNUSED __attribute__ ((__unused__))
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
90 #ifndef SWIGUNUSEDPARM
92 # define SWIGUNUSEDPARM(p)
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
98 /* internal SWIG method */
100 # define SWIGINTERN static SWIGUNUSED
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
108 /* exporting methods */
109 #if defined(__GNUC__)
110 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
111 # ifndef GCC_HASCLASSVISIBILITY
112 # define GCC_HASCLASSVISIBILITY
118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
119 # if defined(STATIC_LINKED)
122 # define SWIGEXPORT __declspec(dllexport)
125 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
126 # define SWIGEXPORT __attribute__ ((visibility("default")))
133 /* calling conventions for Windows */
135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
136 # define SWIGSTDCALL __stdcall
142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
144 # define _CRT_SECURE_NO_DEPRECATE
147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
149 # define _SCL_SECURE_NO_DEPRECATE
152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
157 /* Intel's compiler complains if a variable which was never initialised is
158 * cast to void, which is a common idiom which we use to indicate that we
159 * are aware a variable isn't used. So we just silence that warning.
160 * See: https://github.com/swig/swig/issues/192 for more discussion.
162 #ifdef __INTEL_COMPILER
163 # pragma warning disable 592
167 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
168 /* Use debug wrappers with the Python release dll */
176 /* -----------------------------------------------------------------------------
179 * This file contains generic C API SWIG runtime support for pointer
181 * ----------------------------------------------------------------------------- */
183 /* This should only be incremented when either the layout of swig_type_info changes,
184 or for whatever reason, the runtime changes incompatibly */
185 #define SWIG_RUNTIME_VERSION "4"
187 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
188 #ifdef SWIG_TYPE_TABLE
189 # define SWIG_QUOTE_STRING(x) #x
190 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
191 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
193 # define SWIG_TYPE_TABLE_NAME
197 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
198 creating a static or dynamic library from the SWIG runtime code.
199 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
201 But only do this if strictly necessary, ie, if you have problems
202 with your compiler or suchlike.
206 # define SWIGRUNTIME SWIGINTERN
209 #ifndef SWIGRUNTIMEINLINE
210 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
213 /* Generic buffer size */
214 #ifndef SWIG_BUFFER_SIZE
215 # define SWIG_BUFFER_SIZE 1024
218 /* Flags for pointer conversions */
219 #define SWIG_POINTER_DISOWN 0x1
220 #define SWIG_CAST_NEW_MEMORY 0x2
222 /* Flags for new pointer objects */
223 #define SWIG_POINTER_OWN 0x1
227 Flags/methods for returning states.
229 The SWIG conversion methods, as ConvertPtr, return an integer
230 that tells if the conversion was successful or not. And if not,
231 an error code can be returned (see swigerrors.swg for the codes).
233 Use the following macros/flags to set or process the returning
236 In old versions of SWIG, code such as the following was usually written:
238 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
244 Now you can be more explicit:
246 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
247 if (SWIG_IsOK(res)) {
253 which is the same really, but now you can also do
256 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
257 if (SWIG_IsOK(res)) {
259 if (SWIG_IsNewObj(res) {
269 I.e., now SWIG_ConvertPtr can return new objects and you can
270 identify the case and take care of the deallocation. Of course that
271 also requires SWIG_ConvertPtr to return new result values, such as
273 int SWIG_ConvertPtr(obj, ptr,...) {
275 if (<need new object>) {
276 *ptr = <ptr to new allocated object>;
279 *ptr = <ptr to old object>;
287 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
288 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
291 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
292 allows to return the 'cast rank', for example, if you have this
299 food(1) // cast rank '1' (1 -> 1.0)
300 fooi(1) // cast rank '0'
302 just use the SWIG_AddCast()/SWIG_CheckState()
306 #define SWIG_ERROR (-1)
307 #define SWIG_IsOK(r) (r >= 0)
308 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
310 /* The CastRankLimit says how many bits are used for the cast rank */
311 #define SWIG_CASTRANKLIMIT (1 << 8)
312 /* The NewMask denotes the object was created (using new/malloc) */
313 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
314 /* The TmpMask is for in/out typemaps that use temporal objects */
315 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
316 /* Simple returning values */
317 #define SWIG_BADOBJ (SWIG_ERROR)
318 #define SWIG_OLDOBJ (SWIG_OK)
319 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
320 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
321 /* Check, add and del mask methods */
322 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
323 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
324 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
325 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
326 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
327 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
330 #if defined(SWIG_CASTRANK_MODE)
331 # ifndef SWIG_TypeRank
332 # define SWIG_TypeRank unsigned long
334 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
335 # define SWIG_MAXCASTRANK (2)
337 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
338 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
339 SWIGINTERNINLINE int SWIG_AddCast(int r) {
340 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
342 SWIGINTERNINLINE int SWIG_CheckState(int r) {
343 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
345 #else /* no cast-rank mode */
346 # define SWIG_AddCast(r) (r)
347 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
357 typedef void *(*swig_converter_func)(void *, int *);
358 typedef struct swig_type_info *(*swig_dycast_func)(void **);
360 /* Structure to store information on one type */
361 typedef struct swig_type_info {
362 const char *name; /* mangled name of this type */
363 const char *str; /* human readable name of this type */
364 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
365 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
366 void *clientdata; /* language specific type data */
367 int owndata; /* flag if the structure owns the clientdata */
370 /* Structure to store a type and conversion function used for casting */
371 typedef struct swig_cast_info {
372 swig_type_info *type; /* pointer to type that is equivalent to this type */
373 swig_converter_func converter; /* function to cast the void pointers */
374 struct swig_cast_info *next; /* pointer to next cast in linked list */
375 struct swig_cast_info *prev; /* pointer to the previous cast */
378 /* Structure used to store module information
379 * Each module generates one structure like this, and the runtime collects
380 * all of these structures and stores them in a circularly linked list.*/
381 typedef struct swig_module_info {
382 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
383 size_t size; /* Number of types in this module */
384 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
385 swig_type_info **type_initial; /* Array of initially generated type structures */
386 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
387 void *clientdata; /* Language specific module data */
391 Compare two type names skipping the space characters, therefore
392 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
394 Return 0 when the two name types are equivalent, as in
395 strncmp, but skipping ' '.
398 SWIG_TypeNameComp(const char *f1, const char *l1,
399 const char *f2, const char *l2) {
400 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
401 while ((*f1 == ' ') && (f1 != l1)) ++f1;
402 while ((*f2 == ' ') && (f2 != l2)) ++f2;
403 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
405 return (int)((l1 - f1) - (l2 - f2));
409 Check type equivalence in a name list like <name1>|<name2>|...
410 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
413 SWIG_TypeCmp(const char *nb, const char *tb) {
415 const char* te = tb + strlen(tb);
417 while (equiv != 0 && *ne) {
418 for (nb = ne; *ne; ++ne) {
419 if (*ne == '|') break;
421 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
428 Check type equivalence in a name list like <name1>|<name2>|...
429 Return 0 if not equal, 1 if equal
432 SWIG_TypeEquiv(const char *nb, const char *tb) {
433 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
439 SWIGRUNTIME swig_cast_info *
440 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
442 swig_cast_info *iter = ty->cast;
444 if (strcmp(iter->type->name, c) == 0) {
445 if (iter == ty->cast)
447 /* Move iter to the top of the linked list */
448 iter->prev->next = iter->next;
450 iter->next->prev = iter->prev;
451 iter->next = ty->cast;
453 if (ty->cast) ty->cast->prev = iter;
464 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
466 SWIGRUNTIME swig_cast_info *
467 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
469 swig_cast_info *iter = ty->cast;
471 if (iter->type == from) {
472 if (iter == ty->cast)
474 /* Move iter to the top of the linked list */
475 iter->prev->next = iter->next;
477 iter->next->prev = iter->prev;
478 iter->next = ty->cast;
480 if (ty->cast) ty->cast->prev = iter;
491 Cast a pointer up an inheritance hierarchy
493 SWIGRUNTIMEINLINE void *
494 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
495 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
499 Dynamic pointer casting. Down an inheritance hierarchy
501 SWIGRUNTIME swig_type_info *
502 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
503 swig_type_info *lastty = ty;
504 if (!ty || !ty->dcast) return ty;
505 while (ty && (ty->dcast)) {
506 ty = (*ty->dcast)(ptr);
513 Return the name associated with this type
515 SWIGRUNTIMEINLINE const char *
516 SWIG_TypeName(const swig_type_info *ty) {
521 Return the pretty name associated with this type,
522 that is an unmangled type name in a form presentable to the user.
524 SWIGRUNTIME const char *
525 SWIG_TypePrettyName(const swig_type_info *type) {
526 /* The "str" field contains the equivalent pretty names of the
527 type, separated by vertical-bar characters. We choose
528 to print the last name, as it is often (?) the most
530 if (!type) return NULL;
531 if (type->str != NULL) {
532 const char *last_name = type->str;
534 for (s = type->str; *s; s++)
535 if (*s == '|') last_name = s+1;
543 Set the clientdata field for a type
546 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
547 swig_cast_info *cast = ti->cast;
548 /* if (ti->clientdata == clientdata) return; */
549 ti->clientdata = clientdata;
552 if (!cast->converter) {
553 swig_type_info *tc = cast->type;
554 if (!tc->clientdata) {
555 SWIG_TypeClientData(tc, clientdata);
562 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
563 SWIG_TypeClientData(ti, clientdata);
568 Search for a swig_type_info structure only by mangled name
569 Search is a O(log #types)
571 We start searching at module start, and finish searching when start == end.
572 Note: if start == end at the beginning of the function, we go all the way around
575 SWIGRUNTIME swig_type_info *
576 SWIG_MangledTypeQueryModule(swig_module_info *start,
577 swig_module_info *end,
579 swig_module_info *iter = start;
583 size_t r = iter->size - 1;
585 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
586 size_t i = (l + r) >> 1;
587 const char *iname = iter->types[i]->name;
589 int compare = strcmp(name, iname);
591 return iter->types[i];
592 } else if (compare < 0) {
598 } else if (compare > 0) {
602 break; /* should never happen */
607 } while (iter != end);
612 Search for a swig_type_info structure for either a mangled name or a human readable name.
613 It first searches the mangled names of the types, which is a O(log #types)
614 If a type is not found it then searches the human readable names, which is O(#types).
616 We start searching at module start, and finish searching when start == end.
617 Note: if start == end at the beginning of the function, we go all the way around
620 SWIGRUNTIME swig_type_info *
621 SWIG_TypeQueryModule(swig_module_info *start,
622 swig_module_info *end,
624 /* STEP 1: Search the name field using binary search */
625 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
629 /* STEP 2: If the type hasn't been found, do a complete search
630 of the str field (the human readable name) */
631 swig_module_info *iter = start;
634 for (; i < iter->size; ++i) {
635 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
636 return iter->types[i];
639 } while (iter != end);
642 /* neither found a match */
647 Pack binary data into a string
650 SWIG_PackData(char *c, void *ptr, size_t sz) {
651 static const char hex[17] = "0123456789abcdef";
652 const unsigned char *u = (unsigned char *) ptr;
653 const unsigned char *eu = u + sz;
654 for (; u != eu; ++u) {
655 unsigned char uu = *u;
656 *(c++) = hex[(uu & 0xf0) >> 4];
657 *(c++) = hex[uu & 0xf];
663 Unpack binary data from a string
665 SWIGRUNTIME const char *
666 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
667 unsigned char *u = (unsigned char *) ptr;
668 const unsigned char *eu = u + sz;
669 for (; u != eu; ++u) {
672 if ((d >= '0') && (d <= '9'))
673 uu = (unsigned char)((d - '0') << 4);
674 else if ((d >= 'a') && (d <= 'f'))
675 uu = (unsigned char)((d - ('a'-10)) << 4);
679 if ((d >= '0') && (d <= '9'))
680 uu |= (unsigned char)(d - '0');
681 else if ((d >= 'a') && (d <= 'f'))
682 uu |= (unsigned char)(d - ('a'-10));
691 Pack 'void *' into a string buffer.
694 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
696 if ((2*sizeof(void *) + 2) > bsz) return 0;
698 r = SWIG_PackData(r,&ptr,sizeof(void *));
699 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
704 SWIGRUNTIME const char *
705 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
707 if (strcmp(c,"NULL") == 0) {
714 return SWIG_UnpackData(++c,ptr,sizeof(void *));
718 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
720 size_t lname = (name ? strlen(name) : 0);
721 if ((2*sz + 2 + lname) > bsz) return 0;
723 r = SWIG_PackData(r,ptr,sz);
725 strncpy(r,name,lname+1);
732 SWIGRUNTIME const char *
733 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
735 if (strcmp(c,"NULL") == 0) {
742 return SWIG_UnpackData(++c,ptr,sz);
750 #define SWIG_UnknownError -1
751 #define SWIG_IOError -2
752 #define SWIG_RuntimeError -3
753 #define SWIG_IndexError -4
754 #define SWIG_TypeError -5
755 #define SWIG_DivisionByZero -6
756 #define SWIG_OverflowError -7
757 #define SWIG_SyntaxError -8
758 #define SWIG_ValueError -9
759 #define SWIG_SystemError -10
760 #define SWIG_AttributeError -11
761 #define SWIG_MemoryError -12
762 #define SWIG_NullReferenceError -13
766 /* Compatibility macros for Python 3 */
767 #if PY_VERSION_HEX >= 0x03000000
769 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
770 #define PyInt_Check(x) PyLong_Check(x)
771 #define PyInt_AsLong(x) PyLong_AsLong(x)
772 #define PyInt_FromLong(x) PyLong_FromLong(x)
773 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
774 #define PyString_Check(name) PyBytes_Check(name)
775 #define PyString_FromString(x) PyUnicode_FromString(x)
776 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
777 #define PyString_AsString(str) PyBytes_AsString(str)
778 #define PyString_Size(str) PyBytes_Size(str)
779 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
780 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
781 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
782 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
787 # define Py_TYPE(op) ((op)->ob_type)
790 /* SWIG APIs for compatibility of both Python 2 & 3 */
792 #if PY_VERSION_HEX >= 0x03000000
793 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
795 # define SWIG_Python_str_FromFormat PyString_FromFormat
799 /* Warning: This function will allocate a new string in Python 3,
800 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
803 SWIG_Python_str_AsChar(PyObject *str)
805 #if PY_VERSION_HEX >= 0x03000000
809 str = PyUnicode_AsUTF8String(str);
810 PyBytes_AsStringAndSize(str, &cstr, &len);
811 newstr = (char *) malloc(len+1);
812 memcpy(newstr, cstr, len+1);
816 return PyString_AsString(str);
820 #if PY_VERSION_HEX >= 0x03000000
821 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
823 # define SWIG_Python_str_DelForPy3(x)
828 SWIG_Python_str_FromChar(const char *c)
830 #if PY_VERSION_HEX >= 0x03000000
831 return PyUnicode_FromString(c);
833 return PyString_FromString(c);
837 /* Add PyOS_snprintf for old Pythons */
838 #if PY_VERSION_HEX < 0x02020000
839 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
840 # define PyOS_snprintf _snprintf
842 # define PyOS_snprintf snprintf
846 /* A crude PyString_FromFormat implementation for old Pythons */
847 #if PY_VERSION_HEX < 0x02020000
849 #ifndef SWIG_PYBUFFER_SIZE
850 # define SWIG_PYBUFFER_SIZE 1024
854 PyString_FromFormat(const char *fmt, ...) {
856 char buf[SWIG_PYBUFFER_SIZE * 2];
859 res = vsnprintf(buf, sizeof(buf), fmt, ap);
861 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
866 # define PyObject_DEL PyObject_Del
869 /* A crude PyExc_StopIteration exception for old Pythons */
870 #if PY_VERSION_HEX < 0x02020000
871 # ifndef PyExc_StopIteration
872 # define PyExc_StopIteration PyExc_RuntimeError
874 # ifndef PyObject_GenericGetAttr
875 # define PyObject_GenericGetAttr 0
879 /* Py_NotImplemented is defined in 2.1 and up. */
880 #if PY_VERSION_HEX < 0x02010000
881 # ifndef Py_NotImplemented
882 # define Py_NotImplemented PyExc_RuntimeError
886 /* A crude PyString_AsStringAndSize implementation for old Pythons */
887 #if PY_VERSION_HEX < 0x02010000
888 # ifndef PyString_AsStringAndSize
889 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
893 /* PySequence_Size for old Pythons */
894 #if PY_VERSION_HEX < 0x02000000
895 # ifndef PySequence_Size
896 # define PySequence_Size PySequence_Length
900 /* PyBool_FromLong for old Pythons */
901 #if PY_VERSION_HEX < 0x02030000
903 PyObject *PyBool_FromLong(long ok)
905 PyObject *result = ok ? Py_True : Py_False;
911 /* Py_ssize_t for old Pythons */
912 /* This code is as recommended by: */
913 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
914 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
915 typedef int Py_ssize_t;
916 # define PY_SSIZE_T_MAX INT_MAX
917 # define PY_SSIZE_T_MIN INT_MIN
918 typedef inquiry lenfunc;
919 typedef intargfunc ssizeargfunc;
920 typedef intintargfunc ssizessizeargfunc;
921 typedef intobjargproc ssizeobjargproc;
922 typedef intintobjargproc ssizessizeobjargproc;
923 typedef getreadbufferproc readbufferproc;
924 typedef getwritebufferproc writebufferproc;
925 typedef getsegcountproc segcountproc;
926 typedef getcharbufferproc charbufferproc;
927 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
930 PyObject *i = PyNumber_Int(x);
932 result = PyInt_AsLong(i);
939 #if PY_VERSION_HEX < 0x02050000
940 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
943 #if PY_VERSION_HEX < 0x02040000
944 #define Py_VISIT(op) \
947 int vret = visit((op), arg); \
954 #if PY_VERSION_HEX < 0x02030000
957 PyNumberMethods as_number;
958 PyMappingMethods as_mapping;
959 PySequenceMethods as_sequence;
960 PyBufferProcs as_buffer;
961 PyObject *name, *slots;
965 #if PY_VERSION_HEX < 0x02030000
966 typedef destructor freefunc;
969 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
970 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
971 (PY_MAJOR_VERSION > 3))
972 # define SWIGPY_USE_CAPSULE
973 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
976 #if PY_VERSION_HEX < 0x03020000
977 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
978 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
979 #define Py_hash_t long
982 /* -----------------------------------------------------------------------------
984 * ----------------------------------------------------------------------------- */
986 SWIGRUNTIME PyObject*
987 SWIG_Python_ErrorType(int code) {
990 case SWIG_MemoryError:
991 type = PyExc_MemoryError;
994 type = PyExc_IOError;
996 case SWIG_RuntimeError:
997 type = PyExc_RuntimeError;
999 case SWIG_IndexError:
1000 type = PyExc_IndexError;
1002 case SWIG_TypeError:
1003 type = PyExc_TypeError;
1005 case SWIG_DivisionByZero:
1006 type = PyExc_ZeroDivisionError;
1008 case SWIG_OverflowError:
1009 type = PyExc_OverflowError;
1011 case SWIG_SyntaxError:
1012 type = PyExc_SyntaxError;
1014 case SWIG_ValueError:
1015 type = PyExc_ValueError;
1017 case SWIG_SystemError:
1018 type = PyExc_SystemError;
1020 case SWIG_AttributeError:
1021 type = PyExc_AttributeError;
1024 type = PyExc_RuntimeError;
1031 SWIG_Python_AddErrorMsg(const char* mesg)
1034 PyObject *value = 0;
1035 PyObject *traceback = 0;
1037 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1040 PyObject *old_str = PyObject_Str(value);
1044 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1045 SWIG_Python_str_DelForPy3(tmp);
1049 PyErr_SetString(PyExc_RuntimeError, mesg);
1053 #if defined(SWIG_PYTHON_NO_THREADS)
1054 # if defined(SWIG_PYTHON_THREADS)
1055 # undef SWIG_PYTHON_THREADS
1058 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1059 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1060 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1061 # define SWIG_PYTHON_USE_GIL
1064 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1065 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1066 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1068 # ifdef __cplusplus /* C++ code */
1069 class SWIG_Python_Thread_Block {
1071 PyGILState_STATE state;
1073 void end() { if (status) { PyGILState_Release(state); status = false;} }
1074 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1075 ~SWIG_Python_Thread_Block() { end(); }
1077 class SWIG_Python_Thread_Allow {
1079 PyThreadState *save;
1081 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1082 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1083 ~SWIG_Python_Thread_Allow() { end(); }
1085 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1086 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1087 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1088 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1090 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1091 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1092 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1093 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1095 # else /* Old thread way, not implemented, user must provide it */
1096 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1097 # define SWIG_PYTHON_INITIALIZE_THREADS
1099 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1100 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1102 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1103 # define SWIG_PYTHON_THREAD_END_BLOCK
1105 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1106 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1108 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1109 # define SWIG_PYTHON_THREAD_END_ALLOW
1112 #else /* No thread support */
1113 # define SWIG_PYTHON_INITIALIZE_THREADS
1114 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1115 # define SWIG_PYTHON_THREAD_END_BLOCK
1116 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1117 # define SWIG_PYTHON_THREAD_END_ALLOW
1120 /* -----------------------------------------------------------------------------
1121 * Python API portion that goes into the runtime
1122 * ----------------------------------------------------------------------------- */
1128 /* -----------------------------------------------------------------------------
1129 * Constant declarations
1130 * ----------------------------------------------------------------------------- */
1132 /* Constant Types */
1133 #define SWIG_PY_POINTER 4
1134 #define SWIG_PY_BINARY 5
1136 /* Constant information structure */
1137 typedef struct swig_const_info {
1143 swig_type_info **ptype;
1147 /* -----------------------------------------------------------------------------
1148 * Wrapper of PyInstanceMethod_New() used in Python 3
1149 * It is exported to the generated module, used for -fastproxy
1150 * ----------------------------------------------------------------------------- */
1151 #if PY_VERSION_HEX >= 0x03000000
1152 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1154 return PyInstanceMethod_New(func);
1157 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1168 /* -----------------------------------------------------------------------------
1171 * This file contains the runtime support for Python modules
1172 * and includes code for managing global variables and pointer
1175 * ----------------------------------------------------------------------------- */
1177 /* Common SWIG API */
1179 /* for raw pointers */
1180 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1181 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1182 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1184 #ifdef SWIGPYTHON_BUILTIN
1185 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1187 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1190 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1192 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1193 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1194 #define swig_owntype int
1196 /* for raw packed data */
1197 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1198 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1200 /* for class or struct pointers */
1201 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1202 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1204 /* for C or C++ function pointers */
1205 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1206 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1208 /* for C++ member pointers, ie, member methods */
1209 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1210 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1215 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1216 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1217 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1219 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1220 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1221 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1222 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1223 #define SWIG_fail goto fail
1226 /* Runtime API implementation */
1228 /* Error manipulation */
1231 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1232 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1233 PyErr_SetObject(errtype, obj);
1235 SWIG_PYTHON_THREAD_END_BLOCK;
1239 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1240 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1241 PyErr_SetString(errtype, msg);
1242 SWIG_PYTHON_THREAD_END_BLOCK;
1245 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1247 /* Set a constant value */
1249 #if defined(SWIGPYTHON_BUILTIN)
1252 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1253 PyObject *s = PyString_InternFromString(key);
1254 PyList_Append(seq, s);
1259 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1260 #if PY_VERSION_HEX < 0x02030000
1261 PyDict_SetItemString(d, (char *)name, obj);
1263 PyDict_SetItemString(d, name, obj);
1266 if (public_interface)
1267 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1273 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1274 #if PY_VERSION_HEX < 0x02030000
1275 PyDict_SetItemString(d, (char *)name, obj);
1277 PyDict_SetItemString(d, name, obj);
1284 /* Append a value to the result obj */
1286 SWIGINTERN PyObject*
1287 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1288 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1291 } else if (result == Py_None) {
1295 if (!PyList_Check(result)) {
1296 PyObject *o2 = result;
1297 result = PyList_New(1);
1298 PyList_SetItem(result, 0, o2);
1300 PyList_Append(result,obj);
1309 } else if (result == Py_None) {
1313 if (!PyTuple_Check(result)) {
1315 result = PyTuple_New(1);
1316 PyTuple_SET_ITEM(result, 0, o2);
1318 o3 = PyTuple_New(1);
1319 PyTuple_SET_ITEM(o3, 0, obj);
1321 result = PySequence_Concat(o2, o3);
1329 /* Unpack the argument tuple */
1331 SWIGINTERN Py_ssize_t
1332 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1338 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1339 name, (min == max ? "" : "at least "), (int)min);
1343 if (!PyTuple_Check(args)) {
1344 if (min <= 1 && max >= 1) {
1347 for (i = 1; i < max; ++i) {
1352 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1355 Py_ssize_t l = PyTuple_GET_SIZE(args);
1357 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1358 name, (min == max ? "" : "at least "), (int)min, (int)l);
1360 } else if (l > max) {
1361 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1362 name, (min == max ? "" : "at most "), (int)max, (int)l);
1366 for (i = 0; i < l; ++i) {
1367 objs[i] = PyTuple_GET_ITEM(args, i);
1369 for (; l < max; ++l) {
1377 /* A functor is a function object with one single object argument */
1378 #if PY_VERSION_HEX >= 0x02020000
1379 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1381 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1385 Helper for static pointer initialization for both C and C++ code, for example
1386 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1389 #define SWIG_STATIC_POINTER(var) var
1391 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1394 /* -----------------------------------------------------------------------------
1395 * Pointer declarations
1396 * ----------------------------------------------------------------------------- */
1398 /* Flags for new pointer objects */
1399 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1400 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1402 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1404 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1405 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1411 /* How to access Py_None */
1412 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1413 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1414 # ifndef SWIG_PYTHON_BUILD_NONE
1415 # define SWIG_PYTHON_BUILD_NONE
1420 #ifdef SWIG_PYTHON_BUILD_NONE
1423 # define Py_None SWIG_Py_None()
1425 SWIGRUNTIMEINLINE PyObject *
1428 PyObject *none = Py_BuildValue((char*)"");
1432 SWIGRUNTIME PyObject *
1435 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1440 /* The python void return value */
1442 SWIGRUNTIMEINLINE PyObject *
1445 PyObject *none = Py_None;
1450 /* SwigPyClientData */
1459 PyTypeObject *pytype;
1462 SWIGRUNTIMEINLINE int
1463 SWIG_Python_CheckImplicit(swig_type_info *ty)
1465 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1466 return data ? data->implicitconv : 0;
1469 SWIGRUNTIMEINLINE PyObject *
1470 SWIG_Python_ExceptionType(swig_type_info *desc) {
1471 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1472 PyObject *klass = data ? data->klass : 0;
1473 return (klass ? klass : PyExc_RuntimeError);
1477 SWIGRUNTIME SwigPyClientData *
1478 SwigPyClientData_New(PyObject* obj)
1483 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1484 /* the klass element */
1486 Py_INCREF(data->klass);
1487 /* the newraw method and newargs arguments used to create a new raw instance */
1488 if (PyClass_Check(obj)) {
1490 data->newargs = obj;
1493 #if (PY_VERSION_HEX < 0x02020000)
1496 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1499 Py_INCREF(data->newraw);
1500 data->newargs = PyTuple_New(1);
1501 PyTuple_SetItem(data->newargs, 0, obj);
1503 data->newargs = obj;
1505 Py_INCREF(data->newargs);
1507 /* the destroy method, aka as the C++ delete method */
1508 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1509 if (PyErr_Occurred()) {
1513 if (data->destroy) {
1515 Py_INCREF(data->destroy);
1516 flags = PyCFunction_GET_FLAGS(data->destroy);
1518 data->delargs = !(flags & (METH_O));
1525 data->implicitconv = 0;
1532 SwigPyClientData_Del(SwigPyClientData *data) {
1533 Py_XDECREF(data->newraw);
1534 Py_XDECREF(data->newargs);
1535 Py_XDECREF(data->destroy);
1538 /* =============== SwigPyObject =====================*/
1546 #ifdef SWIGPYTHON_BUILTIN
1552 #ifdef SWIGPYTHON_BUILTIN
1554 SWIGRUNTIME PyObject *
1555 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1557 SwigPyObject *sobj = (SwigPyObject *)v;
1560 sobj->dict = PyDict_New();
1562 Py_INCREF(sobj->dict);
1568 SWIGRUNTIME PyObject *
1569 SwigPyObject_long(SwigPyObject *v)
1571 return PyLong_FromVoidPtr(v->ptr);
1574 SWIGRUNTIME PyObject *
1575 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1577 PyObject *res = NULL;
1578 PyObject *args = PyTuple_New(1);
1580 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1581 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1583 #if PY_VERSION_HEX >= 0x03000000
1584 res = PyUnicode_Format(ofmt,args);
1586 res = PyString_Format(ofmt,args);
1596 SWIGRUNTIME PyObject *
1597 SwigPyObject_oct(SwigPyObject *v)
1599 return SwigPyObject_format("%o",v);
1602 SWIGRUNTIME PyObject *
1603 SwigPyObject_hex(SwigPyObject *v)
1605 return SwigPyObject_format("%x",v);
1608 SWIGRUNTIME PyObject *
1610 SwigPyObject_repr(SwigPyObject *v)
1612 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1615 const char *name = SWIG_TypePrettyName(v->ty);
1616 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1619 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1621 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1623 # if PY_VERSION_HEX >= 0x03000000
1624 PyObject *joined = PyUnicode_Concat(repr, nrep);
1629 PyString_ConcatAndDel(&repr,nrep);
1636 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1640 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1643 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1644 SWIGRUNTIME PyObject*
1645 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1648 if( op != Py_EQ && op != Py_NE ) {
1649 Py_INCREF(Py_NotImplemented);
1650 return Py_NotImplemented;
1652 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1657 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1659 #ifdef SWIGPYTHON_BUILTIN
1660 static swig_type_info *SwigPyObject_stype = 0;
1661 SWIGRUNTIME PyTypeObject*
1662 SwigPyObject_type(void) {
1663 SwigPyClientData *cd;
1664 assert(SwigPyObject_stype);
1665 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1671 SWIGRUNTIME PyTypeObject*
1672 SwigPyObject_type(void) {
1673 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1678 SWIGRUNTIMEINLINE int
1679 SwigPyObject_Check(PyObject *op) {
1680 #ifdef SWIGPYTHON_BUILTIN
1681 PyTypeObject *target_tp = SwigPyObject_type();
1682 if (PyType_IsSubtype(op->ob_type, target_tp))
1684 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1686 return (Py_TYPE(op) == SwigPyObject_type())
1687 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1691 SWIGRUNTIME PyObject *
1692 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1695 SwigPyObject_dealloc(PyObject *v)
1697 SwigPyObject *sobj = (SwigPyObject *) v;
1698 PyObject *next = sobj->next;
1699 if (sobj->own == SWIG_POINTER_OWN) {
1700 swig_type_info *ty = sobj->ty;
1701 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1702 PyObject *destroy = data ? data->destroy : 0;
1704 /* destroy is always a VARARGS method */
1707 /* PyObject_CallFunction() has the potential to silently drop
1708 the active active exception. In cases of unnamed temporary
1709 variable or where we just finished iterating over a generator
1710 StopIteration will be active right now, and this needs to
1711 remain true upon return from SwigPyObject_dealloc. So save
1714 PyObject *val = NULL, *type = NULL, *tb = NULL;
1715 PyErr_Fetch(&val, &type, &tb);
1717 if (data->delargs) {
1718 /* we need to create a temporary object to carry the destroy operation */
1719 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1720 res = SWIG_Python_CallFunctor(destroy, tmp);
1723 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1724 PyObject *mself = PyCFunction_GET_SELF(destroy);
1725 res = ((*meth)(mself, v));
1728 PyErr_WriteUnraisable(destroy);
1730 PyErr_Restore(val, type, tb);
1734 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1736 const char *name = SWIG_TypePrettyName(ty);
1737 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1745 SWIGRUNTIME PyObject*
1746 SwigPyObject_append(PyObject* v, PyObject* next)
1748 SwigPyObject *sobj = (SwigPyObject *) v;
1751 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1754 if (!SwigPyObject_Check(next)) {
1755 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1760 return SWIG_Py_Void();
1763 SWIGRUNTIME PyObject*
1765 SwigPyObject_next(PyObject* v)
1767 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1770 SwigPyObject *sobj = (SwigPyObject *) v;
1772 Py_INCREF(sobj->next);
1775 return SWIG_Py_Void();
1779 SWIGINTERN PyObject*
1781 SwigPyObject_disown(PyObject *v)
1783 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1786 SwigPyObject *sobj = (SwigPyObject *)v;
1788 return SWIG_Py_Void();
1791 SWIGINTERN PyObject*
1793 SwigPyObject_acquire(PyObject *v)
1795 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1798 SwigPyObject *sobj = (SwigPyObject *)v;
1799 sobj->own = SWIG_POINTER_OWN;
1800 return SWIG_Py_Void();
1803 SWIGINTERN PyObject*
1804 SwigPyObject_own(PyObject *v, PyObject *args)
1807 #if (PY_VERSION_HEX < 0x02020000)
1808 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1809 #elif (PY_VERSION_HEX < 0x02050000)
1810 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1812 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1819 SwigPyObject *sobj = (SwigPyObject *)v;
1820 PyObject *obj = PyBool_FromLong(sobj->own);
1823 if (PyObject_IsTrue(val)) {
1824 SwigPyObject_acquire(v);
1826 SwigPyObject_disown(v);
1829 if (PyObject_IsTrue(val)) {
1830 SwigPyObject_acquire(v,args);
1832 SwigPyObject_disown(v,args);
1842 swigobject_methods[] = {
1843 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1844 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1845 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1846 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1847 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1848 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1853 swigobject_methods[] = {
1854 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1855 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1856 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1857 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1858 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1859 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1864 #if PY_VERSION_HEX < 0x02020000
1865 SWIGINTERN PyObject *
1866 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1868 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1872 SWIGRUNTIME PyTypeObject*
1873 SwigPyObject_TypeOnce(void) {
1874 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1876 static PyNumberMethods SwigPyObject_as_number = {
1877 (binaryfunc)0, /*nb_add*/
1878 (binaryfunc)0, /*nb_subtract*/
1879 (binaryfunc)0, /*nb_multiply*/
1880 /* nb_divide removed in Python 3 */
1881 #if PY_VERSION_HEX < 0x03000000
1882 (binaryfunc)0, /*nb_divide*/
1884 (binaryfunc)0, /*nb_remainder*/
1885 (binaryfunc)0, /*nb_divmod*/
1886 (ternaryfunc)0,/*nb_power*/
1887 (unaryfunc)0, /*nb_negative*/
1888 (unaryfunc)0, /*nb_positive*/
1889 (unaryfunc)0, /*nb_absolute*/
1890 (inquiry)0, /*nb_nonzero*/
1897 #if PY_VERSION_HEX < 0x03000000
1900 (unaryfunc)SwigPyObject_long, /*nb_int*/
1901 #if PY_VERSION_HEX < 0x03000000
1902 (unaryfunc)SwigPyObject_long, /*nb_long*/
1906 (unaryfunc)0, /*nb_float*/
1907 #if PY_VERSION_HEX < 0x03000000
1908 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1909 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1911 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1912 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1913 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1914 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1915 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1916 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1917 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1918 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1919 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1920 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1924 static PyTypeObject swigpyobject_type;
1925 static int type_init = 0;
1927 const PyTypeObject tmp = {
1928 #if PY_VERSION_HEX >= 0x03000000
1929 PyVarObject_HEAD_INIT(NULL, 0)
1931 PyObject_HEAD_INIT(NULL)
1934 (char *)"SwigPyObject", /* tp_name */
1935 sizeof(SwigPyObject), /* tp_basicsize */
1936 0, /* tp_itemsize */
1937 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1939 #if PY_VERSION_HEX < 0x02020000
1940 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1942 (getattrfunc)0, /* tp_getattr */
1944 (setattrfunc)0, /* tp_setattr */
1945 #if PY_VERSION_HEX >= 0x03000000
1946 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1948 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1950 (reprfunc)SwigPyObject_repr, /* tp_repr */
1951 &SwigPyObject_as_number, /* tp_as_number */
1952 0, /* tp_as_sequence */
1953 0, /* tp_as_mapping */
1954 (hashfunc)0, /* tp_hash */
1955 (ternaryfunc)0, /* tp_call */
1957 PyObject_GenericGetAttr, /* tp_getattro */
1958 0, /* tp_setattro */
1959 0, /* tp_as_buffer */
1960 Py_TPFLAGS_DEFAULT, /* tp_flags */
1961 swigobject_doc, /* tp_doc */
1962 0, /* tp_traverse */
1964 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1965 0, /* tp_weaklistoffset */
1966 #if PY_VERSION_HEX >= 0x02020000
1968 0, /* tp_iternext */
1969 swigobject_methods, /* tp_methods */
1974 0, /* tp_descr_get */
1975 0, /* tp_descr_set */
1976 0, /* tp_dictoffset */
1985 0, /* tp_subclasses */
1986 0, /* tp_weaklist */
1988 #if PY_VERSION_HEX >= 0x02030000
1991 #if PY_VERSION_HEX >= 0x02060000
1992 0, /* tp_version_tag */
1994 #if PY_VERSION_HEX >= 0x03040000
1995 0, /* tp_finalize */
2000 0, /* tp_maxalloc */
2001 #if PY_VERSION_HEX >= 0x02050000
2007 swigpyobject_type = tmp;
2009 #if PY_VERSION_HEX < 0x02020000
2010 swigpyobject_type.ob_type = &PyType_Type;
2012 if (PyType_Ready(&swigpyobject_type) < 0)
2016 return &swigpyobject_type;
2019 SWIGRUNTIME PyObject *
2020 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2022 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2029 return (PyObject *)sobj;
2032 /* -----------------------------------------------------------------------------
2033 * Implements a simple Swig Packed type, and use it instead of string
2034 * ----------------------------------------------------------------------------- */
2044 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2046 char result[SWIG_BUFFER_SIZE];
2047 fputs("<Swig Packed ", fp);
2048 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2052 fputs(v->ty->name,fp);
2057 SWIGRUNTIME PyObject *
2058 SwigPyPacked_repr(SwigPyPacked *v)
2060 char result[SWIG_BUFFER_SIZE];
2061 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2062 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2064 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2068 SWIGRUNTIME PyObject *
2069 SwigPyPacked_str(SwigPyPacked *v)
2071 char result[SWIG_BUFFER_SIZE];
2072 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2073 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2075 return SWIG_Python_str_FromChar(v->ty->name);
2080 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2084 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2085 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2088 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2090 SWIGRUNTIME PyTypeObject*
2091 SwigPyPacked_type(void) {
2092 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2096 SWIGRUNTIMEINLINE int
2097 SwigPyPacked_Check(PyObject *op) {
2098 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2099 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2103 SwigPyPacked_dealloc(PyObject *v)
2105 if (SwigPyPacked_Check(v)) {
2106 SwigPyPacked *sobj = (SwigPyPacked *) v;
2112 SWIGRUNTIME PyTypeObject*
2113 SwigPyPacked_TypeOnce(void) {
2114 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2115 static PyTypeObject swigpypacked_type;
2116 static int type_init = 0;
2118 const PyTypeObject tmp = {
2119 #if PY_VERSION_HEX>=0x03000000
2120 PyVarObject_HEAD_INIT(NULL, 0)
2122 PyObject_HEAD_INIT(NULL)
2125 (char *)"SwigPyPacked", /* tp_name */
2126 sizeof(SwigPyPacked), /* tp_basicsize */
2127 0, /* tp_itemsize */
2128 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2129 (printfunc)SwigPyPacked_print, /* tp_print */
2130 (getattrfunc)0, /* tp_getattr */
2131 (setattrfunc)0, /* tp_setattr */
2132 #if PY_VERSION_HEX>=0x03000000
2133 0, /* tp_reserved in 3.0.1 */
2135 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2137 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2138 0, /* tp_as_number */
2139 0, /* tp_as_sequence */
2140 0, /* tp_as_mapping */
2141 (hashfunc)0, /* tp_hash */
2142 (ternaryfunc)0, /* tp_call */
2143 (reprfunc)SwigPyPacked_str, /* tp_str */
2144 PyObject_GenericGetAttr, /* tp_getattro */
2145 0, /* tp_setattro */
2146 0, /* tp_as_buffer */
2147 Py_TPFLAGS_DEFAULT, /* tp_flags */
2148 swigpacked_doc, /* tp_doc */
2149 0, /* tp_traverse */
2151 0, /* tp_richcompare */
2152 0, /* tp_weaklistoffset */
2153 #if PY_VERSION_HEX >= 0x02020000
2155 0, /* tp_iternext */
2161 0, /* tp_descr_get */
2162 0, /* tp_descr_set */
2163 0, /* tp_dictoffset */
2172 0, /* tp_subclasses */
2173 0, /* tp_weaklist */
2175 #if PY_VERSION_HEX >= 0x02030000
2178 #if PY_VERSION_HEX >= 0x02060000
2179 0, /* tp_version_tag */
2181 #if PY_VERSION_HEX >= 0x03040000
2182 0, /* tp_finalize */
2187 0, /* tp_maxalloc */
2188 #if PY_VERSION_HEX >= 0x02050000
2194 swigpypacked_type = tmp;
2196 #if PY_VERSION_HEX < 0x02020000
2197 swigpypacked_type.ob_type = &PyType_Type;
2199 if (PyType_Ready(&swigpypacked_type) < 0)
2203 return &swigpypacked_type;
2206 SWIGRUNTIME PyObject *
2207 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2209 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2211 void *pack = malloc(size);
2213 memcpy(pack, ptr, size);
2218 PyObject_DEL((PyObject *) sobj);
2222 return (PyObject *) sobj;
2225 SWIGRUNTIME swig_type_info *
2226 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2228 if (SwigPyPacked_Check(obj)) {
2229 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2230 if (sobj->size != size) return 0;
2231 memcpy(ptr, sobj->pack, size);
2238 /* -----------------------------------------------------------------------------
2239 * pointers/data manipulation
2240 * ----------------------------------------------------------------------------- */
2242 SWIGRUNTIMEINLINE PyObject *
2245 return SWIG_Python_str_FromChar("this");
2248 static PyObject *swig_this = NULL;
2250 SWIGRUNTIME PyObject *
2253 if (swig_this == NULL)
2254 swig_this = _SWIG_This();
2258 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2260 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2261 #if PY_VERSION_HEX>=0x03000000
2262 #define SWIG_PYTHON_SLOW_GETSET_THIS
2265 SWIGRUNTIME SwigPyObject *
2266 SWIG_Python_GetSwigThis(PyObject *pyobj)
2270 if (SwigPyObject_Check(pyobj))
2271 return (SwigPyObject *) pyobj;
2273 #ifdef SWIGPYTHON_BUILTIN
2275 # ifdef PyWeakref_CheckProxy
2276 if (PyWeakref_CheckProxy(pyobj)) {
2277 pyobj = PyWeakref_GET_OBJECT(pyobj);
2278 if (pyobj && SwigPyObject_Check(pyobj))
2279 return (SwigPyObject*) pyobj;
2287 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2288 if (PyInstance_Check(pyobj)) {
2289 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2291 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2292 if (dictptr != NULL) {
2293 PyObject *dict = *dictptr;
2294 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2296 #ifdef PyWeakref_CheckProxy
2297 if (PyWeakref_CheckProxy(pyobj)) {
2298 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2299 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2302 obj = PyObject_GetAttr(pyobj,SWIG_This());
2306 if (PyErr_Occurred()) PyErr_Clear();
2312 obj = PyObject_GetAttr(pyobj,SWIG_This());
2316 if (PyErr_Occurred()) PyErr_Clear();
2320 if (obj && !SwigPyObject_Check(obj)) {
2321 /* a PyObject is called 'this', try to get the 'real this'
2322 SwigPyObject from it */
2323 return SWIG_Python_GetSwigThis(obj);
2325 return (SwigPyObject *)obj;
2329 /* Acquire a pointer value */
2332 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2333 if (own == SWIG_POINTER_OWN) {
2334 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2336 int oldown = sobj->own;
2344 /* Convert a pointer value */
2347 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2350 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2354 if (obj == Py_None && !implicit_conv) {
2362 sobj = SWIG_Python_GetSwigThis(obj);
2366 void *vptr = sobj->ptr;
2368 swig_type_info *to = sobj->ty;
2370 /* no type cast needed */
2371 if (ptr) *ptr = vptr;
2374 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2376 sobj = (SwigPyObject *)sobj->next;
2380 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2381 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2382 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2384 *own = *own | SWIG_CAST_NEW_MEMORY;
2391 if (ptr) *ptr = vptr;
2397 *own = *own | sobj->own;
2398 if (flags & SWIG_POINTER_DISOWN) {
2403 if (implicit_conv) {
2404 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2405 if (data && !data->implicitconv) {
2406 PyObject *klass = data->klass;
2409 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2410 impconv = SWIG_Python_CallFunctor(klass, obj);
2411 data->implicitconv = 0;
2412 if (PyErr_Occurred()) {
2417 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2420 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2421 if (SWIG_IsOK(res)) {
2424 /* transfer the ownership to 'ptr' */
2426 res = SWIG_AddCast(res);
2427 res = SWIG_AddNewMask(res);
2429 res = SWIG_AddCast(res);
2438 if (!SWIG_IsOK(res) && obj == Py_None) {
2441 if (PyErr_Occurred())
2449 /* Convert a function ptr value */
2452 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2453 if (!PyCFunction_Check(obj)) {
2454 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2458 /* here we get the method pointer for callbacks */
2459 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2460 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2462 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2466 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2469 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2470 assert(!newmemory); /* newmemory handling not yet implemented */
2481 /* Convert a packed value value */
2484 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2485 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2486 if (!to) return SWIG_ERROR;
2489 /* check type cast? */
2490 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2491 if (!tc) return SWIG_ERROR;
2497 /* -----------------------------------------------------------------------------
2498 * Create a new pointer object
2499 * ----------------------------------------------------------------------------- */
2502 Create a new instance object, without calling __init__, and set the
2506 SWIGRUNTIME PyObject*
2507 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2509 #if (PY_VERSION_HEX >= 0x02020000)
2511 PyObject *newraw = data->newraw;
2513 inst = PyObject_Call(newraw, data->newargs, NULL);
2515 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2516 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2517 if (dictptr != NULL) {
2518 PyObject *dict = *dictptr;
2520 dict = PyDict_New();
2522 PyDict_SetItem(dict, SWIG_This(), swig_this);
2526 PyObject *key = SWIG_This();
2527 PyObject_SetAttr(inst, key, swig_this);
2531 #if PY_VERSION_HEX >= 0x03000000
2532 inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2534 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2535 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2538 PyObject *dict = PyDict_New();
2540 PyDict_SetItem(dict, SWIG_This(), swig_this);
2541 inst = PyInstance_NewRaw(data->newargs, dict);
2548 #if (PY_VERSION_HEX >= 0x02010000)
2550 PyObject *dict = PyDict_New();
2552 PyDict_SetItem(dict, SWIG_This(), swig_this);
2553 inst = PyInstance_NewRaw(data->newargs, dict);
2556 return (PyObject *) inst;
2558 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2562 inst->in_class = (PyClassObject *)data->newargs;
2563 Py_INCREF(inst->in_class);
2564 inst->in_dict = PyDict_New();
2565 if (inst->in_dict == NULL) {
2569 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2570 inst->in_weakreflist = NULL;
2572 #ifdef Py_TPFLAGS_GC
2573 PyObject_GC_Init(inst);
2575 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2576 return (PyObject *) inst;
2582 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2585 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2586 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2587 if (dictptr != NULL) {
2590 dict = PyDict_New();
2593 PyDict_SetItem(dict, SWIG_This(), swig_this);
2597 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2598 PyDict_SetItem(dict, SWIG_This(), swig_this);
2603 SWIGINTERN PyObject *
2604 SWIG_Python_InitShadowInstance(PyObject *args) {
2606 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2609 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2611 SwigPyObject_append((PyObject*) sthis, obj[1]);
2613 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2615 return SWIG_Py_Void();
2619 /* Create a new pointer object */
2621 SWIGRUNTIME PyObject *
2622 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2623 SwigPyClientData *clientdata;
2628 return SWIG_Py_Void();
2630 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2631 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2632 if (clientdata && clientdata->pytype) {
2633 SwigPyObject *newobj;
2634 if (flags & SWIG_BUILTIN_TP_INIT) {
2635 newobj = (SwigPyObject*) self;
2637 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2638 while (newobj->next)
2639 newobj = (SwigPyObject *) newobj->next;
2640 newobj->next = next_self;
2641 newobj = (SwigPyObject *)next_self;
2642 #ifdef SWIGPYTHON_BUILTIN
2647 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2648 #ifdef SWIGPYTHON_BUILTIN
2657 return (PyObject*) newobj;
2659 return SWIG_Py_Void();
2662 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2664 robj = SwigPyObject_New(ptr, type, own);
2665 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2666 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2673 /* Create a new packed object */
2675 SWIGRUNTIMEINLINE PyObject *
2676 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2677 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2680 /* -----------------------------------------------------------------------------*
2682 * -----------------------------------------------------------------------------*/
2684 #ifdef SWIG_LINK_RUNTIME
2685 void *SWIG_ReturnGlobalTypeList(void *);
2688 SWIGRUNTIME swig_module_info *
2689 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2690 static void *type_pointer = (void *)0;
2691 /* first check if module already created */
2692 if (!type_pointer) {
2693 #ifdef SWIG_LINK_RUNTIME
2694 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2696 # ifdef SWIGPY_USE_CAPSULE
2697 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2699 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2700 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2702 if (PyErr_Occurred()) {
2704 type_pointer = (void *)0;
2708 return (swig_module_info *) type_pointer;
2711 #if PY_MAJOR_VERSION < 2
2712 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2713 is copied out of Python/modsupport.c in python version 2.3.4 */
2715 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2718 if (!PyModule_Check(m)) {
2719 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2723 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2727 dict = PyModule_GetDict(m);
2729 /* Internal error -- modules must have a dict! */
2730 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2731 PyModule_GetName(m));
2734 if (PyDict_SetItemString(dict, name, o))
2742 #ifdef SWIGPY_USE_CAPSULE
2743 SWIG_Python_DestroyModule(PyObject *obj)
2745 SWIG_Python_DestroyModule(void *vptr)
2748 #ifdef SWIGPY_USE_CAPSULE
2749 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2751 swig_module_info *swig_module = (swig_module_info *) vptr;
2753 swig_type_info **types = swig_module->types;
2755 for (i =0; i < swig_module->size; ++i) {
2756 swig_type_info *ty = types[i];
2758 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2759 if (data) SwigPyClientData_Del(data);
2762 Py_DECREF(SWIG_This());
2767 SWIG_Python_SetModule(swig_module_info *swig_module) {
2768 #if PY_VERSION_HEX >= 0x03000000
2769 /* Add a dummy module object into sys.modules */
2770 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2772 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2773 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2775 #ifdef SWIGPY_USE_CAPSULE
2776 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2777 if (pointer && module) {
2778 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2780 Py_XDECREF(pointer);
2783 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2784 if (pointer && module) {
2785 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2787 Py_XDECREF(pointer);
2792 /* The python cached type query */
2793 SWIGRUNTIME PyObject *
2794 SWIG_Python_TypeCache(void) {
2795 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2799 SWIGRUNTIME swig_type_info *
2800 SWIG_Python_TypeQuery(const char *type)
2802 PyObject *cache = SWIG_Python_TypeCache();
2803 PyObject *key = SWIG_Python_str_FromChar(type);
2804 PyObject *obj = PyDict_GetItem(cache, key);
2805 swig_type_info *descriptor;
2807 #ifdef SWIGPY_USE_CAPSULE
2808 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2810 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2813 swig_module_info *swig_module = SWIG_GetModule(0);
2814 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2816 #ifdef SWIGPY_USE_CAPSULE
2817 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2819 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2821 PyDict_SetItem(cache, key, obj);
2830 For backward compatibility only
2832 #define SWIG_POINTER_EXCEPTION 0
2833 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2834 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2837 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2839 if (PyErr_Occurred()) {
2841 PyObject *value = 0;
2842 PyObject *traceback = 0;
2843 PyErr_Fetch(&type, &value, &traceback);
2846 PyObject *old_str = PyObject_Str(value);
2850 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2852 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2854 SWIG_Python_str_DelForPy3(tmp);
2864 SWIG_Python_ArgFail(int argnum)
2866 if (PyErr_Occurred()) {
2867 /* add information about failing argument */
2869 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2870 return SWIG_Python_AddErrMesg(mesg, 1);
2876 SWIGRUNTIMEINLINE const char *
2877 SwigPyObject_GetDesc(PyObject *self)
2879 SwigPyObject *v = (SwigPyObject *)self;
2880 swig_type_info *ty = v ? v->ty : 0;
2881 return ty ? ty->str : "";
2885 SWIG_Python_TypeError(const char *type, PyObject *obj)
2888 #if defined(SWIG_COBJECT_TYPES)
2889 if (obj && SwigPyObject_Check(obj)) {
2890 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2892 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2899 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2901 PyObject *str = PyObject_Str(obj);
2902 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2904 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2906 SWIG_Python_str_DelForPy3(cstr);
2908 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2915 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2917 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2922 /* Convert a pointer value, signal an exception on a type mismatch */
2924 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2926 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2928 #if SWIG_POINTER_EXCEPTION
2930 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2931 SWIG_Python_ArgFail(argnum);
2938 #ifdef SWIGPYTHON_BUILTIN
2940 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2941 PyTypeObject *tp = obj->ob_type;
2943 PyObject *encoded_name;
2947 # ifdef Py_USING_UNICODE
2948 if (PyString_Check(name)) {
2949 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2952 } else if (!PyUnicode_Check(name))
2954 if (!PyString_Check(name))
2957 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2964 if (PyType_Ready(tp) < 0)
2968 descr = _PyType_Lookup(tp, name);
2971 f = descr->ob_type->tp_descr_set;
2973 if (PyString_Check(name)) {
2974 encoded_name = name;
2977 encoded_name = PyUnicode_AsUTF8String(name);
2979 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2980 Py_DECREF(encoded_name);
2982 res = f(descr, obj, value);
2998 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3000 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3004 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3007 /* -------- TYPES TABLE (BEGIN) -------- */
3009 #define SWIGTYPE_p_FILE swig_types[0]
3010 #define SWIGTYPE_p_Hex__BiCylinder swig_types[1]
3011 #define SWIGTYPE_p_Hex__Document swig_types[2]
3012 #define SWIGTYPE_p_Hex__Edge swig_types[3]
3013 #define SWIGTYPE_p_Hex__Elements swig_types[4]
3014 #define SWIGTYPE_p_Hex__EltBase swig_types[5]
3015 #define SWIGTYPE_p_Hex__Group swig_types[6]
3016 #define SWIGTYPE_p_Hex__Hex swig_types[7]
3017 #define SWIGTYPE_p_Hex__Hex__Elements swig_types[8]
3018 #define SWIGTYPE_p_Hex__Hex__EltBase swig_types[9]
3019 #define SWIGTYPE_p_Hex__Hexa swig_types[10]
3020 #define SWIGTYPE_p_Hex__Law swig_types[11]
3021 #define SWIGTYPE_p_Hex__NewShape swig_types[12]
3022 #define SWIGTYPE_p_Hex__Propagation swig_types[13]
3023 #define SWIGTYPE_p_Hex__Quad swig_types[14]
3024 #define SWIGTYPE_p_Hex__Shape swig_types[15]
3025 #define SWIGTYPE_p_Hex__Vector swig_types[16]
3026 #define SWIGTYPE_p_Hex__Vertex swig_types[17]
3027 #define SWIGTYPE_p_Hex__XmlWriter swig_types[18]
3028 #define SWIGTYPE_p_a_Hex__DIM3__double swig_types[19]
3029 #define SWIGTYPE_p_allocator_type swig_types[20]
3030 #define SWIGTYPE_p_char swig_types[21]
3031 #define SWIGTYPE_p_const_reference swig_types[22]
3032 #define SWIGTYPE_p_difference_type swig_types[23]
3033 #define SWIGTYPE_p_double swig_types[24]
3034 #define SWIGTYPE_p_int swig_types[25]
3035 #define SWIGTYPE_p_p_PyObject swig_types[26]
3036 #define SWIGTYPE_p_reference swig_types[27]
3037 #define SWIGTYPE_p_size_type swig_types[28]
3038 #define SWIGTYPE_p_std__allocatorT_Hex__Edge_p_t swig_types[29]
3039 #define SWIGTYPE_p_std__allocatorT_Hex__Hexa_p_t swig_types[30]
3040 #define SWIGTYPE_p_std__allocatorT_Hex__NewShape_p_t swig_types[31]
3041 #define SWIGTYPE_p_std__allocatorT_Hex__Quad_p_t swig_types[32]
3042 #define SWIGTYPE_p_std__allocatorT_Hex__Vertex_p_t swig_types[33]
3043 #define SWIGTYPE_p_std__allocatorT_double_t swig_types[34]
3044 #define SWIGTYPE_p_std__allocatorT_int_t swig_types[35]
3045 #define SWIGTYPE_p_std__invalid_argument swig_types[36]
3046 #define SWIGTYPE_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t swig_types[37]
3047 #define SWIGTYPE_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t swig_types[38]
3048 #define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t swig_types[39]
3049 #define SWIGTYPE_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t swig_types[40]
3050 #define SWIGTYPE_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t swig_types[41]
3051 #define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t swig_types[42]
3052 #define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t swig_types[43]
3053 #define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t swig_types[44]
3054 #define SWIGTYPE_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t swig_types[45]
3055 #define SWIGTYPE_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t swig_types[46]
3056 #define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t swig_types[47]
3057 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[48]
3058 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[49]
3059 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[50]
3060 #define SWIGTYPE_p_string swig_types[51]
3061 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[52]
3062 #define SWIGTYPE_p_value_type swig_types[53]
3063 static swig_type_info *swig_types[55];
3064 static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
3065 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3066 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3068 /* -------- TYPES TABLE (END) -------- */
3070 #if (PY_VERSION_HEX <= 0x02000000)
3071 # if !defined(SWIG_PYTHON_CLASSIC)
3072 # error "This python version requires swig to be run with the '-classic' option"
3076 /*-----------------------------------------------
3077 @(target):= _hexablock_swig.so
3078 ------------------------------------------------*/
3079 #if PY_VERSION_HEX >= 0x03000000
3080 # define SWIG_init PyInit__hexablock_swig
3083 # define SWIG_init init_hexablock_swig
3086 #define SWIG_name "_hexablock_swig"
3088 #define SWIGVERSION 0x030012
3089 #define SWIG_VERSION SWIGVERSION
3092 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3093 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3096 #include <stdexcept>
3100 class SwigPtr_PyObject {
3105 SwigPtr_PyObject() :_obj(0)
3109 SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
3111 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3113 SWIG_PYTHON_THREAD_END_BLOCK;
3116 SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
3119 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3121 SWIG_PYTHON_THREAD_END_BLOCK;
3125 SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
3127 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3128 Py_XINCREF(item._obj);
3131 SWIG_PYTHON_THREAD_END_BLOCK;
3137 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3139 SWIG_PYTHON_THREAD_END_BLOCK;
3142 operator PyObject *() const
3147 PyObject *operator->() const
3156 struct SwigVar_PyObject : SwigPtr_PyObject {
3157 SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
3159 SwigVar_PyObject & operator = (PyObject* obj)
3170 #include "HexDocument.hxx"
3171 #include "HexPropagation.hxx"
3172 #include "HexElements.hxx"
3173 #include "HexQuad.hxx"
3174 #include "HexVertex.hxx"
3175 #include "HexHexa.hxx"
3176 #include "HexEdge.hxx"
3177 #include "HexVector.hxx"
3178 #include "HexBiCylinder.hxx"
3179 #include "HexNewShape.hxx"
3180 #include "HexGroup.hxx"
3185 #if PY_VERSION_HEX >= 0x03020000
3186 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
3188 # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
3193 #include <stdexcept>
3196 #if defined(__GNUC__)
3197 # if __GNUC__ == 2 && __GNUC_MINOR <= 96
3198 # define SWIG_STD_NOMODERN_STL
3210 struct stop_iteration {
3213 struct SwigPyIterator {
3215 SwigPtr_PyObject _seq;
3218 SwigPyIterator(PyObject *seq) : _seq(seq)
3223 virtual ~SwigPyIterator() {}
3225 // Access iterator method, required by Python
3226 virtual PyObject *value() const = 0;
3228 // Forward iterator method, required by Python
3229 virtual SwigPyIterator *incr(size_t n = 1) = 0;
3231 // Backward iterator method, very common in C++, but not required in Python
3232 virtual SwigPyIterator *decr(size_t /*n*/ = 1)
3234 throw stop_iteration();
3237 // Random access iterator methods, but not required in Python
3238 virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
3240 throw std::invalid_argument("operation not supported");
3243 virtual bool equal (const SwigPyIterator &/*x*/) const
3245 throw std::invalid_argument("operation not supported");
3248 // C++ common/needed methods
3249 virtual SwigPyIterator *copy() const = 0;
3253 SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3254 PyObject *obj = value();
3256 SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3260 /* Make an alias for Python 3.x */
3261 PyObject *__next__()
3266 PyObject *previous()
3268 SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3270 PyObject *obj = value();
3271 SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3275 SwigPyIterator *advance(ptrdiff_t n)
3277 return (n > 0) ? incr(n) : decr(-n);
3280 bool operator == (const SwigPyIterator& x) const
3285 bool operator != (const SwigPyIterator& x) const
3287 return ! operator==(x);
3290 SwigPyIterator& operator += (ptrdiff_t n)
3295 SwigPyIterator& operator -= (ptrdiff_t n)
3297 return *advance(-n);
3300 SwigPyIterator* operator + (ptrdiff_t n) const
3302 return copy()->advance(n);
3305 SwigPyIterator* operator - (ptrdiff_t n) const
3307 return copy()->advance(-n);
3310 ptrdiff_t operator - (const SwigPyIterator& x) const
3312 return x.distance(*this);
3315 static swig_type_info* descriptor() {
3316 static int init = 0;
3317 static swig_type_info* desc = 0;
3319 desc = SWIG_TypeQuery("swig::SwigPyIterator *");
3326 #if defined(SWIGPYTHON_BUILTIN)
3327 inline PyObject* make_output_iterator_builtin (PyObject *pyself)
3337 SWIG_AsVal_double (PyObject *obj, double *val)
3339 int res = SWIG_TypeError;
3340 if (PyFloat_Check(obj)) {
3341 if (val) *val = PyFloat_AsDouble(obj);
3343 #if PY_VERSION_HEX < 0x03000000
3344 } else if (PyInt_Check(obj)) {
3345 if (val) *val = (double) PyInt_AsLong(obj);
3348 } else if (PyLong_Check(obj)) {
3349 double v = PyLong_AsDouble(obj);
3350 if (!PyErr_Occurred()) {
3357 #ifdef SWIG_PYTHON_CAST_MODE
3360 double d = PyFloat_AsDouble(obj);
3361 if (!PyErr_Occurred()) {
3363 return SWIG_AddCast(SWIG_OK);
3368 long v = PyLong_AsLong(obj);
3369 if (!PyErr_Occurred()) {
3371 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3388 SWIGINTERNINLINE int
3389 SWIG_CanCastAsInteger(double *d, double min, double max) {
3391 if ((min <= x && x <= max)) {
3392 double fx = floor(x);
3393 double cx = ceil(x);
3394 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3395 if ((errno == EDOM) || (errno == ERANGE)) {
3398 double summ, reps, diff;
3401 } else if (rd > x) {
3408 if (reps < 8*DBL_EPSILON) {
3419 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3421 #if PY_VERSION_HEX < 0x03000000
3422 if (PyInt_Check(obj)) {
3423 long v = PyInt_AsLong(obj);
3428 return SWIG_OverflowError;
3432 if (PyLong_Check(obj)) {
3433 unsigned long v = PyLong_AsUnsignedLong(obj);
3434 if (!PyErr_Occurred()) {
3439 return SWIG_OverflowError;
3442 #ifdef SWIG_PYTHON_CAST_MODE
3445 unsigned long v = PyLong_AsUnsignedLong(obj);
3446 if (!PyErr_Occurred()) {
3448 return SWIG_AddCast(SWIG_OK);
3454 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3455 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3456 if (val) *val = (unsigned long)(d);
3462 return SWIG_TypeError;
3467 #if !defined(SWIG_NO_LLONG_MAX)
3468 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3469 # define LLONG_MAX __LONG_LONG_MAX__
3470 # define LLONG_MIN (-LLONG_MAX - 1LL)
3471 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3476 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3477 # define SWIG_LONG_LONG_AVAILABLE
3481 #ifdef SWIG_LONG_LONG_AVAILABLE
3483 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3485 int res = SWIG_TypeError;
3486 if (PyLong_Check(obj)) {
3487 unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3488 if (!PyErr_Occurred()) {
3493 res = SWIG_OverflowError;
3497 res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3498 if (SWIG_IsOK(res)) {
3503 #ifdef SWIG_PYTHON_CAST_MODE
3505 const double mant_max = 1LL << DBL_MANT_DIG;
3507 res = SWIG_AsVal_double (obj,&d);
3508 if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
3509 return SWIG_OverflowError;
3510 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3511 if (val) *val = (unsigned long long)(d);
3512 return SWIG_AddCast(res);
3514 res = SWIG_TypeError;
3522 SWIGINTERNINLINE int
3523 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3525 int res = SWIG_TypeError;
3526 #ifdef SWIG_LONG_LONG_AVAILABLE
3527 if (sizeof(size_t) <= sizeof(unsigned long)) {
3530 res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3531 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3532 #ifdef SWIG_LONG_LONG_AVAILABLE
3533 } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3534 unsigned long long v;
3535 res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3536 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3543 #define SWIG_From_long PyInt_FromLong
3546 #ifdef SWIG_LONG_LONG_AVAILABLE
3547 SWIGINTERNINLINE PyObject*
3548 SWIG_From_long_SS_long (long long value)
3550 return ((value < LONG_MIN) || (value > LONG_MAX)) ?
3551 PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
3556 SWIGINTERNINLINE PyObject *
3557 SWIG_From_ptrdiff_t (ptrdiff_t value)
3559 #ifdef SWIG_LONG_LONG_AVAILABLE
3560 if (sizeof(ptrdiff_t) <= sizeof(long)) {
3562 return SWIG_From_long (static_cast< long >(value));
3563 #ifdef SWIG_LONG_LONG_AVAILABLE
3565 /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
3566 return SWIG_From_long_SS_long (static_cast< long long >(value));
3572 SWIGINTERNINLINE PyObject*
3573 SWIG_From_bool (bool value)
3575 return PyBool_FromLong(value ? 1 : 0);
3580 SWIG_AsVal_long (PyObject *obj, long* val)
3582 #if PY_VERSION_HEX < 0x03000000
3583 if (PyInt_Check(obj)) {
3584 if (val) *val = PyInt_AsLong(obj);
3588 if (PyLong_Check(obj)) {
3589 long v = PyLong_AsLong(obj);
3590 if (!PyErr_Occurred()) {
3595 return SWIG_OverflowError;
3598 #ifdef SWIG_PYTHON_CAST_MODE
3601 long v = PyInt_AsLong(obj);
3602 if (!PyErr_Occurred()) {
3604 return SWIG_AddCast(SWIG_OK);
3610 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3611 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3612 if (val) *val = (long)(d);
3618 return SWIG_TypeError;
3622 #ifdef SWIG_LONG_LONG_AVAILABLE
3624 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
3626 int res = SWIG_TypeError;
3627 if (PyLong_Check(obj)) {
3628 long long v = PyLong_AsLongLong(obj);
3629 if (!PyErr_Occurred()) {
3634 res = SWIG_OverflowError;
3638 res = SWIG_AsVal_long (obj,&v);
3639 if (SWIG_IsOK(res)) {
3644 #ifdef SWIG_PYTHON_CAST_MODE
3646 const double mant_max = 1LL << DBL_MANT_DIG;
3647 const double mant_min = -mant_max;
3649 res = SWIG_AsVal_double (obj,&d);
3650 if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
3651 return SWIG_OverflowError;
3652 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
3653 if (val) *val = (long long)(d);
3654 return SWIG_AddCast(res);
3656 res = SWIG_TypeError;
3664 SWIGINTERNINLINE int
3665 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3667 int res = SWIG_TypeError;
3668 #ifdef SWIG_LONG_LONG_AVAILABLE
3669 if (sizeof(ptrdiff_t) <= sizeof(long)) {
3672 res = SWIG_AsVal_long (obj, val ? &v : 0);
3673 if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3674 #ifdef SWIG_LONG_LONG_AVAILABLE
3675 } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
3677 res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
3678 if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3685 #include <algorithm>
3692 template <class Type>
3693 struct noconst_traits {
3694 typedef Type noconst_type;
3697 template <class Type>
3698 struct noconst_traits<const Type> {
3699 typedef Type noconst_type;
3705 struct pointer_category { };
3706 struct value_category { };
3709 General traits that provides type_name and type_info
3711 template <class Type> struct traits { };
3713 template <class Type>
3714 inline const char* type_name() {
3715 return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3718 template <class Type> struct traits_info {
3719 static swig_type_info *type_query(std::string name) {
3721 return SWIG_TypeQuery(name.c_str());
3723 static swig_type_info *type_info() {
3724 static swig_type_info *info = type_query(type_name<Type>());
3730 Partial specialization for pointers (traits_info)
3732 template <class Type> struct traits_info<Type *> {
3733 static swig_type_info *type_query(std::string name) {
3735 return SWIG_TypeQuery(name.c_str());
3737 static swig_type_info *type_info() {
3738 static swig_type_info *info = type_query(type_name<Type>());
3743 template <class Type>
3744 inline swig_type_info *type_info() {
3745 return traits_info<Type>::type_info();
3749 Partial specialization for pointers (traits)
3751 template <class Type> struct traits <Type *> {
3752 typedef pointer_category category;
3753 static std::string make_ptr_name(const char* name) {
3754 std::string ptrname = name;
3758 static const char* type_name() {
3759 static std::string name = make_ptr_name(swig::type_name<Type>());
3760 return name.c_str();
3764 template <class Type, class Category>
3765 struct traits_as { };
3767 template <class Type, class Category>
3768 struct traits_check { };
3775 Traits that provides the from method
3777 template <class Type> struct traits_from_ptr {
3778 static PyObject *from(Type *val, int owner = 0) {
3779 return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
3783 template <class Type> struct traits_from {
3784 static PyObject *from(const Type& val) {
3785 return traits_from_ptr<Type>::from(new Type(val), 1);
3789 template <class Type> struct traits_from<Type *> {
3790 static PyObject *from(Type* val) {
3791 return traits_from_ptr<Type>::from(val, 0);
3795 template <class Type> struct traits_from<const Type *> {
3796 static PyObject *from(const Type* val) {
3797 return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3802 template <class Type>
3803 inline PyObject *from(const Type& val) {
3804 return traits_from<Type>::from(val);
3807 template <class Type>
3808 inline PyObject *from_ptr(Type* val, int owner) {
3809 return traits_from_ptr<Type>::from(val, owner);
3813 Traits that provides the asval/as/check method
3815 template <class Type>
3816 struct traits_asptr {
3817 static int asptr(PyObject *obj, Type **val) {
3819 swig_type_info *descriptor = type_info<Type>();
3820 int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
3821 if (SWIG_IsOK(res)) {
3828 template <class Type>
3829 inline int asptr(PyObject *obj, Type **vptr) {
3830 return traits_asptr<Type>::asptr(obj, vptr);
3833 template <class Type>
3834 struct traits_asval {
3835 static int asval(PyObject *obj, Type *val) {
3838 int res = traits_asptr<Type>::asptr(obj, &p);
3839 if (!SWIG_IsOK(res)) return res;
3841 typedef typename noconst_traits<Type>::noconst_type noconst_type;
3842 *(const_cast<noconst_type*>(val)) = *p;
3843 if (SWIG_IsNewObj(res)){
3845 res = SWIG_DelNewMask(res);
3852 return traits_asptr<Type>::asptr(obj, (Type **)(0));
3857 template <class Type> struct traits_asval<Type*> {
3858 static int asval(PyObject *obj, Type **val) {
3860 typedef typename noconst_traits<Type>::noconst_type noconst_type;
3861 noconst_type *p = 0;
3862 int res = traits_asptr<noconst_type>::asptr(obj, &p);
3863 if (SWIG_IsOK(res)) {
3864 *(const_cast<noconst_type**>(val)) = p;
3868 return traits_asptr<Type>::asptr(obj, (Type **)(0));
3873 template <class Type>
3874 inline int asval(PyObject *obj, Type *val) {
3875 return traits_asval<Type>::asval(obj, val);
3878 template <class Type>
3879 struct traits_as<Type, value_category> {
3880 static Type as(PyObject *obj, bool throw_error) {
3882 int res = asval(obj, &v);
3883 if (!obj || !SWIG_IsOK(res)) {
3884 if (!PyErr_Occurred()) {
3885 ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3887 if (throw_error) throw std::invalid_argument("bad type");
3893 template <class Type>
3894 struct traits_as<Type, pointer_category> {
3895 static Type as(PyObject *obj, bool throw_error) {
3897 int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3898 if (SWIG_IsOK(res) && v) {
3899 if (SWIG_IsNewObj(res)) {
3907 // Uninitialized return value, no Type() constructor required.
3908 static Type *v_def = (Type*) malloc(sizeof(Type));
3909 if (!PyErr_Occurred()) {
3910 SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3912 if (throw_error) throw std::invalid_argument("bad type");
3913 memset(v_def,0,sizeof(Type));
3919 template <class Type>
3920 struct traits_as<Type*, pointer_category> {
3921 static Type* as(PyObject *obj, bool throw_error) {
3923 int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3924 if (SWIG_IsOK(res)) {
3927 if (!PyErr_Occurred()) {
3928 SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
3930 if (throw_error) throw std::invalid_argument("bad type");
3936 template <class Type>
3937 inline Type as(PyObject *obj, bool te = false) {
3938 return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3941 template <class Type>
3942 struct traits_check<Type, value_category> {
3943 static bool check(PyObject *obj) {
3944 int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3945 return SWIG_IsOK(res) ? true : false;
3949 template <class Type>
3950 struct traits_check<Type, pointer_category> {
3951 static bool check(PyObject *obj) {
3952 int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3953 return SWIG_IsOK(res) ? true : false;
3957 template <class Type>
3958 inline bool check(PyObject *obj) {
3959 return traits_check<Type, typename traits<Type>::category>::check(obj);
3964 #include <functional>
3968 struct less <PyObject *>
3971 operator()(PyObject * v, PyObject *w) const
3974 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3975 res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
3976 /* This may fall into a case of inconsistent
3977 eg. ObjA > ObjX > ObjB
3980 if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
3982 /* Objects can't be compared, this mostly occurred in Python 3.0 */
3983 /* Compare their ptr directly for a workaround */
3987 SWIG_PYTHON_THREAD_END_BLOCK;
3993 struct less <swig::SwigPtr_PyObject>
3996 operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
3998 return std::less<PyObject *>()(v, w);
4003 struct less <swig::SwigVar_PyObject>
4006 operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
4008 return std::less<PyObject *>()(v, w);
4015 template <> struct traits<PyObject *> {
4016 typedef value_category category;
4017 static const char* type_name() { return "PyObject *"; }
4020 template <> struct traits_asval<PyObject * > {
4021 typedef PyObject * value_type;
4022 static int asval(PyObject *obj, value_type *val) {
4023 if (val) *val = obj;
4029 struct traits_check<PyObject *, value_category> {
4030 static bool check(PyObject *) {
4035 template <> struct traits_from<PyObject *> {
4036 typedef PyObject * value_type;
4037 static PyObject *from(const value_type& val) {
4046 template <class Difference>
4048 check_index(Difference i, size_t size, bool insert = false) {
4050 if ((size_t) (-i) <= size)
4051 return (size_t) (i + size);
4052 } else if ( (size_t) i < size ) {
4054 } else if (insert && ((size_t) i == size)) {
4057 throw std::out_of_range("index out of range");
4060 template <class Difference>
4062 slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
4064 throw std::invalid_argument("slice step cannot be zero");
4065 } else if (step > 0) {
4066 // Required range: 0 <= i < size, 0 <= j < size, i <= j
4069 } else if (i < (Difference)size) {
4071 } else if (insert && (i >= (Difference)size)) {
4072 ii = (Difference)size;
4077 jj = (j < (Difference)size) ? j : (Difference)size;
4082 // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
4085 } else if (i < (Difference) size) {
4087 } else if (i >= (Difference)(size-1)) {
4088 ii = (Difference)(size-1);
4093 jj = (j < (Difference)size ) ? j : (Difference)(size-1);
4100 template <class Sequence, class Difference>
4101 inline typename Sequence::iterator
4102 getpos(Sequence* self, Difference i) {
4103 typename Sequence::iterator pos = self->begin();
4104 std::advance(pos, check_index(i,self->size()));
4108 template <class Sequence, class Difference>
4109 inline typename Sequence::const_iterator
4110 cgetpos(const Sequence* self, Difference i) {
4111 typename Sequence::const_iterator pos = self->begin();
4112 std::advance(pos, check_index(i,self->size()));
4116 template <class Sequence>
4118 erase(Sequence* seq, const typename Sequence::iterator& position) {
4119 seq->erase(position);
4122 template <class Sequence>
4123 struct traits_reserve {
4124 static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
4125 // This should be specialized for types that support reserve
4129 template <class Sequence, class Difference>
4131 getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4132 typename Sequence::size_type size = self->size();
4135 swig::slice_adjust(i, j, step, size, ii, jj);
4138 typename Sequence::const_iterator sb = self->begin();
4139 typename Sequence::const_iterator se = self->begin();
4140 std::advance(sb,ii);
4141 std::advance(se,jj);
4143 return new Sequence(sb, se);
4145 Sequence *sequence = new Sequence();
4146 swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
4147 typename Sequence::const_iterator it = sb;
4149 sequence->push_back(*it);
4150 for (Py_ssize_t c=0; c<step && it!=se; ++c)
4156 Sequence *sequence = new Sequence();
4157 swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
4158 typename Sequence::const_reverse_iterator sb = self->rbegin();
4159 typename Sequence::const_reverse_iterator se = self->rbegin();
4160 std::advance(sb,size-ii-1);
4161 std::advance(se,size-jj-1);
4162 typename Sequence::const_reverse_iterator it = sb;
4164 sequence->push_back(*it);
4165 for (Py_ssize_t c=0; c<-step && it!=se; ++c)
4172 template <class Sequence, class Difference, class InputSeq>
4174 setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
4175 typename Sequence::size_type size = self->size();
4178 swig::slice_adjust(i, j, step, size, ii, jj, true);
4181 size_t ssize = jj - ii;
4182 if (ssize <= is.size()) {
4183 // expanding/staying the same size
4184 swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
4185 typename Sequence::iterator sb = self->begin();
4186 typename InputSeq::const_iterator isit = is.begin();
4187 std::advance(sb,ii);
4188 std::advance(isit, jj - ii);
4189 self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
4192 typename Sequence::iterator sb = self->begin();
4193 typename Sequence::iterator se = self->begin();
4194 std::advance(sb,ii);
4195 std::advance(se,jj);
4198 std::advance(sb,ii);
4199 self->insert(sb, is.begin(), is.end());
4202 size_t replacecount = (jj - ii + step - 1) / step;
4203 if (is.size() != replacecount) {
4205 sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4206 throw std::invalid_argument(msg);
4208 typename Sequence::const_iterator isit = is.begin();
4209 typename Sequence::iterator it = self->begin();
4210 std::advance(it,ii);
4211 for (size_t rc=0; rc<replacecount; ++rc) {
4213 for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4218 size_t replacecount = (ii - jj - step - 1) / -step;
4219 if (is.size() != replacecount) {
4221 sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4222 throw std::invalid_argument(msg);
4224 typename Sequence::const_iterator isit = is.begin();
4225 typename Sequence::reverse_iterator it = self->rbegin();
4226 std::advance(it,size-ii-1);
4227 for (size_t rc=0; rc<replacecount; ++rc) {
4229 for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4235 template <class Sequence, class Difference>
4237 delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4238 typename Sequence::size_type size = self->size();
4241 swig::slice_adjust(i, j, step, size, ii, jj, true);
4243 typename Sequence::iterator sb = self->begin();
4244 std::advance(sb,ii);
4246 typename Sequence::iterator se = self->begin();
4247 std::advance(se,jj);
4250 typename Sequence::iterator it = sb;
4251 size_t delcount = (jj - ii + step - 1) / step;
4253 it = self->erase(it);
4254 for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4260 typename Sequence::reverse_iterator sb = self->rbegin();
4261 std::advance(sb,size-ii-1);
4262 typename Sequence::reverse_iterator it = sb;
4263 size_t delcount = (ii - jj - step - 1) / -step;
4265 it = typename Sequence::reverse_iterator(self->erase((++it).base()));
4266 for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4275 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
4276 # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
4277 # define SWIG_STD_NOITERATOR_TRAITS_STL
4281 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
4285 template <class Iterator>
4286 struct iterator_traits {
4287 typedef ptrdiff_t difference_type;
4288 typedef typename Iterator::value_type value_type;
4291 template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
4292 struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
4293 typedef Distance difference_type;
4294 typedef T value_type;
4298 struct iterator_traits<T*> {
4299 typedef T value_type;
4300 typedef ptrdiff_t difference_type;
4303 template<typename _InputIterator>
4304 inline typename iterator_traits<_InputIterator>::difference_type
4305 distance(_InputIterator __first, _InputIterator __last)
4307 typename iterator_traits<_InputIterator>::difference_type __n = 0;
4308 while (__first != __last) {
4318 template<typename OutIterator>
4319 class SwigPyIterator_T : public SwigPyIterator
4322 typedef OutIterator out_iterator;
4323 typedef typename std::iterator_traits<out_iterator>::value_type value_type;
4324 typedef SwigPyIterator_T<out_iterator> self_type;
4326 SwigPyIterator_T(out_iterator curr, PyObject *seq)
4327 : SwigPyIterator(seq), current(curr)
4331 const out_iterator& get_current() const
4337 bool equal (const SwigPyIterator &iter) const
4339 const self_type *iters = dynamic_cast<const self_type *>(&iter);
4341 return (current == iters->get_current());
4343 throw std::invalid_argument("bad iterator type");
4347 ptrdiff_t distance(const SwigPyIterator &iter) const
4349 const self_type *iters = dynamic_cast<const self_type *>(&iter);
4351 return std::distance(current, iters->get_current());
4353 throw std::invalid_argument("bad iterator type");
4358 out_iterator current;
4361 template <class ValueType>
4364 typedef const ValueType& argument_type;
4365 typedef PyObject *result_type;
4366 result_type operator()(argument_type v) const
4368 return swig::from(v);
4372 template<typename OutIterator,
4373 typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4374 typename FromOper = from_oper<ValueType> >
4375 class SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
4379 typedef OutIterator out_iterator;
4380 typedef ValueType value_type;
4381 typedef SwigPyIterator_T<out_iterator> base;
4382 typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
4384 SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
4385 : SwigPyIterator_T<OutIterator>(curr, seq)
4389 PyObject *value() const {
4390 return from(static_cast<const value_type&>(*(base::current)));
4393 SwigPyIterator *copy() const
4395 return new self_type(*this);
4398 SwigPyIterator *incr(size_t n = 1)
4406 SwigPyIterator *decr(size_t n = 1)
4415 template<typename OutIterator,
4416 typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4417 typename FromOper = from_oper<ValueType> >
4418 class SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
4422 typedef OutIterator out_iterator;
4423 typedef ValueType value_type;
4424 typedef SwigPyIterator_T<out_iterator> base;
4425 typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
4427 SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4428 : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
4432 PyObject *value() const {
4433 if (base::current == end) {
4434 throw stop_iteration();
4436 return from(static_cast<const value_type&>(*(base::current)));
4440 SwigPyIterator *copy() const
4442 return new self_type(*this);
4445 SwigPyIterator *incr(size_t n = 1)
4448 if (base::current == end) {
4449 throw stop_iteration();
4457 SwigPyIterator *decr(size_t n = 1)
4460 if (base::current == begin) {
4461 throw stop_iteration();
4474 template<typename OutIter>
4475 inline SwigPyIterator*
4476 make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4478 return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
4481 template<typename OutIter>
4482 inline SwigPyIterator*
4483 make_output_iterator(const OutIter& current, PyObject *seq = 0)
4485 return new SwigPyIteratorOpen_T<OutIter>(current, seq);
4494 struct SwigPySequence_Ref
4496 SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
4497 : _seq(seq), _index(index)
4503 swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
4505 return swig::as<T>(item, true);
4506 } catch (std::exception& e) {
4508 sprintf(msg, "in sequence element %d ", (int)_index);
4509 if (!PyErr_Occurred()) {
4510 ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
4512 SWIG_Python_AddErrorMsg(msg);
4513 SWIG_Python_AddErrorMsg(e.what());
4518 SwigPySequence_Ref& operator=(const T& v)
4520 PySequence_SetItem(_seq, _index, swig::from<T>(v));
4530 struct SwigPySequence_ArrowProxy
4532 SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
4533 const T* operator->() const { return &m_value; }
4534 operator const T*() const { return &m_value; }
4538 template <class T, class Reference >
4539 struct SwigPySequence_InputIterator
4541 typedef SwigPySequence_InputIterator<T, Reference > self;
4543 typedef std::random_access_iterator_tag iterator_category;
4544 typedef Reference reference;
4545 typedef T value_type;
4547 typedef Py_ssize_t difference_type;
4549 SwigPySequence_InputIterator()
4553 SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
4554 : _seq(seq), _index(index)
4558 reference operator*() const
4560 return reference(_seq, _index);
4563 SwigPySequence_ArrowProxy<T>
4564 operator->() const {
4565 return SwigPySequence_ArrowProxy<T>(operator*());
4568 bool operator==(const self& ri) const
4570 return (_index == ri._index) && (_seq == ri._seq);
4573 bool operator!=(const self& ri) const
4575 return !(operator==(ri));
4578 self& operator ++ ()
4584 self& operator -- ()
4590 self& operator += (difference_type n)
4596 self operator +(difference_type n) const
4598 return self(_seq, _index + n);
4601 self& operator -= (difference_type n)
4607 self operator -(difference_type n) const
4609 return self(_seq, _index - n);
4612 difference_type operator - (const self& ri) const
4614 return _index - ri._index;
4617 bool operator < (const self& ri) const
4619 return _index < ri._index;
4623 operator[](difference_type n) const
4625 return reference(_seq, _index + n);
4630 difference_type _index;
4633 // STL container wrapper around a Python sequence
4635 struct SwigPySequence_Cont
4637 typedef SwigPySequence_Ref<T> reference;
4638 typedef const SwigPySequence_Ref<T> const_reference;
4639 typedef T value_type;
4641 typedef Py_ssize_t difference_type;
4642 typedef size_t size_type;
4643 typedef const pointer const_pointer;
4644 typedef SwigPySequence_InputIterator<T, reference> iterator;
4645 typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
4647 SwigPySequence_Cont(PyObject* seq) : _seq(0)
4649 if (!PySequence_Check(seq)) {
4650 throw std::invalid_argument("a sequence is expected");
4656 ~SwigPySequence_Cont()
4661 size_type size() const
4663 return static_cast<size_type>(PySequence_Size(_seq));
4673 return iterator(_seq, 0);
4676 const_iterator begin() const
4678 return const_iterator(_seq, 0);
4683 return iterator(_seq, size());
4686 const_iterator end() const
4688 return const_iterator(_seq, size());
4691 reference operator[](difference_type n)
4693 return reference(_seq, n);
4696 const_reference operator[](difference_type n) const
4698 return const_reference(_seq, n);
4701 bool check(bool set_err = true) const
4703 Py_ssize_t s = size();
4704 for (Py_ssize_t i = 0; i < s; ++i) {
4705 swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
4706 if (!swig::check<value_type>(item)) {
4709 sprintf(msg, "in sequence element %d", (int)i);
4710 SWIG_Error(SWIG_RuntimeError, msg);
4726 template <> struct traits< Hex::Hexa > {
4727 typedef pointer_category category;
4728 static const char* type_name() { return"Hex::Hexa"; }
4734 template <class SwigPySeq, class Seq>
4736 assign(const SwigPySeq& swigpyseq, Seq* seq) {
4737 // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
4738 typedef typename SwigPySeq::value_type value_type;
4739 typename SwigPySeq::const_iterator it = swigpyseq.begin();
4740 for (;it != swigpyseq.end(); ++it) {
4741 seq->insert(seq->end(),(value_type)(*it));
4745 template <class Seq, class T = typename Seq::value_type >
4746 struct traits_asptr_stdseq {
4747 typedef Seq sequence;
4748 typedef T value_type;
4750 static int asptr(PyObject *obj, sequence **seq) {
4751 if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
4753 swig_type_info *descriptor = swig::type_info<sequence>();
4754 if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
4758 } else if (PySequence_Check(obj)) {
4760 SwigPySequence_Cont<value_type> swigpyseq(obj);
4762 sequence *pseq = new sequence();
4763 assign(swigpyseq, pseq);
4767 return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
4769 } catch (std::exception& e) {
4771 if (!PyErr_Occurred()) {
4772 PyErr_SetString(PyExc_TypeError, e.what());
4782 template <class Seq, class T = typename Seq::value_type >
4783 struct traits_from_stdseq {
4784 typedef Seq sequence;
4785 typedef T value_type;
4786 typedef typename Seq::size_type size_type;
4787 typedef typename sequence::const_iterator const_iterator;
4789 static PyObject *from(const sequence& seq) {
4790 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
4791 swig_type_info *desc = swig::type_info<sequence>();
4792 if (desc && desc->clientdata) {
4793 return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
4796 size_type size = seq.size();
4797 if (size <= (size_type)INT_MAX) {
4798 PyObject *obj = PyTuple_New((Py_ssize_t)size);
4800 for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
4801 PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
4805 PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
4815 struct traits_reserve<std::vector<T> > {
4816 static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
4822 struct traits_asptr<std::vector<T> > {
4823 static int asptr(PyObject *obj, std::vector<T> **vec) {
4824 return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
4829 struct traits_from<std::vector<T> > {
4830 static PyObject *from(const std::vector<T>& vec) {
4831 return traits_from_stdseq<std::vector<T> >::from(vec);
4838 template <> struct traits<std::vector< Hex::Hexa*, std::allocator< Hex::Hexa * > > > {
4839 typedef value_category category;
4840 static const char* type_name() {
4841 return "std::vector<" "Hex::Hexa" " *," "std::allocator< Hex::Hexa * >" " >";
4846 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector< Hex::Hexa * > *self,PyObject **PYTHON_SELF){
4847 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4849 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector< Hex::Hexa * > const *self){
4850 return !(self->empty());
4852 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____bool__(std::vector< Hex::Hexa * > const *self){
4853 return !(self->empty());
4855 SWIGINTERN std::vector< Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector< Hex::Hexa * > const *self){
4856 return self->size();
4859 SWIGINTERNINLINE PyObject*
4860 SWIG_From_unsigned_SS_long (unsigned long value)
4862 return (value > LONG_MAX) ?
4863 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4867 #ifdef SWIG_LONG_LONG_AVAILABLE
4868 SWIGINTERNINLINE PyObject*
4869 SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
4871 return (value > LONG_MAX) ?
4872 PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
4877 SWIGINTERNINLINE PyObject *
4878 SWIG_From_size_t (size_t value)
4880 #ifdef SWIG_LONG_LONG_AVAILABLE
4881 if (sizeof(size_t) <= sizeof(unsigned long)) {
4883 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
4884 #ifdef SWIG_LONG_LONG_AVAILABLE
4886 /* assume sizeof(size_t) <= sizeof(unsigned long long) */
4887 return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
4892 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){
4893 return swig::getslice(self, i, j, 1);
4895 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j){
4896 swig::setslice(self, i, j, 1, std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >());
4898 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_1(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){
4899 swig::setslice(self, i, j, 1, v);
4901 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){
4902 swig::delslice(self, i, j, 1);
4904 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4905 swig::erase(self, swig::getpos(self, i));
4907 SWIGINTERN std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4908 Py_ssize_t i, j, step;
4909 if( !PySlice_Check(slice) ) {
4910 SWIG_Error(SWIG_TypeError, "Slice object expected.");
4913 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4914 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4915 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4916 return swig::getslice(self, id, jd, step);
4918 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &v){
4919 Py_ssize_t i, j, step;
4920 if( !PySlice_Check(slice) ) {
4921 SWIG_Error(SWIG_TypeError, "Slice object expected.");
4924 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4925 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4926 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4927 swig::setslice(self, id, jd, step, v);
4929 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4930 Py_ssize_t i, j, step;
4931 if( !PySlice_Check(slice) ) {
4932 SWIG_Error(SWIG_TypeError, "Slice object expected.");
4935 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4936 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4937 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4938 swig::delslice(self, id, jd, step);
4940 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4941 Py_ssize_t i, j, step;
4942 if( !PySlice_Check(slice) ) {
4943 SWIG_Error(SWIG_TypeError, "Slice object expected.");
4946 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4947 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4948 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4949 swig::delslice(self, id, jd, step);
4951 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4952 return *(swig::cgetpos(self, i));
4954 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::value_type x){
4955 *(swig::getpos(self,i)) = x;
4957 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector< Hex::Hexa * > *self){
4958 if (self->size() == 0)
4959 throw std::out_of_range("pop from empty container");
4960 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::value_type x = self->back();
4964 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::value_type x){
4967 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos){ return self->erase(pos); }
4968 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator first,std::vector< Hex::Hexa * >::iterator last){ return self->erase(first, last); }
4969 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos,std::vector< Hex::Hexa * >::value_type x){ return self->insert(pos, x); }
4970 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos,std::vector< Hex::Hexa * >::size_type n,std::vector< Hex::Hexa * >::value_type x){ self->insert(pos, n, x); }
4973 template <> struct traits< Hex::Quad > {
4974 typedef pointer_category category;
4975 static const char* type_name() { return"Hex::Quad"; }
4981 template <> struct traits<std::vector< Hex::Quad*, std::allocator< Hex::Quad * > > > {
4982 typedef value_category category;
4983 static const char* type_name() {
4984 return "std::vector<" "Hex::Quad" " *," "std::allocator< Hex::Quad * >" " >";
4989 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector< Hex::Quad * > *self,PyObject **PYTHON_SELF){
4990 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4992 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector< Hex::Quad * > const *self){
4993 return !(self->empty());
4995 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____bool__(std::vector< Hex::Quad * > const *self){
4996 return !(self->empty());
4998 SWIGINTERN std::vector< Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector< Hex::Quad * > const *self){
4999 return self->size();
5001 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){
5002 return swig::getslice(self, i, j, 1);
5004 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j){
5005 swig::setslice(self, i, j, 1, std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >());
5007 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_1(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){
5008 swig::setslice(self, i, j, 1, v);
5010 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){
5011 swig::delslice(self, i, j, 1);
5013 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
5014 swig::erase(self, swig::getpos(self, i));
5016 SWIGINTERN std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5017 Py_ssize_t i, j, step;
5018 if( !PySlice_Check(slice) ) {
5019 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5022 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5023 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5024 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5025 return swig::getslice(self, id, jd, step);
5027 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &v){
5028 Py_ssize_t i, j, step;
5029 if( !PySlice_Check(slice) ) {
5030 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5033 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5034 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5035 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5036 swig::setslice(self, id, jd, step, v);
5038 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5039 Py_ssize_t i, j, step;
5040 if( !PySlice_Check(slice) ) {
5041 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5044 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5045 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5046 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5047 swig::delslice(self, id, jd, step);
5049 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5050 Py_ssize_t i, j, step;
5051 if( !PySlice_Check(slice) ) {
5052 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5055 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5056 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5057 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5058 swig::delslice(self, id, jd, step);
5060 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
5061 return *(swig::cgetpos(self, i));
5063 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::value_type x){
5064 *(swig::getpos(self,i)) = x;
5066 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector< Hex::Quad * > *self){
5067 if (self->size() == 0)
5068 throw std::out_of_range("pop from empty container");
5069 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::value_type x = self->back();
5073 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::value_type x){
5076 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos){ return self->erase(pos); }
5077 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator first,std::vector< Hex::Quad * >::iterator last){ return self->erase(first, last); }
5078 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos,std::vector< Hex::Quad * >::value_type x){ return self->insert(pos, x); }
5079 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos,std::vector< Hex::Quad * >::size_type n,std::vector< Hex::Quad * >::value_type x){ self->insert(pos, n, x); }
5082 template <> struct traits< Hex::Edge > {
5083 typedef pointer_category category;
5084 static const char* type_name() { return"Hex::Edge"; }
5090 template <> struct traits<std::vector< Hex::Edge*, std::allocator< Hex::Edge * > > > {
5091 typedef value_category category;
5092 static const char* type_name() {
5093 return "std::vector<" "Hex::Edge" " *," "std::allocator< Hex::Edge * >" " >";
5098 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector< Hex::Edge * > *self,PyObject **PYTHON_SELF){
5099 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5101 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector< Hex::Edge * > const *self){
5102 return !(self->empty());
5104 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____bool__(std::vector< Hex::Edge * > const *self){
5105 return !(self->empty());
5107 SWIGINTERN std::vector< Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector< Hex::Edge * > const *self){
5108 return self->size();
5110 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){
5111 return swig::getslice(self, i, j, 1);
5113 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j){
5114 swig::setslice(self, i, j, 1, std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >());
5116 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_1(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){
5117 swig::setslice(self, i, j, 1, v);
5119 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){
5120 swig::delslice(self, i, j, 1);
5122 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
5123 swig::erase(self, swig::getpos(self, i));
5125 SWIGINTERN std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5126 Py_ssize_t i, j, step;
5127 if( !PySlice_Check(slice) ) {
5128 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5131 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5132 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5133 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5134 return swig::getslice(self, id, jd, step);
5136 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &v){
5137 Py_ssize_t i, j, step;
5138 if( !PySlice_Check(slice) ) {
5139 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5142 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5143 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5144 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5145 swig::setslice(self, id, jd, step, v);
5147 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5148 Py_ssize_t i, j, step;
5149 if( !PySlice_Check(slice) ) {
5150 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5153 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5154 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5155 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5156 swig::delslice(self, id, jd, step);
5158 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5159 Py_ssize_t i, j, step;
5160 if( !PySlice_Check(slice) ) {
5161 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5164 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5165 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5166 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5167 swig::delslice(self, id, jd, step);
5169 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
5170 return *(swig::cgetpos(self, i));
5172 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::value_type x){
5173 *(swig::getpos(self,i)) = x;
5175 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector< Hex::Edge * > *self){
5176 if (self->size() == 0)
5177 throw std::out_of_range("pop from empty container");
5178 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::value_type x = self->back();
5182 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::value_type x){
5185 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos){ return self->erase(pos); }
5186 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator first,std::vector< Hex::Edge * >::iterator last){ return self->erase(first, last); }
5187 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos,std::vector< Hex::Edge * >::value_type x){ return self->insert(pos, x); }
5188 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos,std::vector< Hex::Edge * >::size_type n,std::vector< Hex::Edge * >::value_type x){ self->insert(pos, n, x); }
5191 template <> struct traits< Hex::Vertex > {
5192 typedef pointer_category category;
5193 static const char* type_name() { return"Hex::Vertex"; }
5199 template <> struct traits<std::vector< Hex::Vertex*, std::allocator< Hex::Vertex * > > > {
5200 typedef value_category category;
5201 static const char* type_name() {
5202 return "std::vector<" "Hex::Vertex" " *," "std::allocator< Hex::Vertex * >" " >";
5207 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector< Hex::Vertex * > *self,PyObject **PYTHON_SELF){
5208 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5210 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector< Hex::Vertex * > const *self){
5211 return !(self->empty());
5213 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____bool__(std::vector< Hex::Vertex * > const *self){
5214 return !(self->empty());
5216 SWIGINTERN std::vector< Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector< Hex::Vertex * > const *self){
5217 return self->size();
5219 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){
5220 return swig::getslice(self, i, j, 1);
5222 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j){
5223 swig::setslice(self, i, j, 1, std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >());
5225 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_1(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){
5226 swig::setslice(self, i, j, 1, v);
5228 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){
5229 swig::delslice(self, i, j, 1);
5231 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
5232 swig::erase(self, swig::getpos(self, i));
5234 SWIGINTERN std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5235 Py_ssize_t i, j, step;
5236 if( !PySlice_Check(slice) ) {
5237 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5240 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5241 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5242 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5243 return swig::getslice(self, id, jd, step);
5245 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &v){
5246 Py_ssize_t i, j, step;
5247 if( !PySlice_Check(slice) ) {
5248 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5251 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5252 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5253 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5254 swig::setslice(self, id, jd, step, v);
5256 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5257 Py_ssize_t i, j, step;
5258 if( !PySlice_Check(slice) ) {
5259 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5262 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5263 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5264 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5265 swig::delslice(self, id, jd, step);
5267 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5268 Py_ssize_t i, j, step;
5269 if( !PySlice_Check(slice) ) {
5270 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5273 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5274 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5275 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5276 swig::delslice(self, id, jd, step);
5278 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
5279 return *(swig::cgetpos(self, i));
5281 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::value_type x){
5282 *(swig::getpos(self,i)) = x;
5284 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector< Hex::Vertex * > *self){
5285 if (self->size() == 0)
5286 throw std::out_of_range("pop from empty container");
5287 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::value_type x = self->back();
5291 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::value_type x){
5294 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos){ return self->erase(pos); }
5295 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator first,std::vector< Hex::Vertex * >::iterator last){ return self->erase(first, last); }
5296 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos,std::vector< Hex::Vertex * >::value_type x){ return self->insert(pos, x); }
5297 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos,std::vector< Hex::Vertex * >::size_type n,std::vector< Hex::Vertex * >::value_type x){ self->insert(pos, n, x); }
5300 template <> struct traits< Hex::NewShape > {
5301 typedef pointer_category category;
5302 static const char* type_name() { return"Hex::NewShape"; }
5308 template <> struct traits<std::vector< Hex::NewShape*, std::allocator< Hex::NewShape * > > > {
5309 typedef value_category category;
5310 static const char* type_name() {
5311 return "std::vector<" "Hex::NewShape" " *," "std::allocator< Hex::NewShape * >" " >";
5316 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector< Hex::NewShape * > *self,PyObject **PYTHON_SELF){
5317 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5319 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector< Hex::NewShape * > const *self){
5320 return !(self->empty());
5322 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____bool__(std::vector< Hex::NewShape * > const *self){
5323 return !(self->empty());
5325 SWIGINTERN std::vector< Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector< Hex::NewShape * > const *self){
5326 return self->size();
5328 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){
5329 return swig::getslice(self, i, j, 1);
5331 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j){
5332 swig::setslice(self, i, j, 1, std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >());
5334 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_1(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){
5335 swig::setslice(self, i, j, 1, v);
5337 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){
5338 swig::delslice(self, i, j, 1);
5340 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
5341 swig::erase(self, swig::getpos(self, i));
5343 SWIGINTERN std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5344 Py_ssize_t i, j, step;
5345 if( !PySlice_Check(slice) ) {
5346 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5349 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5350 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5351 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5352 return swig::getslice(self, id, jd, step);
5354 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &v){
5355 Py_ssize_t i, j, step;
5356 if( !PySlice_Check(slice) ) {
5357 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5360 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5361 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5362 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5363 swig::setslice(self, id, jd, step, v);
5365 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5366 Py_ssize_t i, j, step;
5367 if( !PySlice_Check(slice) ) {
5368 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5371 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5372 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5373 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5374 swig::delslice(self, id, jd, step);
5376 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5377 Py_ssize_t i, j, step;
5378 if( !PySlice_Check(slice) ) {
5379 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5382 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5383 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5384 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5385 swig::delslice(self, id, jd, step);
5387 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
5388 return *(swig::cgetpos(self, i));
5390 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_2(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::value_type x){
5391 *(swig::getpos(self,i)) = x;
5393 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector< Hex::NewShape * > *self){
5394 if (self->size() == 0)
5395 throw std::out_of_range("pop from empty container");
5396 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::value_type x = self->back();
5400 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::value_type x){
5403 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos){ return self->erase(pos); }
5404 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator first,std::vector< Hex::NewShape * >::iterator last){ return self->erase(first, last); }
5405 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos,std::vector< Hex::NewShape * >::value_type x){ return self->insert(pos, x); }
5406 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos,std::vector< Hex::NewShape * >::size_type n,std::vector< Hex::NewShape * >::value_type x){ self->insert(pos, n, x); }
5408 #define SWIG_From_double PyFloat_FromDouble
5412 template <> struct traits< double > {
5413 typedef value_category category;
5414 static const char* type_name() { return"double"; }
5416 template <> struct traits_asval< double > {
5417 typedef double value_type;
5418 static int asval(PyObject *obj, value_type *val) {
5419 return SWIG_AsVal_double (obj, val);
5422 template <> struct traits_from< double > {
5423 typedef double value_type;
5424 static PyObject *from(const value_type& val) {
5425 return SWIG_From_double (val);
5432 template <> struct traits<std::vector< double, std::allocator< double > > > {
5433 typedef pointer_category category;
5434 static const char* type_name() {
5435 return "std::vector<" "double" "," "std::allocator< double >" " >";
5440 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
5441 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5443 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
5444 return !(self->empty());
5446 SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
5447 return !(self->empty());
5449 SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
5450 return self->size();
5452 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){
5453 return swig::getslice(self, i, j, 1);
5455 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5456 swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
5458 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
5459 swig::setslice(self, i, j, 1, v);
5461 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5462 swig::delslice(self, i, j, 1);
5464 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
5465 swig::erase(self, swig::getpos(self, i));
5467 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
5468 Py_ssize_t i, j, step;
5469 if( !PySlice_Check(slice) ) {
5470 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5473 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5474 std::vector< double,std::allocator< double > >::difference_type id = i;
5475 std::vector< double,std::allocator< double > >::difference_type jd = j;
5476 return swig::getslice(self, id, jd, step);
5478 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
5479 Py_ssize_t i, j, step;
5480 if( !PySlice_Check(slice) ) {
5481 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5484 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5485 std::vector< double,std::allocator< double > >::difference_type id = i;
5486 std::vector< double,std::allocator< double > >::difference_type jd = j;
5487 swig::setslice(self, id, jd, step, v);
5489 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5490 Py_ssize_t i, j, step;
5491 if( !PySlice_Check(slice) ) {
5492 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5495 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5496 std::vector< double,std::allocator< double > >::difference_type id = i;
5497 std::vector< double,std::allocator< double > >::difference_type jd = j;
5498 swig::delslice(self, id, jd, step);
5500 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5501 Py_ssize_t i, j, step;
5502 if( !PySlice_Check(slice) ) {
5503 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5506 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5507 std::vector< double,std::allocator< double > >::difference_type id = i;
5508 std::vector< double,std::allocator< double > >::difference_type jd = j;
5509 swig::delslice(self, id, jd, step);
5511 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
5512 return *(swig::cgetpos(self, i));
5514 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
5515 *(swig::getpos(self,i)) = x;
5517 SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
5518 if (self->size() == 0)
5519 throw std::out_of_range("pop from empty container");
5520 std::vector< double,std::allocator< double > >::value_type x = self->back();
5524 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
5527 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
5528 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
5529 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
5530 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
5533 SWIG_AsVal_int (PyObject * obj, int *val)
5536 int res = SWIG_AsVal_long (obj, &v);
5537 if (SWIG_IsOK(res)) {
5538 if ((v < INT_MIN || v > INT_MAX)) {
5539 return SWIG_OverflowError;
5541 if (val) *val = static_cast< int >(v);
5548 SWIGINTERNINLINE PyObject*
5549 SWIG_From_int (int value)
5551 return PyInt_FromLong((long) value);
5556 template <> struct traits< int > {
5557 typedef value_category category;
5558 static const char* type_name() { return"int"; }
5560 template <> struct traits_asval< int > {
5561 typedef int value_type;
5562 static int asval(PyObject *obj, value_type *val) {
5563 return SWIG_AsVal_int (obj, val);
5566 template <> struct traits_from< int > {
5567 typedef int value_type;
5568 static PyObject *from(const value_type& val) {
5569 return SWIG_From_int (val);
5576 template <> struct traits<std::vector< int, std::allocator< int > > > {
5577 typedef pointer_category category;
5578 static const char* type_name() {
5579 return "std::vector<" "int" "," "std::allocator< int >" " >";
5584 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
5585 return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5587 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
5588 return !(self->empty());
5590 SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
5591 return !(self->empty());
5593 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
5594 return self->size();
5596 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){
5597 return swig::getslice(self, i, j, 1);
5599 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
5600 swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
5602 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
5603 swig::setslice(self, i, j, 1, v);
5605 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
5606 swig::delslice(self, i, j, 1);
5608 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
5609 swig::erase(self, swig::getpos(self, i));
5611 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
5612 Py_ssize_t i, j, step;
5613 if( !PySlice_Check(slice) ) {
5614 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5617 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5618 std::vector< int,std::allocator< int > >::difference_type id = i;
5619 std::vector< int,std::allocator< int > >::difference_type jd = j;
5620 return swig::getslice(self, id, jd, step);
5622 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
5623 Py_ssize_t i, j, step;
5624 if( !PySlice_Check(slice) ) {
5625 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5628 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5629 std::vector< int,std::allocator< int > >::difference_type id = i;
5630 std::vector< int,std::allocator< int > >::difference_type jd = j;
5631 swig::setslice(self, id, jd, step, v);
5633 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
5634 Py_ssize_t i, j, step;
5635 if( !PySlice_Check(slice) ) {
5636 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5639 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5640 std::vector< int,std::allocator< int > >::difference_type id = i;
5641 std::vector< int,std::allocator< int > >::difference_type jd = j;
5642 swig::delslice(self, id, jd, step);
5644 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
5645 Py_ssize_t i, j, step;
5646 if( !PySlice_Check(slice) ) {
5647 SWIG_Error(SWIG_TypeError, "Slice object expected.");
5650 PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5651 std::vector< int,std::allocator< int > >::difference_type id = i;
5652 std::vector< int,std::allocator< int > >::difference_type jd = j;
5653 swig::delslice(self, id, jd, step);
5655 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
5656 return *(swig::cgetpos(self, i));
5658 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
5659 *(swig::getpos(self,i)) = x;
5661 SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
5662 if (self->size() == 0)
5663 throw std::out_of_range("pop from empty container");
5664 std::vector< int,std::allocator< int > >::value_type x = self->back();
5668 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
5671 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
5672 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
5673 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
5674 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
5676 SWIGINTERN swig_type_info*
5677 SWIG_pchar_descriptor(void)
5679 static int init = 0;
5680 static swig_type_info* info = 0;
5682 info = SWIG_TypeQuery("_p_char");
5689 SWIGINTERNINLINE PyObject *
5690 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
5693 if (size > INT_MAX) {
5694 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
5695 return pchar_descriptor ?
5696 SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
5698 #if PY_VERSION_HEX >= 0x03000000
5699 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5700 return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5702 #if PY_VERSION_HEX >= 0x03010000
5703 return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
5705 return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5709 return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5713 return SWIG_Py_Void();
5718 SWIGINTERNINLINE PyObject *
5719 SWIG_From_char (char c)
5721 return SWIG_FromCharPtrAndSize(&c,1);
5725 SWIGINTERNINLINE PyObject *
5726 SWIG_FromCharPtr(const char *cptr)
5728 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
5733 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
5735 #if PY_VERSION_HEX>=0x03000000
5736 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5737 if (PyBytes_Check(obj))
5739 if (PyUnicode_Check(obj))
5742 if (PyString_Check(obj))
5745 char *cstr; Py_ssize_t len;
5746 #if PY_VERSION_HEX>=0x03000000
5747 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5748 if (!alloc && cptr) {
5749 /* We can't allow converting without allocation, since the internal
5750 representation of string in Python 3 is UCS-2/UCS-4 but we require
5751 a UTF-8 representation.
5752 TODO(bhy) More detailed explanation */
5753 return SWIG_RuntimeError;
5755 obj = PyUnicode_AsUTF8String(obj);
5756 if(alloc) *alloc = SWIG_NEWOBJ;
5758 PyBytes_AsStringAndSize(obj, &cstr, &len);
5760 PyString_AsStringAndSize(obj, &cstr, &len);
5765 In python the user should not be able to modify the inner
5766 string representation. To warranty that, if you define
5767 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
5768 buffer is always returned.
5770 The default behavior is just to return the pointer value,
5773 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
5774 if (*alloc != SWIG_OLDOBJ)
5776 if (*alloc == SWIG_NEWOBJ)
5779 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
5780 *alloc = SWIG_NEWOBJ;
5783 *alloc = SWIG_OLDOBJ;
5786 #if PY_VERSION_HEX>=0x03000000
5787 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5788 *cptr = PyBytes_AsString(obj);
5790 assert(0); /* Should never reach here with Unicode strings in Python 3 */
5793 *cptr = SWIG_Python_str_AsChar(obj);
5797 if (psize) *psize = len + 1;
5798 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5803 #if defined(SWIG_PYTHON_2_UNICODE)
5804 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5805 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
5807 #if PY_VERSION_HEX<0x03000000
5808 if (PyUnicode_Check(obj)) {
5809 char *cstr; Py_ssize_t len;
5810 if (!alloc && cptr) {
5811 return SWIG_RuntimeError;
5813 obj = PyUnicode_AsUTF8String(obj);
5814 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
5816 if (alloc) *alloc = SWIG_NEWOBJ;
5817 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
5819 if (psize) *psize = len + 1;
5830 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
5831 if (pchar_descriptor) {
5833 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
5834 if (cptr) *cptr = (char *) vptr;
5835 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
5836 if (alloc) *alloc = SWIG_OLDOBJ;
5841 return SWIG_TypeError;
5849 SWIG_AsVal_bool (PyObject *obj, bool *val)
5852 if (!PyBool_Check(obj))
5854 r = PyObject_IsTrue(obj);
5857 if (val) *val = r ? true : false;
5864 SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5865 PyObject *resultobj = 0;
5866 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5869 PyObject * obj0 = 0 ;
5871 if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
5872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
5873 if (!SWIG_IsOK(res1)) {
5874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5876 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5878 resultobj = SWIG_Py_Void();
5885 SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5886 PyObject *resultobj = 0;
5887 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5890 PyObject * obj0 = 0 ;
5891 PyObject *result = 0 ;
5893 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
5894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5895 if (!SWIG_IsOK(res1)) {
5896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5898 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5900 result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
5902 catch(swig::stop_iteration &_e) {
5905 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5917 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5918 PyObject *resultobj = 0;
5919 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 swig::SwigPyIterator *result = 0 ;
5929 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
5930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5931 if (!SWIG_IsOK(res1)) {
5932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5934 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5935 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5936 if (!SWIG_IsOK(ecode2)) {
5937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
5939 arg2 = static_cast< size_t >(val2);
5941 result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
5943 catch(swig::stop_iteration &_e) {
5946 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5958 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5959 PyObject *resultobj = 0;
5960 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5963 PyObject * obj0 = 0 ;
5964 swig::SwigPyIterator *result = 0 ;
5966 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
5967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5968 if (!SWIG_IsOK(res1)) {
5969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5971 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5973 result = (swig::SwigPyIterator *)(arg1)->incr();
5975 catch(swig::stop_iteration &_e) {
5978 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5990 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
5992 PyObject *argv[3] = {
5997 if (!PyTuple_Check(args)) SWIG_fail;
5998 argc = args ? PyObject_Length(args) : 0;
5999 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6000 argv[ii] = PyTuple_GET_ITEM(args,ii);
6005 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6006 _v = SWIG_CheckState(res);
6008 return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
6014 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6015 _v = SWIG_CheckState(res);
6018 int res = SWIG_AsVal_size_t(argv[1], NULL);
6019 _v = SWIG_CheckState(res);
6022 return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
6028 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
6029 " Possible C/C++ prototypes are:\n"
6030 " swig::SwigPyIterator::incr(size_t)\n"
6031 " swig::SwigPyIterator::incr()\n");
6036 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6037 PyObject *resultobj = 0;
6038 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 swig::SwigPyIterator *result = 0 ;
6048 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
6049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6050 if (!SWIG_IsOK(res1)) {
6051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6053 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6054 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6055 if (!SWIG_IsOK(ecode2)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
6058 arg2 = static_cast< size_t >(val2);
6060 result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
6062 catch(swig::stop_iteration &_e) {
6065 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6077 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078 PyObject *resultobj = 0;
6079 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6082 PyObject * obj0 = 0 ;
6083 swig::SwigPyIterator *result = 0 ;
6085 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
6086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6087 if (!SWIG_IsOK(res1)) {
6088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6090 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6092 result = (swig::SwigPyIterator *)(arg1)->decr();
6094 catch(swig::stop_iteration &_e) {
6097 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6109 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
6111 PyObject *argv[3] = {
6116 if (!PyTuple_Check(args)) SWIG_fail;
6117 argc = args ? PyObject_Length(args) : 0;
6118 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6119 argv[ii] = PyTuple_GET_ITEM(args,ii);
6124 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6125 _v = SWIG_CheckState(res);
6127 return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
6133 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6134 _v = SWIG_CheckState(res);
6137 int res = SWIG_AsVal_size_t(argv[1], NULL);
6138 _v = SWIG_CheckState(res);
6141 return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
6147 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
6148 " Possible C/C++ prototypes are:\n"
6149 " swig::SwigPyIterator::decr(size_t)\n"
6150 " swig::SwigPyIterator::decr()\n");
6155 SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156 PyObject *resultobj = 0;
6157 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6158 swig::SwigPyIterator *arg2 = 0 ;
6163 PyObject * obj0 = 0 ;
6164 PyObject * obj1 = 0 ;
6167 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
6168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6169 if (!SWIG_IsOK(res1)) {
6170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6172 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6174 if (!SWIG_IsOK(res2)) {
6175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6180 arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6182 result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
6184 catch(std::invalid_argument &_e) {
6185 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;
6188 resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
6195 SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196 PyObject *resultobj = 0;
6197 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6198 swig::SwigPyIterator *arg2 = 0 ;
6203 PyObject * obj0 = 0 ;
6204 PyObject * obj1 = 0 ;
6207 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
6208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6209 if (!SWIG_IsOK(res1)) {
6210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6212 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6213 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6214 if (!SWIG_IsOK(res2)) {
6215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6220 arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6222 result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
6224 catch(std::invalid_argument &_e) {
6225 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;
6228 resultobj = SWIG_From_bool(static_cast< bool >(result));
6235 SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6236 PyObject *resultobj = 0;
6237 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6240 PyObject * obj0 = 0 ;
6241 swig::SwigPyIterator *result = 0 ;
6243 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
6244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6245 if (!SWIG_IsOK(res1)) {
6246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6248 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6249 result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
6250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6257 SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258 PyObject *resultobj = 0;
6259 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6262 PyObject * obj0 = 0 ;
6263 PyObject *result = 0 ;
6265 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
6266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6267 if (!SWIG_IsOK(res1)) {
6268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6270 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6272 result = (PyObject *)(arg1)->next();
6274 catch(swig::stop_iteration &_e) {
6277 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6289 SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6290 PyObject *resultobj = 0;
6291 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject *result = 0 ;
6297 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
6298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6299 if (!SWIG_IsOK(res1)) {
6300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6302 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6304 result = (PyObject *)(arg1)->__next__();
6306 catch(swig::stop_iteration &_e) {
6309 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6321 SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6322 PyObject *resultobj = 0;
6323 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6326 PyObject * obj0 = 0 ;
6327 PyObject *result = 0 ;
6329 if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
6330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6331 if (!SWIG_IsOK(res1)) {
6332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6334 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6336 result = (PyObject *)(arg1)->previous();
6338 catch(swig::stop_iteration &_e) {
6341 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6353 SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6354 PyObject *resultobj = 0;
6355 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6361 PyObject * obj0 = 0 ;
6362 PyObject * obj1 = 0 ;
6363 swig::SwigPyIterator *result = 0 ;
6365 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
6366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6370 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6371 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6372 if (!SWIG_IsOK(ecode2)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
6375 arg2 = static_cast< ptrdiff_t >(val2);
6377 result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
6379 catch(swig::stop_iteration &_e) {
6382 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6394 SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6397 swig::SwigPyIterator *arg2 = 0 ;
6402 PyObject * obj0 = 0 ;
6403 PyObject * obj1 = 0 ;
6406 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
6407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6408 if (!SWIG_IsOK(res1)) {
6409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6411 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6412 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6413 if (!SWIG_IsOK(res2)) {
6414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6419 arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6420 result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
6421 resultobj = SWIG_From_bool(static_cast< bool >(result));
6428 SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6429 PyObject *resultobj = 0;
6430 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6431 swig::SwigPyIterator *arg2 = 0 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6440 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
6441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6442 if (!SWIG_IsOK(res1)) {
6443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6445 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6447 if (!SWIG_IsOK(res2)) {
6448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6453 arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6454 result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
6455 resultobj = SWIG_From_bool(static_cast< bool >(result));
6462 SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6463 PyObject *resultobj = 0;
6464 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 swig::SwigPyIterator *result = 0 ;
6474 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
6475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6479 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6480 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6481 if (!SWIG_IsOK(ecode2)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
6484 arg2 = static_cast< ptrdiff_t >(val2);
6486 result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
6488 catch(swig::stop_iteration &_e) {
6491 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6503 SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504 PyObject *resultobj = 0;
6505 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 swig::SwigPyIterator *result = 0 ;
6515 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
6516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6520 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6521 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6522 if (!SWIG_IsOK(ecode2)) {
6523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6525 arg2 = static_cast< ptrdiff_t >(val2);
6527 result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
6529 catch(swig::stop_iteration &_e) {
6532 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6544 SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545 PyObject *resultobj = 0;
6546 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6552 PyObject * obj0 = 0 ;
6553 PyObject * obj1 = 0 ;
6554 swig::SwigPyIterator *result = 0 ;
6556 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
6557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6558 if (!SWIG_IsOK(res1)) {
6559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6561 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6562 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6563 if (!SWIG_IsOK(ecode2)) {
6564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
6566 arg2 = static_cast< ptrdiff_t >(val2);
6568 result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
6570 catch(swig::stop_iteration &_e) {
6573 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6585 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586 PyObject *resultobj = 0;
6587 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6593 PyObject * obj0 = 0 ;
6594 PyObject * obj1 = 0 ;
6595 swig::SwigPyIterator *result = 0 ;
6597 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6599 if (!SWIG_IsOK(res1)) {
6600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6602 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6603 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6604 if (!SWIG_IsOK(ecode2)) {
6605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6607 arg2 = static_cast< ptrdiff_t >(val2);
6609 result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
6611 catch(swig::stop_iteration &_e) {
6614 SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6626 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6627 PyObject *resultobj = 0;
6628 swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6629 swig::SwigPyIterator *arg2 = 0 ;
6634 PyObject * obj0 = 0 ;
6635 PyObject * obj1 = 0 ;
6638 if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
6640 if (!SWIG_IsOK(res1)) {
6641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6643 arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
6645 if (!SWIG_IsOK(res2)) {
6646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6651 arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6652 result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
6653 resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
6660 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
6662 PyObject *argv[3] = {
6667 if (!PyTuple_Check(args)) SWIG_fail;
6668 argc = args ? PyObject_Length(args) : 0;
6669 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6670 argv[ii] = PyTuple_GET_ITEM(args,ii);
6675 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6676 _v = SWIG_CheckState(res);
6678 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
6679 _v = SWIG_CheckState(res);
6681 return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
6688 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6689 _v = SWIG_CheckState(res);
6692 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6693 _v = SWIG_CheckState(res);
6696 return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
6702 Py_INCREF(Py_NotImplemented);
6703 return Py_NotImplemented;
6707 SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6709 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
6710 SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
6711 return SWIG_Py_Void();
6714 SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6715 PyObject *resultobj = 0;
6716 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6717 PyObject **arg2 = (PyObject **) 0 ;
6720 PyObject * obj0 = 0 ;
6721 swig::SwigPyIterator *result = 0 ;
6724 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
6725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6729 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6730 result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
6731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
6738 SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6739 PyObject *resultobj = 0;
6740 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6743 PyObject * obj0 = 0 ;
6746 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
6747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6748 if (!SWIG_IsOK(res1)) {
6749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6751 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6752 result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector< Hex::Hexa * > const *)arg1);
6753 resultobj = SWIG_From_bool(static_cast< bool >(result));
6760 SWIGINTERN PyObject *_wrap_VectorHexas___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6765 PyObject * obj0 = 0 ;
6768 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___bool__",&obj0)) SWIG_fail;
6769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6770 if (!SWIG_IsOK(res1)) {
6771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___bool__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6773 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6774 result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____bool__((std::vector< Hex::Hexa * > const *)arg1);
6775 resultobj = SWIG_From_bool(static_cast< bool >(result));
6782 SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6783 PyObject *resultobj = 0;
6784 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6787 PyObject * obj0 = 0 ;
6788 std::vector< Hex::Hexa * >::size_type result;
6790 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
6791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6792 if (!SWIG_IsOK(res1)) {
6793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6795 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6796 result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector< Hex::Hexa * > const *)arg1);
6797 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6804 SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805 PyObject *resultobj = 0;
6806 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6807 std::vector< Hex::Hexa * >::difference_type arg2 ;
6808 std::vector< Hex::Hexa * >::difference_type arg3 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 PyObject * obj2 = 0 ;
6818 std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
6820 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6822 if (!SWIG_IsOK(res1)) {
6823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6825 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6826 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6827 if (!SWIG_IsOK(ecode2)) {
6828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6830 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6831 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6832 if (!SWIG_IsOK(ecode3)) {
6833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6835 arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6837 result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
6839 catch(std::out_of_range &_e) {
6840 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6842 catch(std::invalid_argument &_e) {
6843 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_OWN | 0 );
6853 SWIGINTERN PyObject *_wrap_VectorHexas___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854 PyObject *resultobj = 0;
6855 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6856 std::vector< Hex::Hexa * >::difference_type arg2 ;
6857 std::vector< Hex::Hexa * >::difference_type arg3 ;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 PyObject * obj2 = 0 ;
6868 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6873 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6874 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6875 if (!SWIG_IsOK(ecode2)) {
6876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6878 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6879 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6880 if (!SWIG_IsOK(ecode3)) {
6881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6883 arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6885 std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
6887 catch(std::out_of_range &_e) {
6888 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6890 catch(std::invalid_argument &_e) {
6891 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6894 resultobj = SWIG_Py_Void();
6901 SWIGINTERN PyObject *_wrap_VectorHexas___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902 PyObject *resultobj = 0;
6903 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6904 std::vector< Hex::Hexa * >::difference_type arg2 ;
6905 std::vector< Hex::Hexa * >::difference_type arg3 ;
6906 std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg4 = 0 ;
6913 int res4 = SWIG_OLDOBJ ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 PyObject * obj2 = 0 ;
6917 PyObject * obj3 = 0 ;
6919 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
6921 if (!SWIG_IsOK(res1)) {
6922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6924 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6925 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6926 if (!SWIG_IsOK(ecode2)) {
6927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6929 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6930 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6931 if (!SWIG_IsOK(ecode3)) {
6932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6934 arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6936 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
6937 res4 = swig::asptr(obj3, &ptr);
6938 if (!SWIG_IsOK(res4)) {
6939 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6942 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 &""'");
6947 std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg4);
6949 catch(std::out_of_range &_e) {
6950 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6952 catch(std::invalid_argument &_e) {
6953 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6956 resultobj = SWIG_Py_Void();
6957 if (SWIG_IsNewObj(res4)) delete arg4;
6960 if (SWIG_IsNewObj(res4)) delete arg4;
6965 SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *self, PyObject *args) {
6967 PyObject *argv[5] = {
6972 if (!PyTuple_Check(args)) SWIG_fail;
6973 argc = args ? PyObject_Length(args) : 0;
6974 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
6975 argv[ii] = PyTuple_GET_ITEM(args,ii);
6979 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6980 _v = SWIG_CheckState(res);
6983 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6984 _v = SWIG_CheckState(res);
6988 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
6989 _v = SWIG_CheckState(res);
6992 return _wrap_VectorHexas___setslice____SWIG_0(self, args);
6999 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7000 _v = SWIG_CheckState(res);
7003 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7004 _v = SWIG_CheckState(res);
7008 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
7009 _v = SWIG_CheckState(res);
7012 int res = swig::asptr(argv[3], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7013 _v = SWIG_CheckState(res);
7015 return _wrap_VectorHexas___setslice____SWIG_1(self, args);
7023 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___setslice__'.\n"
7024 " Possible C/C++ prototypes are:\n"
7025 " std::vector< Hex::Hexa * >::__setslice__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::difference_type)\n"
7026 " std::vector< Hex::Hexa * >::__setslice__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n");
7031 SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7032 PyObject *resultobj = 0;
7033 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7034 std::vector< Hex::Hexa * >::difference_type arg2 ;
7035 std::vector< Hex::Hexa * >::difference_type arg3 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 PyObject * obj2 = 0 ;
7046 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7048 if (!SWIG_IsOK(res1)) {
7049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7051 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7052 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7053 if (!SWIG_IsOK(ecode2)) {
7054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7056 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7057 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7058 if (!SWIG_IsOK(ecode3)) {
7059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7061 arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
7063 std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
7065 catch(std::out_of_range &_e) {
7066 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7068 catch(std::invalid_argument &_e) {
7069 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7072 resultobj = SWIG_Py_Void();
7079 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7080 PyObject *resultobj = 0;
7081 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7082 std::vector< Hex::Hexa * >::difference_type arg2 ;
7087 PyObject * obj0 = 0 ;
7088 PyObject * obj1 = 0 ;
7090 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
7091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7092 if (!SWIG_IsOK(res1)) {
7093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7095 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7096 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7097 if (!SWIG_IsOK(ecode2)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7100 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7102 std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(arg1,arg2);
7104 catch(std::out_of_range &_e) {
7105 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7107 catch(std::invalid_argument &_e) {
7108 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7111 resultobj = SWIG_Py_Void();
7118 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7119 PyObject *resultobj = 0;
7120 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7121 PySliceObject *arg2 = (PySliceObject *) 0 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
7128 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
7129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7130 if (!SWIG_IsOK(res1)) {
7131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7133 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7135 if (!PySlice_Check(obj1)) {
7136 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7138 arg2 = (PySliceObject *) obj1;
7141 result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(arg1,arg2);
7143 catch(std::out_of_range &_e) {
7144 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7146 catch(std::invalid_argument &_e) {
7147 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_OWN | 0 );
7157 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158 PyObject *resultobj = 0;
7159 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7160 PySliceObject *arg2 = (PySliceObject *) 0 ;
7161 std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg3 = 0 ;
7164 int res3 = SWIG_OLDOBJ ;
7165 PyObject * obj0 = 0 ;
7166 PyObject * obj1 = 0 ;
7167 PyObject * obj2 = 0 ;
7169 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7171 if (!SWIG_IsOK(res1)) {
7172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7174 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7176 if (!PySlice_Check(obj1)) {
7177 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7179 arg2 = (PySliceObject *) obj1;
7182 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
7183 res3 = swig::asptr(obj2, &ptr);
7184 if (!SWIG_IsOK(res3)) {
7185 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
7188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
7193 std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg3);
7195 catch(std::out_of_range &_e) {
7196 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7198 catch(std::invalid_argument &_e) {
7199 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7202 resultobj = SWIG_Py_Void();
7203 if (SWIG_IsNewObj(res3)) delete arg3;
7206 if (SWIG_IsNewObj(res3)) delete arg3;
7211 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7212 PyObject *resultobj = 0;
7213 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7214 PySliceObject *arg2 = (PySliceObject *) 0 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7220 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___setitem__",&obj0,&obj1)) SWIG_fail;
7221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7222 if (!SWIG_IsOK(res1)) {
7223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7225 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7227 if (!PySlice_Check(obj1)) {
7228 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7230 arg2 = (PySliceObject *) obj1;
7233 std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(arg1,arg2);
7235 catch(std::out_of_range &_e) {
7236 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7238 catch(std::invalid_argument &_e) {
7239 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7242 resultobj = SWIG_Py_Void();
7249 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7250 PyObject *resultobj = 0;
7251 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7252 PySliceObject *arg2 = (PySliceObject *) 0 ;
7255 PyObject * obj0 = 0 ;
7256 PyObject * obj1 = 0 ;
7258 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
7259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7260 if (!SWIG_IsOK(res1)) {
7261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7263 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7265 if (!PySlice_Check(obj1)) {
7266 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7268 arg2 = (PySliceObject *) obj1;
7271 std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(arg1,arg2);
7273 catch(std::out_of_range &_e) {
7274 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7276 catch(std::invalid_argument &_e) {
7277 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7280 resultobj = SWIG_Py_Void();
7287 SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *self, PyObject *args) {
7289 PyObject *argv[3] = {
7294 if (!PyTuple_Check(args)) SWIG_fail;
7295 argc = args ? PyObject_Length(args) : 0;
7296 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
7297 argv[ii] = PyTuple_GET_ITEM(args,ii);
7301 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7302 _v = SWIG_CheckState(res);
7305 _v = PySlice_Check(argv[1]);
7308 return _wrap_VectorHexas___delitem____SWIG_1(self, args);
7314 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7315 _v = SWIG_CheckState(res);
7318 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7319 _v = SWIG_CheckState(res);
7322 return _wrap_VectorHexas___delitem____SWIG_0(self, args);
7328 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___delitem__'.\n"
7329 " Possible C/C++ prototypes are:\n"
7330 " std::vector< Hex::Hexa * >::__delitem__(std::vector< Hex::Hexa * >::difference_type)\n"
7331 " std::vector< Hex::Hexa * >::__delitem__(PySliceObject *)\n");
7336 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7337 PyObject *resultobj = 0;
7338 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7339 std::vector< Hex::Hexa * >::difference_type arg2 ;
7344 PyObject * obj0 = 0 ;
7345 PyObject * obj1 = 0 ;
7346 std::vector< Hex::Hexa * >::value_type result;
7348 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
7349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7350 if (!SWIG_IsOK(res1)) {
7351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7353 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7354 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7355 if (!SWIG_IsOK(ecode2)) {
7356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7358 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7360 result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(arg1,arg2);
7362 catch(std::out_of_range &_e) {
7363 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
7373 SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *self, PyObject *args) {
7375 PyObject *argv[3] = {
7380 if (!PyTuple_Check(args)) SWIG_fail;
7381 argc = args ? PyObject_Length(args) : 0;
7382 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
7383 argv[ii] = PyTuple_GET_ITEM(args,ii);
7387 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7388 _v = SWIG_CheckState(res);
7391 _v = PySlice_Check(argv[1]);
7394 return _wrap_VectorHexas___getitem____SWIG_0(self, args);
7400 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7401 _v = SWIG_CheckState(res);
7404 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7405 _v = SWIG_CheckState(res);
7408 return _wrap_VectorHexas___getitem____SWIG_1(self, args);
7414 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___getitem__'.\n"
7415 " Possible C/C++ prototypes are:\n"
7416 " std::vector< Hex::Hexa * >::__getitem__(PySliceObject *)\n"
7417 " std::vector< Hex::Hexa * >::__getitem__(std::vector< Hex::Hexa * >::difference_type)\n");
7422 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 PyObject *resultobj = 0;
7424 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7425 std::vector< Hex::Hexa * >::difference_type arg2 ;
7426 std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 PyObject * obj2 = 0 ;
7437 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7439 if (!SWIG_IsOK(res1)) {
7440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7442 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7443 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7444 if (!SWIG_IsOK(ecode2)) {
7445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7447 arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7448 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
7449 if (!SWIG_IsOK(res3)) {
7450 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7452 arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
7454 std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
7456 catch(std::out_of_range &_e) {
7457 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7460 resultobj = SWIG_Py_Void();
7467 SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *self, PyObject *args) {
7469 PyObject *argv[4] = {
7474 if (!PyTuple_Check(args)) SWIG_fail;
7475 argc = args ? PyObject_Length(args) : 0;
7476 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
7477 argv[ii] = PyTuple_GET_ITEM(args,ii);
7481 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7482 _v = SWIG_CheckState(res);
7485 _v = PySlice_Check(argv[1]);
7488 return _wrap_VectorHexas___setitem____SWIG_1(self, args);
7494 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7495 _v = SWIG_CheckState(res);
7498 _v = PySlice_Check(argv[1]);
7501 int res = swig::asptr(argv[2], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7502 _v = SWIG_CheckState(res);
7504 return _wrap_VectorHexas___setitem____SWIG_0(self, args);
7511 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7512 _v = SWIG_CheckState(res);
7515 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7516 _v = SWIG_CheckState(res);
7520 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
7521 _v = SWIG_CheckState(res);
7523 return _wrap_VectorHexas___setitem____SWIG_2(self, args);
7530 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___setitem__'.\n"
7531 " Possible C/C++ prototypes are:\n"
7532 " std::vector< Hex::Hexa * >::__setitem__(PySliceObject *,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n"
7533 " std::vector< Hex::Hexa * >::__setitem__(PySliceObject *)\n"
7534 " std::vector< Hex::Hexa * >::__setitem__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::value_type)\n");
7539 SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7540 PyObject *resultobj = 0;
7541 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7544 PyObject * obj0 = 0 ;
7545 std::vector< Hex::Hexa * >::value_type result;
7547 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
7548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7549 if (!SWIG_IsOK(res1)) {
7550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7552 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7554 result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
7556 catch(std::out_of_range &_e) {
7557 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
7567 SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7568 PyObject *resultobj = 0;
7569 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7570 std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7578 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
7579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7580 if (!SWIG_IsOK(res1)) {
7581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7583 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
7585 if (!SWIG_IsOK(res2)) {
7586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7588 arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
7589 std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
7590 resultobj = SWIG_Py_Void();
7597 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7598 PyObject *resultobj = 0;
7599 std::vector< Hex::Hexa * > *result = 0 ;
7601 if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
7602 result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >();
7603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
7610 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611 PyObject *resultobj = 0;
7612 std::vector< Hex::Hexa * > *arg1 = 0 ;
7613 int res1 = SWIG_OLDOBJ ;
7614 PyObject * obj0 = 0 ;
7615 std::vector< Hex::Hexa * > *result = 0 ;
7617 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
7619 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
7620 res1 = swig::asptr(obj0, &ptr);
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
7625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
7629 result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >((std::vector< Hex::Hexa * > const &)*arg1);
7630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
7631 if (SWIG_IsNewObj(res1)) delete arg1;
7634 if (SWIG_IsNewObj(res1)) delete arg1;
7639 SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7640 PyObject *resultobj = 0;
7641 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7644 PyObject * obj0 = 0 ;
7647 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
7648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7649 if (!SWIG_IsOK(res1)) {
7650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7652 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7653 result = (bool)((std::vector< Hex::Hexa * > const *)arg1)->empty();
7654 resultobj = SWIG_From_bool(static_cast< bool >(result));
7661 SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7662 PyObject *resultobj = 0;
7663 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7666 PyObject * obj0 = 0 ;
7667 std::vector< Hex::Hexa * >::size_type result;
7669 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
7670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7671 if (!SWIG_IsOK(res1)) {
7672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7674 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7675 result = ((std::vector< Hex::Hexa * > const *)arg1)->size();
7676 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7683 SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7684 PyObject *resultobj = 0;
7685 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7686 std::vector< Hex::Hexa * > *arg2 = 0 ;
7691 PyObject * obj0 = 0 ;
7692 PyObject * obj1 = 0 ;
7694 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
7695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7699 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 );
7701 if (!SWIG_IsOK(res2)) {
7702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
7705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
7707 arg2 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp2);
7708 (arg1)->swap(*arg2);
7709 resultobj = SWIG_Py_Void();
7716 SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7717 PyObject *resultobj = 0;
7718 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7721 PyObject * obj0 = 0 ;
7722 std::vector< Hex::Hexa * >::iterator result;
7724 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
7725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7726 if (!SWIG_IsOK(res1)) {
7727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7729 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7730 result = (arg1)->begin();
7731 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7732 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7739 SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7744 PyObject * obj0 = 0 ;
7745 std::vector< Hex::Hexa * >::iterator result;
7747 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
7748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7752 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7753 result = (arg1)->end();
7754 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7755 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7762 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7767 PyObject * obj0 = 0 ;
7768 std::vector< Hex::Hexa * >::reverse_iterator result;
7770 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
7771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7772 if (!SWIG_IsOK(res1)) {
7773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7775 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7776 result = (arg1)->rbegin();
7777 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::reverse_iterator & >(result)),
7778 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7785 SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7786 PyObject *resultobj = 0;
7787 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7790 PyObject * obj0 = 0 ;
7791 std::vector< Hex::Hexa * >::reverse_iterator result;
7793 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
7794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7795 if (!SWIG_IsOK(res1)) {
7796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7798 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7799 result = (arg1)->rend();
7800 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::reverse_iterator & >(result)),
7801 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7808 SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7809 PyObject *resultobj = 0;
7810 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7813 PyObject * obj0 = 0 ;
7815 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
7816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7817 if (!SWIG_IsOK(res1)) {
7818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7820 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7822 resultobj = SWIG_Py_Void();
7829 SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7834 PyObject * obj0 = 0 ;
7835 SwigValueWrapper< std::allocator< Hex::Hexa * > > result;
7837 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
7838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7839 if (!SWIG_IsOK(res1)) {
7840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7842 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7843 result = ((std::vector< Hex::Hexa * > const *)arg1)->get_allocator();
7844 resultobj = SWIG_NewPointerObj((new std::vector< Hex::Hexa * >::allocator_type(static_cast< const std::vector< Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Hexa_p_t, SWIG_POINTER_OWN | 0 );
7851 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7852 PyObject *resultobj = 0;
7853 std::vector< Hex::Hexa * >::size_type arg1 ;
7856 PyObject * obj0 = 0 ;
7857 std::vector< Hex::Hexa * > *result = 0 ;
7859 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
7860 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7861 if (!SWIG_IsOK(ecode1)) {
7862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7864 arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
7865 result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1);
7866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
7873 SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7874 PyObject *resultobj = 0;
7875 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7878 PyObject * obj0 = 0 ;
7880 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
7881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7882 if (!SWIG_IsOK(res1)) {
7883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7885 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7887 resultobj = SWIG_Py_Void();
7894 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7895 PyObject *resultobj = 0;
7896 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7897 std::vector< Hex::Hexa * >::size_type arg2 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7905 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
7906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7907 if (!SWIG_IsOK(res1)) {
7908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7910 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7911 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7912 if (!SWIG_IsOK(ecode2)) {
7913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7915 arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
7916 (arg1)->resize(arg2);
7917 resultobj = SWIG_Py_Void();
7924 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925 PyObject *resultobj = 0;
7926 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7927 std::vector< Hex::Hexa * >::iterator arg2 ;
7930 swig::SwigPyIterator *iter2 = 0 ;
7932 PyObject * obj0 = 0 ;
7933 PyObject * obj1 = 0 ;
7934 std::vector< Hex::Hexa * >::iterator result;
7936 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
7937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7938 if (!SWIG_IsOK(res1)) {
7939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7941 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7942 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7943 if (!SWIG_IsOK(res2) || !iter2) {
7944 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7946 swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7948 arg2 = iter_t->get_current();
7950 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7953 result = std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_0(arg1,arg2);
7954 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7955 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7962 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 PyObject *resultobj = 0;
7964 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7965 std::vector< Hex::Hexa * >::iterator arg2 ;
7966 std::vector< Hex::Hexa * >::iterator arg3 ;
7969 swig::SwigPyIterator *iter2 = 0 ;
7971 swig::SwigPyIterator *iter3 = 0 ;
7973 PyObject * obj0 = 0 ;
7974 PyObject * obj1 = 0 ;
7975 PyObject * obj2 = 0 ;
7976 std::vector< Hex::Hexa * >::iterator result;
7978 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
7979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
7980 if (!SWIG_IsOK(res1)) {
7981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7983 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7984 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7985 if (!SWIG_IsOK(res2) || !iter2) {
7986 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7988 swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7990 arg2 = iter_t->get_current();
7992 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7995 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
7996 if (!SWIG_IsOK(res3) || !iter3) {
7997 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7999 swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter3);
8001 arg3 = iter_t->get_current();
8003 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8006 result = std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
8007 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
8008 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8015 SWIGINTERN PyObject *_wrap_VectorHexas_erase(PyObject *self, PyObject *args) {
8017 PyObject *argv[4] = {
8022 if (!PyTuple_Check(args)) SWIG_fail;
8023 argc = args ? PyObject_Length(args) : 0;
8024 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
8025 argv[ii] = PyTuple_GET_ITEM(args,ii);
8029 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8030 _v = SWIG_CheckState(res);
8032 swig::SwigPyIterator *iter = 0;
8033 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8034 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8036 return _wrap_VectorHexas_erase__SWIG_0(self, args);
8042 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8043 _v = SWIG_CheckState(res);
8045 swig::SwigPyIterator *iter = 0;
8046 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8047 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8049 swig::SwigPyIterator *iter = 0;
8050 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8051 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8053 return _wrap_VectorHexas_erase__SWIG_1(self, args);
8060 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_erase'.\n"
8061 " Possible C/C++ prototypes are:\n"
8062 " std::vector< Hex::Hexa * >::erase(std::vector< Hex::Hexa * >::iterator)\n"
8063 " std::vector< Hex::Hexa * >::erase(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::iterator)\n");
8068 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 std::vector< Hex::Hexa * >::size_type arg1 ;
8071 std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 std::vector< Hex::Hexa * > *result = 0 ;
8080 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
8081 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8082 if (!SWIG_IsOK(ecode1)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8085 arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
8086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8087 if (!SWIG_IsOK(res2)) {
8088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8090 arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
8091 result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1,arg2);
8092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
8099 SWIGINTERN PyObject *_wrap_new_VectorHexas(PyObject *self, PyObject *args) {
8101 PyObject *argv[3] = {
8106 if (!PyTuple_Check(args)) SWIG_fail;
8107 argc = args ? PyObject_Length(args) : 0;
8108 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
8109 argv[ii] = PyTuple_GET_ITEM(args,ii);
8112 return _wrap_new_VectorHexas__SWIG_0(self, args);
8117 int res = SWIG_AsVal_size_t(argv[0], NULL);
8118 _v = SWIG_CheckState(res);
8121 return _wrap_new_VectorHexas__SWIG_2(self, args);
8126 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8127 _v = SWIG_CheckState(res);
8129 return _wrap_new_VectorHexas__SWIG_1(self, args);
8135 int res = SWIG_AsVal_size_t(argv[0], NULL);
8136 _v = SWIG_CheckState(res);
8140 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8141 _v = SWIG_CheckState(res);
8143 return _wrap_new_VectorHexas__SWIG_3(self, args);
8149 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorHexas'.\n"
8150 " Possible C/C++ prototypes are:\n"
8151 " std::vector< Hex::Hexa * >::vector()\n"
8152 " std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * > const &)\n"
8153 " std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * >::size_type)\n"
8154 " std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8159 SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8162 std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8167 PyObject * obj0 = 0 ;
8168 PyObject * obj1 = 0 ;
8170 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
8171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8172 if (!SWIG_IsOK(res1)) {
8173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8175 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8177 if (!SWIG_IsOK(res2)) {
8178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8180 arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
8181 (arg1)->push_back(arg2);
8182 resultobj = SWIG_Py_Void();
8189 SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8190 PyObject *resultobj = 0;
8191 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8194 PyObject * obj0 = 0 ;
8195 std::vector< Hex::Hexa * >::value_type result;
8197 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
8198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8199 if (!SWIG_IsOK(res1)) {
8200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8202 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8203 result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->front();
8204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8211 SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8212 PyObject *resultobj = 0;
8213 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8216 PyObject * obj0 = 0 ;
8217 std::vector< Hex::Hexa * >::value_type result;
8219 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
8220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8224 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8225 result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->back();
8226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8233 SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8234 PyObject *resultobj = 0;
8235 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8236 std::vector< Hex::Hexa * >::size_type arg2 ;
8237 std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8244 PyObject * obj0 = 0 ;
8245 PyObject * obj1 = 0 ;
8246 PyObject * obj2 = 0 ;
8248 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8253 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8254 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8255 if (!SWIG_IsOK(ecode2)) {
8256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8258 arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8259 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8260 if (!SWIG_IsOK(res3)) {
8261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8263 arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8264 (arg1)->assign(arg2,arg3);
8265 resultobj = SWIG_Py_Void();
8272 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8273 PyObject *resultobj = 0;
8274 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8275 std::vector< Hex::Hexa * >::size_type arg2 ;
8276 std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 PyObject * obj2 = 0 ;
8287 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8289 if (!SWIG_IsOK(res1)) {
8290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8292 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8294 if (!SWIG_IsOK(ecode2)) {
8295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8297 arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8298 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8299 if (!SWIG_IsOK(res3)) {
8300 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8302 arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8303 (arg1)->resize(arg2,arg3);
8304 resultobj = SWIG_Py_Void();
8311 SWIGINTERN PyObject *_wrap_VectorHexas_resize(PyObject *self, PyObject *args) {
8313 PyObject *argv[4] = {
8318 if (!PyTuple_Check(args)) SWIG_fail;
8319 argc = args ? PyObject_Length(args) : 0;
8320 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
8321 argv[ii] = PyTuple_GET_ITEM(args,ii);
8325 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8326 _v = SWIG_CheckState(res);
8329 int res = SWIG_AsVal_size_t(argv[1], NULL);
8330 _v = SWIG_CheckState(res);
8333 return _wrap_VectorHexas_resize__SWIG_0(self, args);
8339 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8340 _v = SWIG_CheckState(res);
8343 int res = SWIG_AsVal_size_t(argv[1], NULL);
8344 _v = SWIG_CheckState(res);
8348 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8349 _v = SWIG_CheckState(res);
8351 return _wrap_VectorHexas_resize__SWIG_1(self, args);
8358 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_resize'.\n"
8359 " Possible C/C++ prototypes are:\n"
8360 " std::vector< Hex::Hexa * >::resize(std::vector< Hex::Hexa * >::size_type)\n"
8361 " std::vector< Hex::Hexa * >::resize(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8366 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8367 PyObject *resultobj = 0;
8368 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8369 std::vector< Hex::Hexa * >::iterator arg2 ;
8370 std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8373 swig::SwigPyIterator *iter2 = 0 ;
8377 PyObject * obj0 = 0 ;
8378 PyObject * obj1 = 0 ;
8379 PyObject * obj2 = 0 ;
8380 std::vector< Hex::Hexa * >::iterator result;
8382 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
8383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8384 if (!SWIG_IsOK(res1)) {
8385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8387 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8388 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8389 if (!SWIG_IsOK(res2) || !iter2) {
8390 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8392 swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
8394 arg2 = iter_t->get_current();
8396 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8399 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8400 if (!SWIG_IsOK(res3)) {
8401 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8403 arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8404 result = std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
8405 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
8406 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8413 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 PyObject *resultobj = 0;
8415 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8416 std::vector< Hex::Hexa * >::iterator arg2 ;
8417 std::vector< Hex::Hexa * >::size_type arg3 ;
8418 std::vector< Hex::Hexa * >::value_type arg4 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8421 swig::SwigPyIterator *iter2 = 0 ;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 PyObject * obj2 = 0 ;
8430 PyObject * obj3 = 0 ;
8432 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8437 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8438 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8439 if (!SWIG_IsOK(res2) || !iter2) {
8440 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8442 swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
8444 arg2 = iter_t->get_current();
8446 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8449 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8450 if (!SWIG_IsOK(ecode3)) {
8451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8453 arg3 = static_cast< std::vector< Hex::Hexa * >::size_type >(val3);
8454 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
8455 if (!SWIG_IsOK(res4)) {
8456 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8458 arg4 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp4);
8459 std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
8460 resultobj = SWIG_Py_Void();
8467 SWIGINTERN PyObject *_wrap_VectorHexas_insert(PyObject *self, PyObject *args) {
8469 PyObject *argv[5] = {
8474 if (!PyTuple_Check(args)) SWIG_fail;
8475 argc = args ? PyObject_Length(args) : 0;
8476 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8477 argv[ii] = PyTuple_GET_ITEM(args,ii);
8481 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8482 _v = SWIG_CheckState(res);
8484 swig::SwigPyIterator *iter = 0;
8485 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8486 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8489 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8490 _v = SWIG_CheckState(res);
8492 return _wrap_VectorHexas_insert__SWIG_0(self, args);
8499 int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8500 _v = SWIG_CheckState(res);
8502 swig::SwigPyIterator *iter = 0;
8503 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8504 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8507 int res = SWIG_AsVal_size_t(argv[2], NULL);
8508 _v = SWIG_CheckState(res);
8512 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8513 _v = SWIG_CheckState(res);
8515 return _wrap_VectorHexas_insert__SWIG_1(self, args);
8523 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_insert'.\n"
8524 " Possible C/C++ prototypes are:\n"
8525 " std::vector< Hex::Hexa * >::insert(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::value_type)\n"
8526 " std::vector< Hex::Hexa * >::insert(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8531 SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8532 PyObject *resultobj = 0;
8533 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8534 std::vector< Hex::Hexa * >::size_type arg2 ;
8539 PyObject * obj0 = 0 ;
8540 PyObject * obj1 = 0 ;
8542 if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
8543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8547 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8548 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8549 if (!SWIG_IsOK(ecode2)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8552 arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8553 (arg1)->reserve(arg2);
8554 resultobj = SWIG_Py_Void();
8561 SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8562 PyObject *resultobj = 0;
8563 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8566 PyObject * obj0 = 0 ;
8567 std::vector< Hex::Hexa * >::size_type result;
8569 if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8574 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8575 result = ((std::vector< Hex::Hexa * > const *)arg1)->capacity();
8576 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8583 SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8584 PyObject *resultobj = 0;
8585 std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8588 PyObject * obj0 = 0 ;
8590 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
8591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_DISOWN | 0 );
8592 if (!SWIG_IsOK(res1)) {
8593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8595 arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8597 resultobj = SWIG_Py_Void();
8604 SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8606 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
8607 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_NewClientData(obj));
8608 return SWIG_Py_Void();
8611 SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8612 PyObject *resultobj = 0;
8613 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8614 PyObject **arg2 = (PyObject **) 0 ;
8617 PyObject * obj0 = 0 ;
8618 swig::SwigPyIterator *result = 0 ;
8621 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
8622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8623 if (!SWIG_IsOK(res1)) {
8624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8626 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8627 result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
8628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
8635 SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8636 PyObject *resultobj = 0;
8637 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8640 PyObject * obj0 = 0 ;
8643 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
8644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8645 if (!SWIG_IsOK(res1)) {
8646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8648 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8649 result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector< Hex::Quad * > const *)arg1);
8650 resultobj = SWIG_From_bool(static_cast< bool >(result));
8657 SWIGINTERN PyObject *_wrap_VectorQuads___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658 PyObject *resultobj = 0;
8659 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8662 PyObject * obj0 = 0 ;
8665 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___bool__",&obj0)) SWIG_fail;
8666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8667 if (!SWIG_IsOK(res1)) {
8668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___bool__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8670 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8671 result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____bool__((std::vector< Hex::Quad * > const *)arg1);
8672 resultobj = SWIG_From_bool(static_cast< bool >(result));
8679 SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8680 PyObject *resultobj = 0;
8681 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8684 PyObject * obj0 = 0 ;
8685 std::vector< Hex::Quad * >::size_type result;
8687 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
8688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8689 if (!SWIG_IsOK(res1)) {
8690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8692 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8693 result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector< Hex::Quad * > const *)arg1);
8694 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8701 SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8702 PyObject *resultobj = 0;
8703 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8704 std::vector< Hex::Quad * >::difference_type arg2 ;
8705 std::vector< Hex::Quad * >::difference_type arg3 ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 PyObject * obj2 = 0 ;
8715 std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
8717 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8719 if (!SWIG_IsOK(res1)) {
8720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8722 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8723 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8724 if (!SWIG_IsOK(ecode2)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8727 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8728 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8729 if (!SWIG_IsOK(ecode3)) {
8730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8732 arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8734 result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
8736 catch(std::out_of_range &_e) {
8737 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8739 catch(std::invalid_argument &_e) {
8740 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_OWN | 0 );
8750 SWIGINTERN PyObject *_wrap_VectorQuads___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8751 PyObject *resultobj = 0;
8752 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8753 std::vector< Hex::Quad * >::difference_type arg2 ;
8754 std::vector< Hex::Quad * >::difference_type arg3 ;
8761 PyObject * obj0 = 0 ;
8762 PyObject * obj1 = 0 ;
8763 PyObject * obj2 = 0 ;
8765 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8770 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8771 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8772 if (!SWIG_IsOK(ecode2)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8775 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8776 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8777 if (!SWIG_IsOK(ecode3)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8780 arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8782 std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
8784 catch(std::out_of_range &_e) {
8785 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8787 catch(std::invalid_argument &_e) {
8788 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8791 resultobj = SWIG_Py_Void();
8798 SWIGINTERN PyObject *_wrap_VectorQuads___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799 PyObject *resultobj = 0;
8800 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8801 std::vector< Hex::Quad * >::difference_type arg2 ;
8802 std::vector< Hex::Quad * >::difference_type arg3 ;
8803 std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg4 = 0 ;
8810 int res4 = SWIG_OLDOBJ ;
8811 PyObject * obj0 = 0 ;
8812 PyObject * obj1 = 0 ;
8813 PyObject * obj2 = 0 ;
8814 PyObject * obj3 = 0 ;
8816 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8818 if (!SWIG_IsOK(res1)) {
8819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8821 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8822 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8823 if (!SWIG_IsOK(ecode2)) {
8824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8826 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8827 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8828 if (!SWIG_IsOK(ecode3)) {
8829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8831 arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8833 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
8834 res4 = swig::asptr(obj3, &ptr);
8835 if (!SWIG_IsOK(res4)) {
8836 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
8839 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 &""'");
8844 std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg4);
8846 catch(std::out_of_range &_e) {
8847 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8849 catch(std::invalid_argument &_e) {
8850 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8853 resultobj = SWIG_Py_Void();
8854 if (SWIG_IsNewObj(res4)) delete arg4;
8857 if (SWIG_IsNewObj(res4)) delete arg4;
8862 SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *self, PyObject *args) {
8864 PyObject *argv[5] = {
8869 if (!PyTuple_Check(args)) SWIG_fail;
8870 argc = args ? PyObject_Length(args) : 0;
8871 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8872 argv[ii] = PyTuple_GET_ITEM(args,ii);
8876 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8877 _v = SWIG_CheckState(res);
8880 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8881 _v = SWIG_CheckState(res);
8885 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8886 _v = SWIG_CheckState(res);
8889 return _wrap_VectorQuads___setslice____SWIG_0(self, args);
8896 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8897 _v = SWIG_CheckState(res);
8900 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8901 _v = SWIG_CheckState(res);
8905 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8906 _v = SWIG_CheckState(res);
8909 int res = swig::asptr(argv[3], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8910 _v = SWIG_CheckState(res);
8912 return _wrap_VectorQuads___setslice____SWIG_1(self, args);
8920 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___setslice__'.\n"
8921 " Possible C/C++ prototypes are:\n"
8922 " std::vector< Hex::Quad * >::__setslice__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::difference_type)\n"
8923 " std::vector< Hex::Quad * >::__setslice__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n");
8928 SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929 PyObject *resultobj = 0;
8930 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8931 std::vector< Hex::Quad * >::difference_type arg2 ;
8932 std::vector< Hex::Quad * >::difference_type arg3 ;
8939 PyObject * obj0 = 0 ;
8940 PyObject * obj1 = 0 ;
8941 PyObject * obj2 = 0 ;
8943 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8945 if (!SWIG_IsOK(res1)) {
8946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8948 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8949 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8950 if (!SWIG_IsOK(ecode2)) {
8951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8953 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8954 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8955 if (!SWIG_IsOK(ecode3)) {
8956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8958 arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8960 std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
8962 catch(std::out_of_range &_e) {
8963 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8965 catch(std::invalid_argument &_e) {
8966 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8969 resultobj = SWIG_Py_Void();
8976 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8977 PyObject *resultobj = 0;
8978 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8979 std::vector< Hex::Quad * >::difference_type arg2 ;
8984 PyObject * obj0 = 0 ;
8985 PyObject * obj1 = 0 ;
8987 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
8988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
8989 if (!SWIG_IsOK(res1)) {
8990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8992 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8993 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8994 if (!SWIG_IsOK(ecode2)) {
8995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8997 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8999 std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(arg1,arg2);
9001 catch(std::out_of_range &_e) {
9002 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9004 catch(std::invalid_argument &_e) {
9005 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9008 resultobj = SWIG_Py_Void();
9015 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9016 PyObject *resultobj = 0;
9017 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9018 PySliceObject *arg2 = (PySliceObject *) 0 ;
9021 PyObject * obj0 = 0 ;
9022 PyObject * obj1 = 0 ;
9023 std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
9025 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
9026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9027 if (!SWIG_IsOK(res1)) {
9028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9030 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9032 if (!PySlice_Check(obj1)) {
9033 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9035 arg2 = (PySliceObject *) obj1;
9038 result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(arg1,arg2);
9040 catch(std::out_of_range &_e) {
9041 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9043 catch(std::invalid_argument &_e) {
9044 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_OWN | 0 );
9054 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9055 PyObject *resultobj = 0;
9056 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9057 PySliceObject *arg2 = (PySliceObject *) 0 ;
9058 std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg3 = 0 ;
9061 int res3 = SWIG_OLDOBJ ;
9062 PyObject * obj0 = 0 ;
9063 PyObject * obj1 = 0 ;
9064 PyObject * obj2 = 0 ;
9066 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9068 if (!SWIG_IsOK(res1)) {
9069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9071 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9073 if (!PySlice_Check(obj1)) {
9074 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9076 arg2 = (PySliceObject *) obj1;
9079 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
9080 res3 = swig::asptr(obj2, &ptr);
9081 if (!SWIG_IsOK(res3)) {
9082 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
9085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
9090 std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg3);
9092 catch(std::out_of_range &_e) {
9093 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9095 catch(std::invalid_argument &_e) {
9096 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9099 resultobj = SWIG_Py_Void();
9100 if (SWIG_IsNewObj(res3)) delete arg3;
9103 if (SWIG_IsNewObj(res3)) delete arg3;
9108 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9109 PyObject *resultobj = 0;
9110 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9111 PySliceObject *arg2 = (PySliceObject *) 0 ;
9114 PyObject * obj0 = 0 ;
9115 PyObject * obj1 = 0 ;
9117 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___setitem__",&obj0,&obj1)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9122 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9124 if (!PySlice_Check(obj1)) {
9125 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9127 arg2 = (PySliceObject *) obj1;
9130 std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(arg1,arg2);
9132 catch(std::out_of_range &_e) {
9133 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9135 catch(std::invalid_argument &_e) {
9136 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9139 resultobj = SWIG_Py_Void();
9146 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9149 PySliceObject *arg2 = (PySliceObject *) 0 ;
9152 PyObject * obj0 = 0 ;
9153 PyObject * obj1 = 0 ;
9155 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
9156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9160 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9162 if (!PySlice_Check(obj1)) {
9163 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9165 arg2 = (PySliceObject *) obj1;
9168 std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(arg1,arg2);
9170 catch(std::out_of_range &_e) {
9171 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9173 catch(std::invalid_argument &_e) {
9174 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9177 resultobj = SWIG_Py_Void();
9184 SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *self, PyObject *args) {
9186 PyObject *argv[3] = {
9191 if (!PyTuple_Check(args)) SWIG_fail;
9192 argc = args ? PyObject_Length(args) : 0;
9193 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
9194 argv[ii] = PyTuple_GET_ITEM(args,ii);
9198 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9199 _v = SWIG_CheckState(res);
9202 _v = PySlice_Check(argv[1]);
9205 return _wrap_VectorQuads___delitem____SWIG_1(self, args);
9211 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9212 _v = SWIG_CheckState(res);
9215 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9216 _v = SWIG_CheckState(res);
9219 return _wrap_VectorQuads___delitem____SWIG_0(self, args);
9225 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___delitem__'.\n"
9226 " Possible C/C++ prototypes are:\n"
9227 " std::vector< Hex::Quad * >::__delitem__(std::vector< Hex::Quad * >::difference_type)\n"
9228 " std::vector< Hex::Quad * >::__delitem__(PySliceObject *)\n");
9233 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 PyObject *resultobj = 0;
9235 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9236 std::vector< Hex::Quad * >::difference_type arg2 ;
9241 PyObject * obj0 = 0 ;
9242 PyObject * obj1 = 0 ;
9243 std::vector< Hex::Quad * >::value_type result;
9245 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
9246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9247 if (!SWIG_IsOK(res1)) {
9248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9250 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9251 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9252 if (!SWIG_IsOK(ecode2)) {
9253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
9255 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
9257 result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(arg1,arg2);
9259 catch(std::out_of_range &_e) {
9260 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
9270 SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *self, PyObject *args) {
9272 PyObject *argv[3] = {
9277 if (!PyTuple_Check(args)) SWIG_fail;
9278 argc = args ? PyObject_Length(args) : 0;
9279 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
9280 argv[ii] = PyTuple_GET_ITEM(args,ii);
9284 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9285 _v = SWIG_CheckState(res);
9288 _v = PySlice_Check(argv[1]);
9291 return _wrap_VectorQuads___getitem____SWIG_0(self, args);
9297 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9298 _v = SWIG_CheckState(res);
9301 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9302 _v = SWIG_CheckState(res);
9305 return _wrap_VectorQuads___getitem____SWIG_1(self, args);
9311 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___getitem__'.\n"
9312 " Possible C/C++ prototypes are:\n"
9313 " std::vector< Hex::Quad * >::__getitem__(PySliceObject *)\n"
9314 " std::vector< Hex::Quad * >::__getitem__(std::vector< Hex::Quad * >::difference_type)\n");
9319 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9320 PyObject *resultobj = 0;
9321 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9322 std::vector< Hex::Quad * >::difference_type arg2 ;
9323 std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
9330 PyObject * obj0 = 0 ;
9331 PyObject * obj1 = 0 ;
9332 PyObject * obj2 = 0 ;
9334 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9336 if (!SWIG_IsOK(res1)) {
9337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9339 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9340 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9341 if (!SWIG_IsOK(ecode2)) {
9342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
9344 arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
9345 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
9346 if (!SWIG_IsOK(res3)) {
9347 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9349 arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
9351 std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
9353 catch(std::out_of_range &_e) {
9354 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9357 resultobj = SWIG_Py_Void();
9364 SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *self, PyObject *args) {
9366 PyObject *argv[4] = {
9371 if (!PyTuple_Check(args)) SWIG_fail;
9372 argc = args ? PyObject_Length(args) : 0;
9373 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9374 argv[ii] = PyTuple_GET_ITEM(args,ii);
9378 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9379 _v = SWIG_CheckState(res);
9382 _v = PySlice_Check(argv[1]);
9385 return _wrap_VectorQuads___setitem____SWIG_1(self, args);
9391 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9392 _v = SWIG_CheckState(res);
9395 _v = PySlice_Check(argv[1]);
9398 int res = swig::asptr(argv[2], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9399 _v = SWIG_CheckState(res);
9401 return _wrap_VectorQuads___setitem____SWIG_0(self, args);
9408 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9409 _v = SWIG_CheckState(res);
9412 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9413 _v = SWIG_CheckState(res);
9417 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
9418 _v = SWIG_CheckState(res);
9420 return _wrap_VectorQuads___setitem____SWIG_2(self, args);
9427 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___setitem__'.\n"
9428 " Possible C/C++ prototypes are:\n"
9429 " std::vector< Hex::Quad * >::__setitem__(PySliceObject *,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n"
9430 " std::vector< Hex::Quad * >::__setitem__(PySliceObject *)\n"
9431 " std::vector< Hex::Quad * >::__setitem__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::value_type)\n");
9436 SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9437 PyObject *resultobj = 0;
9438 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9441 PyObject * obj0 = 0 ;
9442 std::vector< Hex::Quad * >::value_type result;
9444 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9449 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9451 result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
9453 catch(std::out_of_range &_e) {
9454 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
9464 SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9465 PyObject *resultobj = 0;
9466 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9467 std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9475 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
9476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9477 if (!SWIG_IsOK(res1)) {
9478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9480 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
9482 if (!SWIG_IsOK(res2)) {
9483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9485 arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
9486 std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
9487 resultobj = SWIG_Py_Void();
9494 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9495 PyObject *resultobj = 0;
9496 std::vector< Hex::Quad * > *result = 0 ;
9498 if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
9499 result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >();
9500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
9507 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508 PyObject *resultobj = 0;
9509 std::vector< Hex::Quad * > *arg1 = 0 ;
9510 int res1 = SWIG_OLDOBJ ;
9511 PyObject * obj0 = 0 ;
9512 std::vector< Hex::Quad * > *result = 0 ;
9514 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
9516 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
9517 res1 = swig::asptr(obj0, &ptr);
9518 if (!SWIG_IsOK(res1)) {
9519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
9522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
9526 result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >((std::vector< Hex::Quad * > const &)*arg1);
9527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
9528 if (SWIG_IsNewObj(res1)) delete arg1;
9531 if (SWIG_IsNewObj(res1)) delete arg1;
9536 SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 PyObject *resultobj = 0;
9538 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9541 PyObject * obj0 = 0 ;
9544 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
9545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9546 if (!SWIG_IsOK(res1)) {
9547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9549 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9550 result = (bool)((std::vector< Hex::Quad * > const *)arg1)->empty();
9551 resultobj = SWIG_From_bool(static_cast< bool >(result));
9558 SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9559 PyObject *resultobj = 0;
9560 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9563 PyObject * obj0 = 0 ;
9564 std::vector< Hex::Quad * >::size_type result;
9566 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
9567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9568 if (!SWIG_IsOK(res1)) {
9569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9571 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9572 result = ((std::vector< Hex::Quad * > const *)arg1)->size();
9573 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9580 SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9581 PyObject *resultobj = 0;
9582 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9583 std::vector< Hex::Quad * > *arg2 = 0 ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9591 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
9592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9593 if (!SWIG_IsOK(res1)) {
9594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9596 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 );
9598 if (!SWIG_IsOK(res2)) {
9599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
9602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
9604 arg2 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp2);
9605 (arg1)->swap(*arg2);
9606 resultobj = SWIG_Py_Void();
9613 SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9614 PyObject *resultobj = 0;
9615 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9618 PyObject * obj0 = 0 ;
9619 std::vector< Hex::Quad * >::iterator result;
9621 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
9622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9623 if (!SWIG_IsOK(res1)) {
9624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9626 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9627 result = (arg1)->begin();
9628 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9629 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9636 SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9637 PyObject *resultobj = 0;
9638 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9641 PyObject * obj0 = 0 ;
9642 std::vector< Hex::Quad * >::iterator result;
9644 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
9645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9646 if (!SWIG_IsOK(res1)) {
9647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9649 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9650 result = (arg1)->end();
9651 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9652 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9659 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9660 PyObject *resultobj = 0;
9661 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9664 PyObject * obj0 = 0 ;
9665 std::vector< Hex::Quad * >::reverse_iterator result;
9667 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
9668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9672 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9673 result = (arg1)->rbegin();
9674 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::reverse_iterator & >(result)),
9675 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9682 SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9683 PyObject *resultobj = 0;
9684 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9687 PyObject * obj0 = 0 ;
9688 std::vector< Hex::Quad * >::reverse_iterator result;
9690 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
9691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9695 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9696 result = (arg1)->rend();
9697 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::reverse_iterator & >(result)),
9698 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9705 SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9706 PyObject *resultobj = 0;
9707 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9710 PyObject * obj0 = 0 ;
9712 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
9713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9714 if (!SWIG_IsOK(res1)) {
9715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9717 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9719 resultobj = SWIG_Py_Void();
9726 SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727 PyObject *resultobj = 0;
9728 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9731 PyObject * obj0 = 0 ;
9732 SwigValueWrapper< std::allocator< Hex::Quad * > > result;
9734 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
9735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9736 if (!SWIG_IsOK(res1)) {
9737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9739 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9740 result = ((std::vector< Hex::Quad * > const *)arg1)->get_allocator();
9741 resultobj = SWIG_NewPointerObj((new std::vector< Hex::Quad * >::allocator_type(static_cast< const std::vector< Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Quad_p_t, SWIG_POINTER_OWN | 0 );
9748 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9749 PyObject *resultobj = 0;
9750 std::vector< Hex::Quad * >::size_type arg1 ;
9753 PyObject * obj0 = 0 ;
9754 std::vector< Hex::Quad * > *result = 0 ;
9756 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
9757 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9758 if (!SWIG_IsOK(ecode1)) {
9759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9761 arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
9762 result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1);
9763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
9770 SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9771 PyObject *resultobj = 0;
9772 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9775 PyObject * obj0 = 0 ;
9777 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
9778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9779 if (!SWIG_IsOK(res1)) {
9780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9782 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9784 resultobj = SWIG_Py_Void();
9791 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9794 std::vector< Hex::Quad * >::size_type arg2 ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9802 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
9803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9804 if (!SWIG_IsOK(res1)) {
9805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9807 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9808 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9809 if (!SWIG_IsOK(ecode2)) {
9810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9812 arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
9813 (arg1)->resize(arg2);
9814 resultobj = SWIG_Py_Void();
9821 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822 PyObject *resultobj = 0;
9823 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9824 std::vector< Hex::Quad * >::iterator arg2 ;
9827 swig::SwigPyIterator *iter2 = 0 ;
9829 PyObject * obj0 = 0 ;
9830 PyObject * obj1 = 0 ;
9831 std::vector< Hex::Quad * >::iterator result;
9833 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9838 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9839 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9840 if (!SWIG_IsOK(res2) || !iter2) {
9841 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9843 swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9845 arg2 = iter_t->get_current();
9847 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9850 result = std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_0(arg1,arg2);
9851 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9852 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9859 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *resultobj = 0;
9861 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9862 std::vector< Hex::Quad * >::iterator arg2 ;
9863 std::vector< Hex::Quad * >::iterator arg3 ;
9866 swig::SwigPyIterator *iter2 = 0 ;
9868 swig::SwigPyIterator *iter3 = 0 ;
9870 PyObject * obj0 = 0 ;
9871 PyObject * obj1 = 0 ;
9872 PyObject * obj2 = 0 ;
9873 std::vector< Hex::Quad * >::iterator result;
9875 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
9877 if (!SWIG_IsOK(res1)) {
9878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9880 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9881 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9882 if (!SWIG_IsOK(res2) || !iter2) {
9883 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9885 swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9887 arg2 = iter_t->get_current();
9889 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9892 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
9893 if (!SWIG_IsOK(res3) || !iter3) {
9894 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9896 swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter3);
9898 arg3 = iter_t->get_current();
9900 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9903 result = std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
9904 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9905 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9912 SWIGINTERN PyObject *_wrap_VectorQuads_erase(PyObject *self, PyObject *args) {
9914 PyObject *argv[4] = {
9919 if (!PyTuple_Check(args)) SWIG_fail;
9920 argc = args ? PyObject_Length(args) : 0;
9921 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9922 argv[ii] = PyTuple_GET_ITEM(args,ii);
9926 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9927 _v = SWIG_CheckState(res);
9929 swig::SwigPyIterator *iter = 0;
9930 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9931 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9933 return _wrap_VectorQuads_erase__SWIG_0(self, args);
9939 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9940 _v = SWIG_CheckState(res);
9942 swig::SwigPyIterator *iter = 0;
9943 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9944 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9946 swig::SwigPyIterator *iter = 0;
9947 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9948 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9950 return _wrap_VectorQuads_erase__SWIG_1(self, args);
9957 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_erase'.\n"
9958 " Possible C/C++ prototypes are:\n"
9959 " std::vector< Hex::Quad * >::erase(std::vector< Hex::Quad * >::iterator)\n"
9960 " std::vector< Hex::Quad * >::erase(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::iterator)\n");
9965 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9966 PyObject *resultobj = 0;
9967 std::vector< Hex::Quad * >::size_type arg1 ;
9968 std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
9973 PyObject * obj0 = 0 ;
9974 PyObject * obj1 = 0 ;
9975 std::vector< Hex::Quad * > *result = 0 ;
9977 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
9978 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9979 if (!SWIG_IsOK(ecode1)) {
9980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9982 arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
9983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
9984 if (!SWIG_IsOK(res2)) {
9985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9987 arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
9988 result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1,arg2);
9989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
9996 SWIGINTERN PyObject *_wrap_new_VectorQuads(PyObject *self, PyObject *args) {
9998 PyObject *argv[3] = {
10003 if (!PyTuple_Check(args)) SWIG_fail;
10004 argc = args ? PyObject_Length(args) : 0;
10005 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
10006 argv[ii] = PyTuple_GET_ITEM(args,ii);
10009 return _wrap_new_VectorQuads__SWIG_0(self, args);
10014 int res = SWIG_AsVal_size_t(argv[0], NULL);
10015 _v = SWIG_CheckState(res);
10018 return _wrap_new_VectorQuads__SWIG_2(self, args);
10023 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10024 _v = SWIG_CheckState(res);
10026 return _wrap_new_VectorQuads__SWIG_1(self, args);
10032 int res = SWIG_AsVal_size_t(argv[0], NULL);
10033 _v = SWIG_CheckState(res);
10037 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10038 _v = SWIG_CheckState(res);
10040 return _wrap_new_VectorQuads__SWIG_3(self, args);
10046 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorQuads'.\n"
10047 " Possible C/C++ prototypes are:\n"
10048 " std::vector< Hex::Quad * >::vector()\n"
10049 " std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * > const &)\n"
10050 " std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * >::size_type)\n"
10051 " std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10056 SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10057 PyObject *resultobj = 0;
10058 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10059 std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
10064 PyObject * obj0 = 0 ;
10065 PyObject * obj1 = 0 ;
10067 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
10068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10069 if (!SWIG_IsOK(res1)) {
10070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10072 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
10074 if (!SWIG_IsOK(res2)) {
10075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10077 arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
10078 (arg1)->push_back(arg2);
10079 resultobj = SWIG_Py_Void();
10086 SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10087 PyObject *resultobj = 0;
10088 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10091 PyObject * obj0 = 0 ;
10092 std::vector< Hex::Quad * >::value_type result;
10094 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
10095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10099 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10100 result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->front();
10101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
10108 SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10109 PyObject *resultobj = 0;
10110 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10113 PyObject * obj0 = 0 ;
10114 std::vector< Hex::Quad * >::value_type result;
10116 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10121 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10122 result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->back();
10123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
10130 SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131 PyObject *resultobj = 0;
10132 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10133 std::vector< Hex::Quad * >::size_type arg2 ;
10134 std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 PyObject * obj2 = 0 ;
10145 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
10146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10150 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10151 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10152 if (!SWIG_IsOK(ecode2)) {
10153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10155 arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10156 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
10157 if (!SWIG_IsOK(res3)) {
10158 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10160 arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10161 (arg1)->assign(arg2,arg3);
10162 resultobj = SWIG_Py_Void();
10169 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10170 PyObject *resultobj = 0;
10171 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10172 std::vector< Hex::Quad * >::size_type arg2 ;
10173 std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10180 PyObject * obj0 = 0 ;
10181 PyObject * obj1 = 0 ;
10182 PyObject * obj2 = 0 ;
10184 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
10185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10186 if (!SWIG_IsOK(res1)) {
10187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10189 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10190 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10191 if (!SWIG_IsOK(ecode2)) {
10192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10194 arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10195 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
10196 if (!SWIG_IsOK(res3)) {
10197 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10199 arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10200 (arg1)->resize(arg2,arg3);
10201 resultobj = SWIG_Py_Void();
10208 SWIGINTERN PyObject *_wrap_VectorQuads_resize(PyObject *self, PyObject *args) {
10210 PyObject *argv[4] = {
10215 if (!PyTuple_Check(args)) SWIG_fail;
10216 argc = args ? PyObject_Length(args) : 0;
10217 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
10218 argv[ii] = PyTuple_GET_ITEM(args,ii);
10222 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10223 _v = SWIG_CheckState(res);
10226 int res = SWIG_AsVal_size_t(argv[1], NULL);
10227 _v = SWIG_CheckState(res);
10230 return _wrap_VectorQuads_resize__SWIG_0(self, args);
10236 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10237 _v = SWIG_CheckState(res);
10240 int res = SWIG_AsVal_size_t(argv[1], NULL);
10241 _v = SWIG_CheckState(res);
10245 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10246 _v = SWIG_CheckState(res);
10248 return _wrap_VectorQuads_resize__SWIG_1(self, args);
10255 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_resize'.\n"
10256 " Possible C/C++ prototypes are:\n"
10257 " std::vector< Hex::Quad * >::resize(std::vector< Hex::Quad * >::size_type)\n"
10258 " std::vector< Hex::Quad * >::resize(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10263 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10264 PyObject *resultobj = 0;
10265 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10266 std::vector< Hex::Quad * >::iterator arg2 ;
10267 std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10270 swig::SwigPyIterator *iter2 = 0 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 PyObject * obj2 = 0 ;
10277 std::vector< Hex::Quad * >::iterator result;
10279 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10284 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10286 if (!SWIG_IsOK(res2) || !iter2) {
10287 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10289 swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
10291 arg2 = iter_t->get_current();
10293 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10296 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
10297 if (!SWIG_IsOK(res3)) {
10298 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10300 arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10301 result = std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
10302 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
10303 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10310 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10311 PyObject *resultobj = 0;
10312 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10313 std::vector< Hex::Quad * >::iterator arg2 ;
10314 std::vector< Hex::Quad * >::size_type arg3 ;
10315 std::vector< Hex::Quad * >::value_type arg4 = (std::vector< Hex::Quad * >::value_type) 0 ;
10318 swig::SwigPyIterator *iter2 = 0 ;
10324 PyObject * obj0 = 0 ;
10325 PyObject * obj1 = 0 ;
10326 PyObject * obj2 = 0 ;
10327 PyObject * obj3 = 0 ;
10329 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10331 if (!SWIG_IsOK(res1)) {
10332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10334 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10335 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10336 if (!SWIG_IsOK(res2) || !iter2) {
10337 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10339 swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
10341 arg2 = iter_t->get_current();
10343 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10346 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
10347 if (!SWIG_IsOK(ecode3)) {
10348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10350 arg3 = static_cast< std::vector< Hex::Quad * >::size_type >(val3);
10351 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
10352 if (!SWIG_IsOK(res4)) {
10353 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10355 arg4 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp4);
10356 std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
10357 resultobj = SWIG_Py_Void();
10364 SWIGINTERN PyObject *_wrap_VectorQuads_insert(PyObject *self, PyObject *args) {
10366 PyObject *argv[5] = {
10371 if (!PyTuple_Check(args)) SWIG_fail;
10372 argc = args ? PyObject_Length(args) : 0;
10373 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
10374 argv[ii] = PyTuple_GET_ITEM(args,ii);
10378 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10379 _v = SWIG_CheckState(res);
10381 swig::SwigPyIterator *iter = 0;
10382 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10383 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
10386 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10387 _v = SWIG_CheckState(res);
10389 return _wrap_VectorQuads_insert__SWIG_0(self, args);
10396 int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10397 _v = SWIG_CheckState(res);
10399 swig::SwigPyIterator *iter = 0;
10400 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10401 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
10404 int res = SWIG_AsVal_size_t(argv[2], NULL);
10405 _v = SWIG_CheckState(res);
10409 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10410 _v = SWIG_CheckState(res);
10412 return _wrap_VectorQuads_insert__SWIG_1(self, args);
10420 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_insert'.\n"
10421 " Possible C/C++ prototypes are:\n"
10422 " std::vector< Hex::Quad * >::insert(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::value_type)\n"
10423 " std::vector< Hex::Quad * >::insert(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10428 SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10429 PyObject *resultobj = 0;
10430 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10431 std::vector< Hex::Quad * >::size_type arg2 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10439 if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
10440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10441 if (!SWIG_IsOK(res1)) {
10442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10444 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10445 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10446 if (!SWIG_IsOK(ecode2)) {
10447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10449 arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10450 (arg1)->reserve(arg2);
10451 resultobj = SWIG_Py_Void();
10458 SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10459 PyObject *resultobj = 0;
10460 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10463 PyObject * obj0 = 0 ;
10464 std::vector< Hex::Quad * >::size_type result;
10466 if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
10467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
10468 if (!SWIG_IsOK(res1)) {
10469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10471 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10472 result = ((std::vector< Hex::Quad * > const *)arg1)->capacity();
10473 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10480 SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10481 PyObject *resultobj = 0;
10482 std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10485 PyObject * obj0 = 0 ;
10487 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
10488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_DISOWN | 0 );
10489 if (!SWIG_IsOK(res1)) {
10490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10492 arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10494 resultobj = SWIG_Py_Void();
10501 SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10503 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
10504 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_NewClientData(obj));
10505 return SWIG_Py_Void();
10508 SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509 PyObject *resultobj = 0;
10510 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10511 PyObject **arg2 = (PyObject **) 0 ;
10514 PyObject * obj0 = 0 ;
10515 swig::SwigPyIterator *result = 0 ;
10518 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
10519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10520 if (!SWIG_IsOK(res1)) {
10521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10523 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10524 result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
10525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
10532 SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10533 PyObject *resultobj = 0;
10534 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10537 PyObject * obj0 = 0 ;
10540 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
10541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10542 if (!SWIG_IsOK(res1)) {
10543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10545 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10546 result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector< Hex::Edge * > const *)arg1);
10547 resultobj = SWIG_From_bool(static_cast< bool >(result));
10554 SWIGINTERN PyObject *_wrap_VectorEdges___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10555 PyObject *resultobj = 0;
10556 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10559 PyObject * obj0 = 0 ;
10562 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___bool__",&obj0)) SWIG_fail;
10563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10564 if (!SWIG_IsOK(res1)) {
10565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___bool__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10567 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10568 result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____bool__((std::vector< Hex::Edge * > const *)arg1);
10569 resultobj = SWIG_From_bool(static_cast< bool >(result));
10576 SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10581 PyObject * obj0 = 0 ;
10582 std::vector< Hex::Edge * >::size_type result;
10584 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
10585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10586 if (!SWIG_IsOK(res1)) {
10587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10589 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10590 result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector< Hex::Edge * > const *)arg1);
10591 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10598 SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10601 std::vector< Hex::Edge * >::difference_type arg2 ;
10602 std::vector< Hex::Edge * >::difference_type arg3 ;
10609 PyObject * obj0 = 0 ;
10610 PyObject * obj1 = 0 ;
10611 PyObject * obj2 = 0 ;
10612 std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
10614 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10616 if (!SWIG_IsOK(res1)) {
10617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10619 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10620 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10621 if (!SWIG_IsOK(ecode2)) {
10622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10624 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10625 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10626 if (!SWIG_IsOK(ecode3)) {
10627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10629 arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10631 result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
10633 catch(std::out_of_range &_e) {
10634 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10636 catch(std::invalid_argument &_e) {
10637 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_OWN | 0 );
10647 SWIGINTERN PyObject *_wrap_VectorEdges___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10648 PyObject *resultobj = 0;
10649 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10650 std::vector< Hex::Edge * >::difference_type arg2 ;
10651 std::vector< Hex::Edge * >::difference_type arg3 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10662 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10664 if (!SWIG_IsOK(res1)) {
10665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10667 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10668 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10669 if (!SWIG_IsOK(ecode2)) {
10670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10672 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10673 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10674 if (!SWIG_IsOK(ecode3)) {
10675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10677 arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10679 std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
10681 catch(std::out_of_range &_e) {
10682 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10684 catch(std::invalid_argument &_e) {
10685 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10688 resultobj = SWIG_Py_Void();
10695 SWIGINTERN PyObject *_wrap_VectorEdges___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *resultobj = 0;
10697 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10698 std::vector< Hex::Edge * >::difference_type arg2 ;
10699 std::vector< Hex::Edge * >::difference_type arg3 ;
10700 std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg4 = 0 ;
10707 int res4 = SWIG_OLDOBJ ;
10708 PyObject * obj0 = 0 ;
10709 PyObject * obj1 = 0 ;
10710 PyObject * obj2 = 0 ;
10711 PyObject * obj3 = 0 ;
10713 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10715 if (!SWIG_IsOK(res1)) {
10716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10718 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10719 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10720 if (!SWIG_IsOK(ecode2)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10723 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10724 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10725 if (!SWIG_IsOK(ecode3)) {
10726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10728 arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10730 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
10731 res4 = swig::asptr(obj3, &ptr);
10732 if (!SWIG_IsOK(res4)) {
10733 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10736 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 &""'");
10741 std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg4);
10743 catch(std::out_of_range &_e) {
10744 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10746 catch(std::invalid_argument &_e) {
10747 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10750 resultobj = SWIG_Py_Void();
10751 if (SWIG_IsNewObj(res4)) delete arg4;
10754 if (SWIG_IsNewObj(res4)) delete arg4;
10759 SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *self, PyObject *args) {
10761 PyObject *argv[5] = {
10766 if (!PyTuple_Check(args)) SWIG_fail;
10767 argc = args ? PyObject_Length(args) : 0;
10768 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
10769 argv[ii] = PyTuple_GET_ITEM(args,ii);
10773 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10774 _v = SWIG_CheckState(res);
10777 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
10778 _v = SWIG_CheckState(res);
10782 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
10783 _v = SWIG_CheckState(res);
10786 return _wrap_VectorEdges___setslice____SWIG_0(self, args);
10793 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10794 _v = SWIG_CheckState(res);
10797 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
10798 _v = SWIG_CheckState(res);
10802 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
10803 _v = SWIG_CheckState(res);
10806 int res = swig::asptr(argv[3], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10807 _v = SWIG_CheckState(res);
10809 return _wrap_VectorEdges___setslice____SWIG_1(self, args);
10817 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___setslice__'.\n"
10818 " Possible C/C++ prototypes are:\n"
10819 " std::vector< Hex::Edge * >::__setslice__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::difference_type)\n"
10820 " std::vector< Hex::Edge * >::__setslice__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n");
10825 SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10826 PyObject *resultobj = 0;
10827 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10828 std::vector< Hex::Edge * >::difference_type arg2 ;
10829 std::vector< Hex::Edge * >::difference_type arg3 ;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 PyObject * obj2 = 0 ;
10840 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10842 if (!SWIG_IsOK(res1)) {
10843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10845 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10846 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10847 if (!SWIG_IsOK(ecode2)) {
10848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10850 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10851 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10852 if (!SWIG_IsOK(ecode3)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10855 arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10857 std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
10859 catch(std::out_of_range &_e) {
10860 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10862 catch(std::invalid_argument &_e) {
10863 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10866 resultobj = SWIG_Py_Void();
10873 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874 PyObject *resultobj = 0;
10875 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10876 std::vector< Hex::Edge * >::difference_type arg2 ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10884 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
10885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10889 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10890 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10891 if (!SWIG_IsOK(ecode2)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10894 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10896 std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(arg1,arg2);
10898 catch(std::out_of_range &_e) {
10899 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10901 catch(std::invalid_argument &_e) {
10902 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10905 resultobj = SWIG_Py_Void();
10912 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10913 PyObject *resultobj = 0;
10914 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10915 PySliceObject *arg2 = (PySliceObject *) 0 ;
10918 PyObject * obj0 = 0 ;
10919 PyObject * obj1 = 0 ;
10920 std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
10922 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
10923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10924 if (!SWIG_IsOK(res1)) {
10925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10927 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10929 if (!PySlice_Check(obj1)) {
10930 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
10932 arg2 = (PySliceObject *) obj1;
10935 result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(arg1,arg2);
10937 catch(std::out_of_range &_e) {
10938 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10940 catch(std::invalid_argument &_e) {
10941 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_OWN | 0 );
10951 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952 PyObject *resultobj = 0;
10953 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10954 PySliceObject *arg2 = (PySliceObject *) 0 ;
10955 std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg3 = 0 ;
10958 int res3 = SWIG_OLDOBJ ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 PyObject * obj2 = 0 ;
10963 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
10964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
10965 if (!SWIG_IsOK(res1)) {
10966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10968 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10970 if (!PySlice_Check(obj1)) {
10971 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
10973 arg2 = (PySliceObject *) obj1;
10976 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
10977 res3 = swig::asptr(obj2, &ptr);
10978 if (!SWIG_IsOK(res3)) {
10979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10987 std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg3);
10989 catch(std::out_of_range &_e) {
10990 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10992 catch(std::invalid_argument &_e) {
10993 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10996 resultobj = SWIG_Py_Void();
10997 if (SWIG_IsNewObj(res3)) delete arg3;
11000 if (SWIG_IsNewObj(res3)) delete arg3;
11005 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006 PyObject *resultobj = 0;
11007 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11008 PySliceObject *arg2 = (PySliceObject *) 0 ;
11011 PyObject * obj0 = 0 ;
11012 PyObject * obj1 = 0 ;
11014 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___setitem__",&obj0,&obj1)) SWIG_fail;
11015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11016 if (!SWIG_IsOK(res1)) {
11017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11019 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11021 if (!PySlice_Check(obj1)) {
11022 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
11024 arg2 = (PySliceObject *) obj1;
11027 std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(arg1,arg2);
11029 catch(std::out_of_range &_e) {
11030 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11032 catch(std::invalid_argument &_e) {
11033 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11036 resultobj = SWIG_Py_Void();
11043 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11044 PyObject *resultobj = 0;
11045 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11046 PySliceObject *arg2 = (PySliceObject *) 0 ;
11049 PyObject * obj0 = 0 ;
11050 PyObject * obj1 = 0 ;
11052 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
11053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11054 if (!SWIG_IsOK(res1)) {
11055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11057 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11059 if (!PySlice_Check(obj1)) {
11060 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
11062 arg2 = (PySliceObject *) obj1;
11065 std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(arg1,arg2);
11067 catch(std::out_of_range &_e) {
11068 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11070 catch(std::invalid_argument &_e) {
11071 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11074 resultobj = SWIG_Py_Void();
11081 SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *self, PyObject *args) {
11083 PyObject *argv[3] = {
11088 if (!PyTuple_Check(args)) SWIG_fail;
11089 argc = args ? PyObject_Length(args) : 0;
11090 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11091 argv[ii] = PyTuple_GET_ITEM(args,ii);
11095 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11096 _v = SWIG_CheckState(res);
11099 _v = PySlice_Check(argv[1]);
11102 return _wrap_VectorEdges___delitem____SWIG_1(self, args);
11108 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11109 _v = SWIG_CheckState(res);
11112 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11113 _v = SWIG_CheckState(res);
11116 return _wrap_VectorEdges___delitem____SWIG_0(self, args);
11122 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___delitem__'.\n"
11123 " Possible C/C++ prototypes are:\n"
11124 " std::vector< Hex::Edge * >::__delitem__(std::vector< Hex::Edge * >::difference_type)\n"
11125 " std::vector< Hex::Edge * >::__delitem__(PySliceObject *)\n");
11130 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131 PyObject *resultobj = 0;
11132 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11133 std::vector< Hex::Edge * >::difference_type arg2 ;
11138 PyObject * obj0 = 0 ;
11139 PyObject * obj1 = 0 ;
11140 std::vector< Hex::Edge * >::value_type result;
11142 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
11143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11144 if (!SWIG_IsOK(res1)) {
11145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11147 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11148 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11149 if (!SWIG_IsOK(ecode2)) {
11150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
11152 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
11154 result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(arg1,arg2);
11156 catch(std::out_of_range &_e) {
11157 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
11167 SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *self, PyObject *args) {
11169 PyObject *argv[3] = {
11174 if (!PyTuple_Check(args)) SWIG_fail;
11175 argc = args ? PyObject_Length(args) : 0;
11176 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11177 argv[ii] = PyTuple_GET_ITEM(args,ii);
11181 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11182 _v = SWIG_CheckState(res);
11185 _v = PySlice_Check(argv[1]);
11188 return _wrap_VectorEdges___getitem____SWIG_0(self, args);
11194 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11195 _v = SWIG_CheckState(res);
11198 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11199 _v = SWIG_CheckState(res);
11202 return _wrap_VectorEdges___getitem____SWIG_1(self, args);
11208 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___getitem__'.\n"
11209 " Possible C/C++ prototypes are:\n"
11210 " std::vector< Hex::Edge * >::__getitem__(PySliceObject *)\n"
11211 " std::vector< Hex::Edge * >::__getitem__(std::vector< Hex::Edge * >::difference_type)\n");
11216 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11217 PyObject *resultobj = 0;
11218 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11219 std::vector< Hex::Edge * >::difference_type arg2 ;
11220 std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
11227 PyObject * obj0 = 0 ;
11228 PyObject * obj1 = 0 ;
11229 PyObject * obj2 = 0 ;
11231 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
11232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11233 if (!SWIG_IsOK(res1)) {
11234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11236 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11237 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11238 if (!SWIG_IsOK(ecode2)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
11241 arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
11242 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
11243 if (!SWIG_IsOK(res3)) {
11244 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11246 arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
11248 std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
11250 catch(std::out_of_range &_e) {
11251 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11254 resultobj = SWIG_Py_Void();
11261 SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *self, PyObject *args) {
11263 PyObject *argv[4] = {
11268 if (!PyTuple_Check(args)) SWIG_fail;
11269 argc = args ? PyObject_Length(args) : 0;
11270 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
11271 argv[ii] = PyTuple_GET_ITEM(args,ii);
11275 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11276 _v = SWIG_CheckState(res);
11279 _v = PySlice_Check(argv[1]);
11282 return _wrap_VectorEdges___setitem____SWIG_1(self, args);
11288 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11289 _v = SWIG_CheckState(res);
11292 _v = PySlice_Check(argv[1]);
11295 int res = swig::asptr(argv[2], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11296 _v = SWIG_CheckState(res);
11298 return _wrap_VectorEdges___setitem____SWIG_0(self, args);
11305 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11306 _v = SWIG_CheckState(res);
11309 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11310 _v = SWIG_CheckState(res);
11314 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
11315 _v = SWIG_CheckState(res);
11317 return _wrap_VectorEdges___setitem____SWIG_2(self, args);
11324 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___setitem__'.\n"
11325 " Possible C/C++ prototypes are:\n"
11326 " std::vector< Hex::Edge * >::__setitem__(PySliceObject *,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n"
11327 " std::vector< Hex::Edge * >::__setitem__(PySliceObject *)\n"
11328 " std::vector< Hex::Edge * >::__setitem__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::value_type)\n");
11333 SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334 PyObject *resultobj = 0;
11335 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11338 PyObject * obj0 = 0 ;
11339 std::vector< Hex::Edge * >::value_type result;
11341 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11346 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11348 result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
11350 catch(std::out_of_range &_e) {
11351 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
11361 SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11362 PyObject *resultobj = 0;
11363 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11364 std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11372 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
11373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11374 if (!SWIG_IsOK(res1)) {
11375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11377 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
11379 if (!SWIG_IsOK(res2)) {
11380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11382 arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11383 std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
11384 resultobj = SWIG_Py_Void();
11391 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *resultobj = 0;
11393 std::vector< Hex::Edge * > *result = 0 ;
11395 if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
11396 result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >();
11397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
11404 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11405 PyObject *resultobj = 0;
11406 std::vector< Hex::Edge * > *arg1 = 0 ;
11407 int res1 = SWIG_OLDOBJ ;
11408 PyObject * obj0 = 0 ;
11409 std::vector< Hex::Edge * > *result = 0 ;
11411 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
11413 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
11414 res1 = swig::asptr(obj0, &ptr);
11415 if (!SWIG_IsOK(res1)) {
11416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
11419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
11423 result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >((std::vector< Hex::Edge * > const &)*arg1);
11424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
11425 if (SWIG_IsNewObj(res1)) delete arg1;
11428 if (SWIG_IsNewObj(res1)) delete arg1;
11433 SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434 PyObject *resultobj = 0;
11435 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11438 PyObject * obj0 = 0 ;
11441 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
11442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11443 if (!SWIG_IsOK(res1)) {
11444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11446 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11447 result = (bool)((std::vector< Hex::Edge * > const *)arg1)->empty();
11448 resultobj = SWIG_From_bool(static_cast< bool >(result));
11455 SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11456 PyObject *resultobj = 0;
11457 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11460 PyObject * obj0 = 0 ;
11461 std::vector< Hex::Edge * >::size_type result;
11463 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
11464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11465 if (!SWIG_IsOK(res1)) {
11466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11468 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11469 result = ((std::vector< Hex::Edge * > const *)arg1)->size();
11470 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11477 SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11478 PyObject *resultobj = 0;
11479 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11480 std::vector< Hex::Edge * > *arg2 = 0 ;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11488 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
11489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11493 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 );
11495 if (!SWIG_IsOK(res2)) {
11496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
11499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
11501 arg2 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp2);
11502 (arg1)->swap(*arg2);
11503 resultobj = SWIG_Py_Void();
11510 SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11511 PyObject *resultobj = 0;
11512 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11515 PyObject * obj0 = 0 ;
11516 std::vector< Hex::Edge * >::iterator result;
11518 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
11519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11523 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11524 result = (arg1)->begin();
11525 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11526 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11533 SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11534 PyObject *resultobj = 0;
11535 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11538 PyObject * obj0 = 0 ;
11539 std::vector< Hex::Edge * >::iterator result;
11541 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
11542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11543 if (!SWIG_IsOK(res1)) {
11544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11546 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11547 result = (arg1)->end();
11548 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11549 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11556 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11557 PyObject *resultobj = 0;
11558 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11561 PyObject * obj0 = 0 ;
11562 std::vector< Hex::Edge * >::reverse_iterator result;
11564 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
11565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11566 if (!SWIG_IsOK(res1)) {
11567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11569 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11570 result = (arg1)->rbegin();
11571 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::reverse_iterator & >(result)),
11572 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11579 SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11580 PyObject *resultobj = 0;
11581 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11584 PyObject * obj0 = 0 ;
11585 std::vector< Hex::Edge * >::reverse_iterator result;
11587 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
11588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11592 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11593 result = (arg1)->rend();
11594 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::reverse_iterator & >(result)),
11595 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11602 SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603 PyObject *resultobj = 0;
11604 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11607 PyObject * obj0 = 0 ;
11609 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
11610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11611 if (!SWIG_IsOK(res1)) {
11612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11614 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11616 resultobj = SWIG_Py_Void();
11623 SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11628 PyObject * obj0 = 0 ;
11629 SwigValueWrapper< std::allocator< Hex::Edge * > > result;
11631 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
11632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11636 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11637 result = ((std::vector< Hex::Edge * > const *)arg1)->get_allocator();
11638 resultobj = SWIG_NewPointerObj((new std::vector< Hex::Edge * >::allocator_type(static_cast< const std::vector< Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Edge_p_t, SWIG_POINTER_OWN | 0 );
11645 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 PyObject *resultobj = 0;
11647 std::vector< Hex::Edge * >::size_type arg1 ;
11650 PyObject * obj0 = 0 ;
11651 std::vector< Hex::Edge * > *result = 0 ;
11653 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
11654 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11655 if (!SWIG_IsOK(ecode1)) {
11656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11658 arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
11659 result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1);
11660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
11667 SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11672 PyObject * obj0 = 0 ;
11674 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
11675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11679 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11680 (arg1)->pop_back();
11681 resultobj = SWIG_Py_Void();
11688 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11689 PyObject *resultobj = 0;
11690 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11691 std::vector< Hex::Edge * >::size_type arg2 ;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11699 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
11700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11704 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11705 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11706 if (!SWIG_IsOK(ecode2)) {
11707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11709 arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
11710 (arg1)->resize(arg2);
11711 resultobj = SWIG_Py_Void();
11718 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *resultobj = 0;
11720 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11721 std::vector< Hex::Edge * >::iterator arg2 ;
11724 swig::SwigPyIterator *iter2 = 0 ;
11726 PyObject * obj0 = 0 ;
11727 PyObject * obj1 = 0 ;
11728 std::vector< Hex::Edge * >::iterator result;
11730 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
11731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11735 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11736 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
11737 if (!SWIG_IsOK(res2) || !iter2) {
11738 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11740 swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
11742 arg2 = iter_t->get_current();
11744 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11747 result = std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_0(arg1,arg2);
11748 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11749 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11756 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757 PyObject *resultobj = 0;
11758 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11759 std::vector< Hex::Edge * >::iterator arg2 ;
11760 std::vector< Hex::Edge * >::iterator arg3 ;
11763 swig::SwigPyIterator *iter2 = 0 ;
11765 swig::SwigPyIterator *iter3 = 0 ;
11767 PyObject * obj0 = 0 ;
11768 PyObject * obj1 = 0 ;
11769 PyObject * obj2 = 0 ;
11770 std::vector< Hex::Edge * >::iterator result;
11772 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
11773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11774 if (!SWIG_IsOK(res1)) {
11775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11777 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11778 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
11779 if (!SWIG_IsOK(res2) || !iter2) {
11780 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11782 swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
11784 arg2 = iter_t->get_current();
11786 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11789 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
11790 if (!SWIG_IsOK(res3) || !iter3) {
11791 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11793 swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter3);
11795 arg3 = iter_t->get_current();
11797 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11800 result = std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
11801 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11802 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11809 SWIGINTERN PyObject *_wrap_VectorEdges_erase(PyObject *self, PyObject *args) {
11811 PyObject *argv[4] = {
11816 if (!PyTuple_Check(args)) SWIG_fail;
11817 argc = args ? PyObject_Length(args) : 0;
11818 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
11819 argv[ii] = PyTuple_GET_ITEM(args,ii);
11823 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11824 _v = SWIG_CheckState(res);
11826 swig::SwigPyIterator *iter = 0;
11827 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11828 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11830 return _wrap_VectorEdges_erase__SWIG_0(self, args);
11836 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11837 _v = SWIG_CheckState(res);
11839 swig::SwigPyIterator *iter = 0;
11840 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11841 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11843 swig::SwigPyIterator *iter = 0;
11844 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11845 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11847 return _wrap_VectorEdges_erase__SWIG_1(self, args);
11854 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_erase'.\n"
11855 " Possible C/C++ prototypes are:\n"
11856 " std::vector< Hex::Edge * >::erase(std::vector< Hex::Edge * >::iterator)\n"
11857 " std::vector< Hex::Edge * >::erase(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::iterator)\n");
11862 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11863 PyObject *resultobj = 0;
11864 std::vector< Hex::Edge * >::size_type arg1 ;
11865 std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11870 PyObject * obj0 = 0 ;
11871 PyObject * obj1 = 0 ;
11872 std::vector< Hex::Edge * > *result = 0 ;
11874 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
11875 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11876 if (!SWIG_IsOK(ecode1)) {
11877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11879 arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
11880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
11881 if (!SWIG_IsOK(res2)) {
11882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11884 arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11885 result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1,arg2);
11886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
11893 SWIGINTERN PyObject *_wrap_new_VectorEdges(PyObject *self, PyObject *args) {
11895 PyObject *argv[3] = {
11900 if (!PyTuple_Check(args)) SWIG_fail;
11901 argc = args ? PyObject_Length(args) : 0;
11902 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11903 argv[ii] = PyTuple_GET_ITEM(args,ii);
11906 return _wrap_new_VectorEdges__SWIG_0(self, args);
11911 int res = SWIG_AsVal_size_t(argv[0], NULL);
11912 _v = SWIG_CheckState(res);
11915 return _wrap_new_VectorEdges__SWIG_2(self, args);
11920 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11921 _v = SWIG_CheckState(res);
11923 return _wrap_new_VectorEdges__SWIG_1(self, args);
11929 int res = SWIG_AsVal_size_t(argv[0], NULL);
11930 _v = SWIG_CheckState(res);
11934 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
11935 _v = SWIG_CheckState(res);
11937 return _wrap_new_VectorEdges__SWIG_3(self, args);
11943 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorEdges'.\n"
11944 " Possible C/C++ prototypes are:\n"
11945 " std::vector< Hex::Edge * >::vector()\n"
11946 " std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * > const &)\n"
11947 " std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * >::size_type)\n"
11948 " std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
11953 SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11954 PyObject *resultobj = 0;
11955 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11956 std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11961 PyObject * obj0 = 0 ;
11962 PyObject * obj1 = 0 ;
11964 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
11965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11966 if (!SWIG_IsOK(res1)) {
11967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11969 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
11971 if (!SWIG_IsOK(res2)) {
11972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11974 arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11975 (arg1)->push_back(arg2);
11976 resultobj = SWIG_Py_Void();
11983 SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 PyObject *resultobj = 0;
11985 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11988 PyObject * obj0 = 0 ;
11989 std::vector< Hex::Edge * >::value_type result;
11991 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
11992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
11993 if (!SWIG_IsOK(res1)) {
11994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11996 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11997 result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->front();
11998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
12005 SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12006 PyObject *resultobj = 0;
12007 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12010 PyObject * obj0 = 0 ;
12011 std::vector< Hex::Edge * >::value_type result;
12013 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
12018 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12019 result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->back();
12020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
12027 SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 PyObject *resultobj = 0;
12029 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12030 std::vector< Hex::Edge * >::size_type arg2 ;
12031 std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 PyObject * obj2 = 0 ;
12042 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
12043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12044 if (!SWIG_IsOK(res1)) {
12045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12047 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12048 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12049 if (!SWIG_IsOK(ecode2)) {
12050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12052 arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12053 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
12054 if (!SWIG_IsOK(res3)) {
12055 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12057 arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12058 (arg1)->assign(arg2,arg3);
12059 resultobj = SWIG_Py_Void();
12066 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12067 PyObject *resultobj = 0;
12068 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12069 std::vector< Hex::Edge * >::size_type arg2 ;
12070 std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12077 PyObject * obj0 = 0 ;
12078 PyObject * obj1 = 0 ;
12079 PyObject * obj2 = 0 ;
12081 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
12082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12086 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12087 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12088 if (!SWIG_IsOK(ecode2)) {
12089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12091 arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12092 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
12093 if (!SWIG_IsOK(res3)) {
12094 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12096 arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12097 (arg1)->resize(arg2,arg3);
12098 resultobj = SWIG_Py_Void();
12105 SWIGINTERN PyObject *_wrap_VectorEdges_resize(PyObject *self, PyObject *args) {
12107 PyObject *argv[4] = {
12112 if (!PyTuple_Check(args)) SWIG_fail;
12113 argc = args ? PyObject_Length(args) : 0;
12114 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
12115 argv[ii] = PyTuple_GET_ITEM(args,ii);
12119 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12120 _v = SWIG_CheckState(res);
12123 int res = SWIG_AsVal_size_t(argv[1], NULL);
12124 _v = SWIG_CheckState(res);
12127 return _wrap_VectorEdges_resize__SWIG_0(self, args);
12133 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12134 _v = SWIG_CheckState(res);
12137 int res = SWIG_AsVal_size_t(argv[1], NULL);
12138 _v = SWIG_CheckState(res);
12142 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12143 _v = SWIG_CheckState(res);
12145 return _wrap_VectorEdges_resize__SWIG_1(self, args);
12152 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_resize'.\n"
12153 " Possible C/C++ prototypes are:\n"
12154 " std::vector< Hex::Edge * >::resize(std::vector< Hex::Edge * >::size_type)\n"
12155 " std::vector< Hex::Edge * >::resize(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
12160 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *resultobj = 0;
12162 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12163 std::vector< Hex::Edge * >::iterator arg2 ;
12164 std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12167 swig::SwigPyIterator *iter2 = 0 ;
12171 PyObject * obj0 = 0 ;
12172 PyObject * obj1 = 0 ;
12173 PyObject * obj2 = 0 ;
12174 std::vector< Hex::Edge * >::iterator result;
12176 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
12177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12178 if (!SWIG_IsOK(res1)) {
12179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12181 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12182 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12183 if (!SWIG_IsOK(res2) || !iter2) {
12184 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12186 swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
12188 arg2 = iter_t->get_current();
12190 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12193 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
12194 if (!SWIG_IsOK(res3)) {
12195 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12197 arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12198 result = std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
12199 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
12200 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
12207 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 PyObject *resultobj = 0;
12209 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12210 std::vector< Hex::Edge * >::iterator arg2 ;
12211 std::vector< Hex::Edge * >::size_type arg3 ;
12212 std::vector< Hex::Edge * >::value_type arg4 = (std::vector< Hex::Edge * >::value_type) 0 ;
12215 swig::SwigPyIterator *iter2 = 0 ;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 PyObject * obj2 = 0 ;
12224 PyObject * obj3 = 0 ;
12226 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12228 if (!SWIG_IsOK(res1)) {
12229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12231 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12232 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12233 if (!SWIG_IsOK(res2) || !iter2) {
12234 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12236 swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
12238 arg2 = iter_t->get_current();
12240 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12243 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12244 if (!SWIG_IsOK(ecode3)) {
12245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12247 arg3 = static_cast< std::vector< Hex::Edge * >::size_type >(val3);
12248 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 | 0 );
12249 if (!SWIG_IsOK(res4)) {
12250 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12252 arg4 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp4);
12253 std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
12254 resultobj = SWIG_Py_Void();
12261 SWIGINTERN PyObject *_wrap_VectorEdges_insert(PyObject *self, PyObject *args) {
12263 PyObject *argv[5] = {
12268 if (!PyTuple_Check(args)) SWIG_fail;
12269 argc = args ? PyObject_Length(args) : 0;
12270 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
12271 argv[ii] = PyTuple_GET_ITEM(args,ii);
12275 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12276 _v = SWIG_CheckState(res);
12278 swig::SwigPyIterator *iter = 0;
12279 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12280 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
12283 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12284 _v = SWIG_CheckState(res);
12286 return _wrap_VectorEdges_insert__SWIG_0(self, args);
12293 int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12294 _v = SWIG_CheckState(res);
12296 swig::SwigPyIterator *iter = 0;
12297 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12298 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
12301 int res = SWIG_AsVal_size_t(argv[2], NULL);
12302 _v = SWIG_CheckState(res);
12306 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12307 _v = SWIG_CheckState(res);
12309 return _wrap_VectorEdges_insert__SWIG_1(self, args);
12317 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_insert'.\n"
12318 " Possible C/C++ prototypes are:\n"
12319 " std::vector< Hex::Edge * >::insert(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::value_type)\n"
12320 " std::vector< Hex::Edge * >::insert(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
12325 SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 PyObject *resultobj = 0;
12327 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12328 std::vector< Hex::Edge * >::size_type arg2 ;
12333 PyObject * obj0 = 0 ;
12334 PyObject * obj1 = 0 ;
12336 if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
12337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12338 if (!SWIG_IsOK(res1)) {
12339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12341 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12342 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12343 if (!SWIG_IsOK(ecode2)) {
12344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12346 arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12347 (arg1)->reserve(arg2);
12348 resultobj = SWIG_Py_Void();
12355 SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12356 PyObject *resultobj = 0;
12357 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12360 PyObject * obj0 = 0 ;
12361 std::vector< Hex::Edge * >::size_type result;
12363 if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
12364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
12365 if (!SWIG_IsOK(res1)) {
12366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
12368 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12369 result = ((std::vector< Hex::Edge * > const *)arg1)->capacity();
12370 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12377 SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378 PyObject *resultobj = 0;
12379 std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12382 PyObject * obj0 = 0 ;
12384 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
12385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_DISOWN | 0 );
12386 if (!SWIG_IsOK(res1)) {
12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12389 arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12391 resultobj = SWIG_Py_Void();
12398 SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12400 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
12401 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_NewClientData(obj));
12402 return SWIG_Py_Void();
12405 SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406 PyObject *resultobj = 0;
12407 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12408 PyObject **arg2 = (PyObject **) 0 ;
12411 PyObject * obj0 = 0 ;
12412 swig::SwigPyIterator *result = 0 ;
12415 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
12416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12420 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12421 result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
12422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
12429 SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430 PyObject *resultobj = 0;
12431 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12434 PyObject * obj0 = 0 ;
12437 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
12438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12439 if (!SWIG_IsOK(res1)) {
12440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12442 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12443 result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector< Hex::Vertex * > const *)arg1);
12444 resultobj = SWIG_From_bool(static_cast< bool >(result));
12451 SWIGINTERN PyObject *_wrap_VectorVertices___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12452 PyObject *resultobj = 0;
12453 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12456 PyObject * obj0 = 0 ;
12459 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___bool__",&obj0)) SWIG_fail;
12460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12461 if (!SWIG_IsOK(res1)) {
12462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___bool__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12464 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12465 result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____bool__((std::vector< Hex::Vertex * > const *)arg1);
12466 resultobj = SWIG_From_bool(static_cast< bool >(result));
12473 SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474 PyObject *resultobj = 0;
12475 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12478 PyObject * obj0 = 0 ;
12479 std::vector< Hex::Vertex * >::size_type result;
12481 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
12482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12486 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12487 result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector< Hex::Vertex * > const *)arg1);
12488 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12495 SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12498 std::vector< Hex::Vertex * >::difference_type arg2 ;
12499 std::vector< Hex::Vertex * >::difference_type arg3 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 PyObject * obj2 = 0 ;
12509 std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
12511 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12516 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12517 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12518 if (!SWIG_IsOK(ecode2)) {
12519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12521 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12522 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12523 if (!SWIG_IsOK(ecode3)) {
12524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12526 arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12528 result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
12530 catch(std::out_of_range &_e) {
12531 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12533 catch(std::invalid_argument &_e) {
12534 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_OWN | 0 );
12544 SWIGINTERN PyObject *_wrap_VectorVertices___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545 PyObject *resultobj = 0;
12546 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12547 std::vector< Hex::Vertex * >::difference_type arg2 ;
12548 std::vector< Hex::Vertex * >::difference_type arg3 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12559 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12561 if (!SWIG_IsOK(res1)) {
12562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12564 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12565 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12566 if (!SWIG_IsOK(ecode2)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12569 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12570 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12571 if (!SWIG_IsOK(ecode3)) {
12572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12574 arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12576 std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
12578 catch(std::out_of_range &_e) {
12579 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12581 catch(std::invalid_argument &_e) {
12582 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12585 resultobj = SWIG_Py_Void();
12592 SWIGINTERN PyObject *_wrap_VectorVertices___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12593 PyObject *resultobj = 0;
12594 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12595 std::vector< Hex::Vertex * >::difference_type arg2 ;
12596 std::vector< Hex::Vertex * >::difference_type arg3 ;
12597 std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg4 = 0 ;
12604 int res4 = SWIG_OLDOBJ ;
12605 PyObject * obj0 = 0 ;
12606 PyObject * obj1 = 0 ;
12607 PyObject * obj2 = 0 ;
12608 PyObject * obj3 = 0 ;
12610 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12615 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12616 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12617 if (!SWIG_IsOK(ecode2)) {
12618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12620 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12621 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12622 if (!SWIG_IsOK(ecode3)) {
12623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12625 arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12627 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
12628 res4 = swig::asptr(obj3, &ptr);
12629 if (!SWIG_IsOK(res4)) {
12630 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12633 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 &""'");
12638 std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg4);
12640 catch(std::out_of_range &_e) {
12641 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12643 catch(std::invalid_argument &_e) {
12644 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12647 resultobj = SWIG_Py_Void();
12648 if (SWIG_IsNewObj(res4)) delete arg4;
12651 if (SWIG_IsNewObj(res4)) delete arg4;
12656 SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *self, PyObject *args) {
12658 PyObject *argv[5] = {
12663 if (!PyTuple_Check(args)) SWIG_fail;
12664 argc = args ? PyObject_Length(args) : 0;
12665 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
12666 argv[ii] = PyTuple_GET_ITEM(args,ii);
12670 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12671 _v = SWIG_CheckState(res);
12674 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
12675 _v = SWIG_CheckState(res);
12679 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
12680 _v = SWIG_CheckState(res);
12683 return _wrap_VectorVertices___setslice____SWIG_0(self, args);
12690 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12691 _v = SWIG_CheckState(res);
12694 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
12695 _v = SWIG_CheckState(res);
12699 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
12700 _v = SWIG_CheckState(res);
12703 int res = swig::asptr(argv[3], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12704 _v = SWIG_CheckState(res);
12706 return _wrap_VectorVertices___setslice____SWIG_1(self, args);
12714 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___setslice__'.\n"
12715 " Possible C/C++ prototypes are:\n"
12716 " std::vector< Hex::Vertex * >::__setslice__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::difference_type)\n"
12717 " std::vector< Hex::Vertex * >::__setslice__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n");
12722 SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723 PyObject *resultobj = 0;
12724 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12725 std::vector< Hex::Vertex * >::difference_type arg2 ;
12726 std::vector< Hex::Vertex * >::difference_type arg3 ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 PyObject * obj2 = 0 ;
12737 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12739 if (!SWIG_IsOK(res1)) {
12740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12742 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12743 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12744 if (!SWIG_IsOK(ecode2)) {
12745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12747 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12748 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12749 if (!SWIG_IsOK(ecode3)) {
12750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12752 arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12754 std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
12756 catch(std::out_of_range &_e) {
12757 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12759 catch(std::invalid_argument &_e) {
12760 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12763 resultobj = SWIG_Py_Void();
12770 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12771 PyObject *resultobj = 0;
12772 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12773 std::vector< Hex::Vertex * >::difference_type arg2 ;
12778 PyObject * obj0 = 0 ;
12779 PyObject * obj1 = 0 ;
12781 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
12782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12786 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12787 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12788 if (!SWIG_IsOK(ecode2)) {
12789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12791 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12793 std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(arg1,arg2);
12795 catch(std::out_of_range &_e) {
12796 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12798 catch(std::invalid_argument &_e) {
12799 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12802 resultobj = SWIG_Py_Void();
12809 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810 PyObject *resultobj = 0;
12811 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12812 PySliceObject *arg2 = (PySliceObject *) 0 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
12819 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
12820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12821 if (!SWIG_IsOK(res1)) {
12822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12824 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12826 if (!PySlice_Check(obj1)) {
12827 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12829 arg2 = (PySliceObject *) obj1;
12832 result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(arg1,arg2);
12834 catch(std::out_of_range &_e) {
12835 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12837 catch(std::invalid_argument &_e) {
12838 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_OWN | 0 );
12848 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *resultobj = 0;
12850 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12851 PySliceObject *arg2 = (PySliceObject *) 0 ;
12852 std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg3 = 0 ;
12855 int res3 = SWIG_OLDOBJ ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 PyObject * obj2 = 0 ;
12860 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
12861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12862 if (!SWIG_IsOK(res1)) {
12863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12865 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12867 if (!PySlice_Check(obj1)) {
12868 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12870 arg2 = (PySliceObject *) obj1;
12873 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
12874 res3 = swig::asptr(obj2, &ptr);
12875 if (!SWIG_IsOK(res3)) {
12876 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12884 std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg3);
12886 catch(std::out_of_range &_e) {
12887 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12889 catch(std::invalid_argument &_e) {
12890 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12893 resultobj = SWIG_Py_Void();
12894 if (SWIG_IsNewObj(res3)) delete arg3;
12897 if (SWIG_IsNewObj(res3)) delete arg3;
12902 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12905 PySliceObject *arg2 = (PySliceObject *) 0 ;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12911 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___setitem__",&obj0,&obj1)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12916 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12918 if (!PySlice_Check(obj1)) {
12919 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12921 arg2 = (PySliceObject *) obj1;
12924 std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(arg1,arg2);
12926 catch(std::out_of_range &_e) {
12927 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12929 catch(std::invalid_argument &_e) {
12930 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12933 resultobj = SWIG_Py_Void();
12940 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *resultobj = 0;
12942 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12943 PySliceObject *arg2 = (PySliceObject *) 0 ;
12946 PyObject * obj0 = 0 ;
12947 PyObject * obj1 = 0 ;
12949 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
12950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
12951 if (!SWIG_IsOK(res1)) {
12952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12954 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12956 if (!PySlice_Check(obj1)) {
12957 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12959 arg2 = (PySliceObject *) obj1;
12962 std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(arg1,arg2);
12964 catch(std::out_of_range &_e) {
12965 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12967 catch(std::invalid_argument &_e) {
12968 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12971 resultobj = SWIG_Py_Void();
12978 SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *self, PyObject *args) {
12980 PyObject *argv[3] = {
12985 if (!PyTuple_Check(args)) SWIG_fail;
12986 argc = args ? PyObject_Length(args) : 0;
12987 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
12988 argv[ii] = PyTuple_GET_ITEM(args,ii);
12992 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12993 _v = SWIG_CheckState(res);
12996 _v = PySlice_Check(argv[1]);
12999 return _wrap_VectorVertices___delitem____SWIG_1(self, args);
13005 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13006 _v = SWIG_CheckState(res);
13009 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13010 _v = SWIG_CheckState(res);
13013 return _wrap_VectorVertices___delitem____SWIG_0(self, args);
13019 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___delitem__'.\n"
13020 " Possible C/C++ prototypes are:\n"
13021 " std::vector< Hex::Vertex * >::__delitem__(std::vector< Hex::Vertex * >::difference_type)\n"
13022 " std::vector< Hex::Vertex * >::__delitem__(PySliceObject *)\n");
13027 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13028 PyObject *resultobj = 0;
13029 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13030 std::vector< Hex::Vertex * >::difference_type arg2 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 std::vector< Hex::Vertex * >::value_type result;
13039 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
13040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13041 if (!SWIG_IsOK(res1)) {
13042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13044 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13045 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13046 if (!SWIG_IsOK(ecode2)) {
13047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
13049 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
13051 result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(arg1,arg2);
13053 catch(std::out_of_range &_e) {
13054 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13064 SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *self, PyObject *args) {
13066 PyObject *argv[3] = {
13071 if (!PyTuple_Check(args)) SWIG_fail;
13072 argc = args ? PyObject_Length(args) : 0;
13073 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
13074 argv[ii] = PyTuple_GET_ITEM(args,ii);
13078 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13079 _v = SWIG_CheckState(res);
13082 _v = PySlice_Check(argv[1]);
13085 return _wrap_VectorVertices___getitem____SWIG_0(self, args);
13091 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13092 _v = SWIG_CheckState(res);
13095 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13096 _v = SWIG_CheckState(res);
13099 return _wrap_VectorVertices___getitem____SWIG_1(self, args);
13105 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___getitem__'.\n"
13106 " Possible C/C++ prototypes are:\n"
13107 " std::vector< Hex::Vertex * >::__getitem__(PySliceObject *)\n"
13108 " std::vector< Hex::Vertex * >::__getitem__(std::vector< Hex::Vertex * >::difference_type)\n");
13113 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13116 std::vector< Hex::Vertex * >::difference_type arg2 ;
13117 std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13124 PyObject * obj0 = 0 ;
13125 PyObject * obj1 = 0 ;
13126 PyObject * obj2 = 0 ;
13128 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
13129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13130 if (!SWIG_IsOK(res1)) {
13131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13133 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13134 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13135 if (!SWIG_IsOK(ecode2)) {
13136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
13138 arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
13139 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13140 if (!SWIG_IsOK(res3)) {
13141 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13143 arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13145 std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
13147 catch(std::out_of_range &_e) {
13148 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13151 resultobj = SWIG_Py_Void();
13158 SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *self, PyObject *args) {
13160 PyObject *argv[4] = {
13165 if (!PyTuple_Check(args)) SWIG_fail;
13166 argc = args ? PyObject_Length(args) : 0;
13167 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13168 argv[ii] = PyTuple_GET_ITEM(args,ii);
13172 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13173 _v = SWIG_CheckState(res);
13176 _v = PySlice_Check(argv[1]);
13179 return _wrap_VectorVertices___setitem____SWIG_1(self, args);
13185 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13186 _v = SWIG_CheckState(res);
13189 _v = PySlice_Check(argv[1]);
13192 int res = swig::asptr(argv[2], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13193 _v = SWIG_CheckState(res);
13195 return _wrap_VectorVertices___setitem____SWIG_0(self, args);
13202 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13203 _v = SWIG_CheckState(res);
13206 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13207 _v = SWIG_CheckState(res);
13211 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
13212 _v = SWIG_CheckState(res);
13214 return _wrap_VectorVertices___setitem____SWIG_2(self, args);
13221 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___setitem__'.\n"
13222 " Possible C/C++ prototypes are:\n"
13223 " std::vector< Hex::Vertex * >::__setitem__(PySliceObject *,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n"
13224 " std::vector< Hex::Vertex * >::__setitem__(PySliceObject *)\n"
13225 " std::vector< Hex::Vertex * >::__setitem__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::value_type)\n");
13230 SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13231 PyObject *resultobj = 0;
13232 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13235 PyObject * obj0 = 0 ;
13236 std::vector< Hex::Vertex * >::value_type result;
13238 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
13239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13240 if (!SWIG_IsOK(res1)) {
13241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13243 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13245 result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
13247 catch(std::out_of_range &_e) {
13248 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13258 SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13259 PyObject *resultobj = 0;
13260 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13261 std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13266 PyObject * obj0 = 0 ;
13267 PyObject * obj1 = 0 ;
13269 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13274 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13276 if (!SWIG_IsOK(res2)) {
13277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13279 arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13280 std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
13281 resultobj = SWIG_Py_Void();
13288 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13289 PyObject *resultobj = 0;
13290 std::vector< Hex::Vertex * > *result = 0 ;
13292 if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
13293 result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >();
13294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
13301 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13302 PyObject *resultobj = 0;
13303 std::vector< Hex::Vertex * > *arg1 = 0 ;
13304 int res1 = SWIG_OLDOBJ ;
13305 PyObject * obj0 = 0 ;
13306 std::vector< Hex::Vertex * > *result = 0 ;
13308 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
13310 std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
13311 res1 = swig::asptr(obj0, &ptr);
13312 if (!SWIG_IsOK(res1)) {
13313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
13316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
13320 result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >((std::vector< Hex::Vertex * > const &)*arg1);
13321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
13322 if (SWIG_IsNewObj(res1)) delete arg1;
13325 if (SWIG_IsNewObj(res1)) delete arg1;
13330 SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 PyObject *resultobj = 0;
13332 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13335 PyObject * obj0 = 0 ;
13338 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
13339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13340 if (!SWIG_IsOK(res1)) {
13341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13343 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13344 result = (bool)((std::vector< Hex::Vertex * > const *)arg1)->empty();
13345 resultobj = SWIG_From_bool(static_cast< bool >(result));
13352 SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13353 PyObject *resultobj = 0;
13354 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13357 PyObject * obj0 = 0 ;
13358 std::vector< Hex::Vertex * >::size_type result;
13360 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
13361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13362 if (!SWIG_IsOK(res1)) {
13363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13365 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13366 result = ((std::vector< Hex::Vertex * > const *)arg1)->size();
13367 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13374 SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13375 PyObject *resultobj = 0;
13376 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13377 std::vector< Hex::Vertex * > *arg2 = 0 ;
13382 PyObject * obj0 = 0 ;
13383 PyObject * obj1 = 0 ;
13385 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
13386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13390 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13391 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 );
13392 if (!SWIG_IsOK(res2)) {
13393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
13396 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
13398 arg2 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp2);
13399 (arg1)->swap(*arg2);
13400 resultobj = SWIG_Py_Void();
13407 SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13408 PyObject *resultobj = 0;
13409 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13412 PyObject * obj0 = 0 ;
13413 std::vector< Hex::Vertex * >::iterator result;
13415 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
13416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13420 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13421 result = (arg1)->begin();
13422 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13423 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13430 SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13435 PyObject * obj0 = 0 ;
13436 std::vector< Hex::Vertex * >::iterator result;
13438 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
13439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13443 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13444 result = (arg1)->end();
13445 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13446 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13453 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *resultobj = 0;
13455 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13458 PyObject * obj0 = 0 ;
13459 std::vector< Hex::Vertex * >::reverse_iterator result;
13461 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
13462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13466 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13467 result = (arg1)->rbegin();
13468 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::reverse_iterator & >(result)),
13469 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13476 SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477 PyObject *resultobj = 0;
13478 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13481 PyObject * obj0 = 0 ;
13482 std::vector< Hex::Vertex * >::reverse_iterator result;
13484 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
13485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13486 if (!SWIG_IsOK(res1)) {
13487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13489 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13490 result = (arg1)->rend();
13491 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::reverse_iterator & >(result)),
13492 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13499 SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13500 PyObject *resultobj = 0;
13501 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13504 PyObject * obj0 = 0 ;
13506 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
13507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13508 if (!SWIG_IsOK(res1)) {
13509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13511 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13513 resultobj = SWIG_Py_Void();
13520 SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13521 PyObject *resultobj = 0;
13522 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13525 PyObject * obj0 = 0 ;
13526 SwigValueWrapper< std::allocator< Hex::Vertex * > > result;
13528 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13533 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13534 result = ((std::vector< Hex::Vertex * > const *)arg1)->get_allocator();
13535 resultobj = SWIG_NewPointerObj((new std::vector< Hex::Vertex * >::allocator_type(static_cast< const std::vector< Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Vertex_p_t, SWIG_POINTER_OWN | 0 );
13542 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543 PyObject *resultobj = 0;
13544 std::vector< Hex::Vertex * >::size_type arg1 ;
13547 PyObject * obj0 = 0 ;
13548 std::vector< Hex::Vertex * > *result = 0 ;
13550 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
13551 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13552 if (!SWIG_IsOK(ecode1)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13555 arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
13556 result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1);
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
13564 SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13565 PyObject *resultobj = 0;
13566 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13569 PyObject * obj0 = 0 ;
13571 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13576 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13577 (arg1)->pop_back();
13578 resultobj = SWIG_Py_Void();
13585 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *resultobj = 0;
13587 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13588 std::vector< Hex::Vertex * >::size_type arg2 ;
13593 PyObject * obj0 = 0 ;
13594 PyObject * obj1 = 0 ;
13596 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
13597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13598 if (!SWIG_IsOK(res1)) {
13599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13601 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13602 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13603 if (!SWIG_IsOK(ecode2)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13606 arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13607 (arg1)->resize(arg2);
13608 resultobj = SWIG_Py_Void();
13615 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13616 PyObject *resultobj = 0;
13617 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13618 std::vector< Hex::Vertex * >::iterator arg2 ;
13621 swig::SwigPyIterator *iter2 = 0 ;
13623 PyObject * obj0 = 0 ;
13624 PyObject * obj1 = 0 ;
13625 std::vector< Hex::Vertex * >::iterator result;
13627 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
13628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13629 if (!SWIG_IsOK(res1)) {
13630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13632 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13633 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13634 if (!SWIG_IsOK(res2) || !iter2) {
13635 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13637 swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
13639 arg2 = iter_t->get_current();
13641 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13644 result = std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_0(arg1,arg2);
13645 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13646 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13653 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13654 PyObject *resultobj = 0;
13655 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13656 std::vector< Hex::Vertex * >::iterator arg2 ;
13657 std::vector< Hex::Vertex * >::iterator arg3 ;
13660 swig::SwigPyIterator *iter2 = 0 ;
13662 swig::SwigPyIterator *iter3 = 0 ;
13664 PyObject * obj0 = 0 ;
13665 PyObject * obj1 = 0 ;
13666 PyObject * obj2 = 0 ;
13667 std::vector< Hex::Vertex * >::iterator result;
13669 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13674 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13675 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13676 if (!SWIG_IsOK(res2) || !iter2) {
13677 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13679 swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
13681 arg2 = iter_t->get_current();
13683 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13686 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
13687 if (!SWIG_IsOK(res3) || !iter3) {
13688 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13690 swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter3);
13692 arg3 = iter_t->get_current();
13694 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13697 result = std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
13698 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13699 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13706 SWIGINTERN PyObject *_wrap_VectorVertices_erase(PyObject *self, PyObject *args) {
13708 PyObject *argv[4] = {
13713 if (!PyTuple_Check(args)) SWIG_fail;
13714 argc = args ? PyObject_Length(args) : 0;
13715 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13716 argv[ii] = PyTuple_GET_ITEM(args,ii);
13720 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13721 _v = SWIG_CheckState(res);
13723 swig::SwigPyIterator *iter = 0;
13724 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13725 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13727 return _wrap_VectorVertices_erase__SWIG_0(self, args);
13733 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13734 _v = SWIG_CheckState(res);
13736 swig::SwigPyIterator *iter = 0;
13737 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13738 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13740 swig::SwigPyIterator *iter = 0;
13741 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13742 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13744 return _wrap_VectorVertices_erase__SWIG_1(self, args);
13751 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_erase'.\n"
13752 " Possible C/C++ prototypes are:\n"
13753 " std::vector< Hex::Vertex * >::erase(std::vector< Hex::Vertex * >::iterator)\n"
13754 " std::vector< Hex::Vertex * >::erase(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::iterator)\n");
13759 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13760 PyObject *resultobj = 0;
13761 std::vector< Hex::Vertex * >::size_type arg1 ;
13762 std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13767 PyObject * obj0 = 0 ;
13768 PyObject * obj1 = 0 ;
13769 std::vector< Hex::Vertex * > *result = 0 ;
13771 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
13772 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13773 if (!SWIG_IsOK(ecode1)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13776 arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
13777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13778 if (!SWIG_IsOK(res2)) {
13779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13781 arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13782 result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1,arg2);
13783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
13790 SWIGINTERN PyObject *_wrap_new_VectorVertices(PyObject *self, PyObject *args) {
13792 PyObject *argv[3] = {
13797 if (!PyTuple_Check(args)) SWIG_fail;
13798 argc = args ? PyObject_Length(args) : 0;
13799 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
13800 argv[ii] = PyTuple_GET_ITEM(args,ii);
13803 return _wrap_new_VectorVertices__SWIG_0(self, args);
13808 int res = SWIG_AsVal_size_t(argv[0], NULL);
13809 _v = SWIG_CheckState(res);
13812 return _wrap_new_VectorVertices__SWIG_2(self, args);
13817 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13818 _v = SWIG_CheckState(res);
13820 return _wrap_new_VectorVertices__SWIG_1(self, args);
13826 int res = SWIG_AsVal_size_t(argv[0], NULL);
13827 _v = SWIG_CheckState(res);
13831 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
13832 _v = SWIG_CheckState(res);
13834 return _wrap_new_VectorVertices__SWIG_3(self, args);
13840 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorVertices'.\n"
13841 " Possible C/C++ prototypes are:\n"
13842 " std::vector< Hex::Vertex * >::vector()\n"
13843 " std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * > const &)\n"
13844 " std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * >::size_type)\n"
13845 " std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
13850 SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13851 PyObject *resultobj = 0;
13852 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13853 std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13858 PyObject * obj0 = 0 ;
13859 PyObject * obj1 = 0 ;
13861 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
13862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13863 if (!SWIG_IsOK(res1)) {
13864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13866 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13868 if (!SWIG_IsOK(res2)) {
13869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13871 arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13872 (arg1)->push_back(arg2);
13873 resultobj = SWIG_Py_Void();
13880 SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13881 PyObject *resultobj = 0;
13882 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13885 PyObject * obj0 = 0 ;
13886 std::vector< Hex::Vertex * >::value_type result;
13888 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
13889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13890 if (!SWIG_IsOK(res1)) {
13891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13893 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13894 result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->front();
13895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13902 SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13903 PyObject *resultobj = 0;
13904 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13907 PyObject * obj0 = 0 ;
13908 std::vector< Hex::Vertex * >::value_type result;
13910 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
13911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13912 if (!SWIG_IsOK(res1)) {
13913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13915 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13916 result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->back();
13917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13924 SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13925 PyObject *resultobj = 0;
13926 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13927 std::vector< Hex::Vertex * >::size_type arg2 ;
13928 std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13935 PyObject * obj0 = 0 ;
13936 PyObject * obj1 = 0 ;
13937 PyObject * obj2 = 0 ;
13939 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
13940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13944 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13945 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13946 if (!SWIG_IsOK(ecode2)) {
13947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13949 arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13950 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13951 if (!SWIG_IsOK(res3)) {
13952 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13954 arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13955 (arg1)->assign(arg2,arg3);
13956 resultobj = SWIG_Py_Void();
13963 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964 PyObject *resultobj = 0;
13965 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13966 std::vector< Hex::Vertex * >::size_type arg2 ;
13967 std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13974 PyObject * obj0 = 0 ;
13975 PyObject * obj1 = 0 ;
13976 PyObject * obj2 = 0 ;
13978 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
13979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
13980 if (!SWIG_IsOK(res1)) {
13981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13983 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13984 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13985 if (!SWIG_IsOK(ecode2)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13988 arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13989 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
13990 if (!SWIG_IsOK(res3)) {
13991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13993 arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13994 (arg1)->resize(arg2,arg3);
13995 resultobj = SWIG_Py_Void();
14002 SWIGINTERN PyObject *_wrap_VectorVertices_resize(PyObject *self, PyObject *args) {
14004 PyObject *argv[4] = {
14009 if (!PyTuple_Check(args)) SWIG_fail;
14010 argc = args ? PyObject_Length(args) : 0;
14011 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
14012 argv[ii] = PyTuple_GET_ITEM(args,ii);
14016 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14017 _v = SWIG_CheckState(res);
14020 int res = SWIG_AsVal_size_t(argv[1], NULL);
14021 _v = SWIG_CheckState(res);
14024 return _wrap_VectorVertices_resize__SWIG_0(self, args);
14030 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14031 _v = SWIG_CheckState(res);
14034 int res = SWIG_AsVal_size_t(argv[1], NULL);
14035 _v = SWIG_CheckState(res);
14039 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14040 _v = SWIG_CheckState(res);
14042 return _wrap_VectorVertices_resize__SWIG_1(self, args);
14049 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_resize'.\n"
14050 " Possible C/C++ prototypes are:\n"
14051 " std::vector< Hex::Vertex * >::resize(std::vector< Hex::Vertex * >::size_type)\n"
14052 " std::vector< Hex::Vertex * >::resize(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
14057 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14058 PyObject *resultobj = 0;
14059 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14060 std::vector< Hex::Vertex * >::iterator arg2 ;
14061 std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
14064 swig::SwigPyIterator *iter2 = 0 ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 PyObject * obj2 = 0 ;
14071 std::vector< Hex::Vertex * >::iterator result;
14073 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
14074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
14075 if (!SWIG_IsOK(res1)) {
14076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14078 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14079 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14080 if (!SWIG_IsOK(res2) || !iter2) {
14081 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14083 swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
14085 arg2 = iter_t->get_current();
14087 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14090 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
14091 if (!SWIG_IsOK(res3)) {
14092 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
14094 arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
14095 result = std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
14096 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
14097 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
14104 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105 PyObject *resultobj = 0;
14106 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14107 std::vector< Hex::Vertex * >::iterator arg2 ;
14108 std::vector< Hex::Vertex * >::size_type arg3 ;
14109 std::vector< Hex::Vertex * >::value_type arg4 = (std::vector< Hex::Vertex * >::value_type) 0 ;
14112 swig::SwigPyIterator *iter2 = 0 ;
14118 PyObject * obj0 = 0 ;
14119 PyObject * obj1 = 0 ;
14120 PyObject * obj2 = 0 ;
14121 PyObject * obj3 = 0 ;
14123 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
14125 if (!SWIG_IsOK(res1)) {
14126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14128 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14129 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14130 if (!SWIG_IsOK(res2) || !iter2) {
14131 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14133 swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
14135 arg2 = iter_t->get_current();
14137 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14140 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14141 if (!SWIG_IsOK(ecode3)) {
14142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
14144 arg3 = static_cast< std::vector< Hex::Vertex * >::size_type >(val3);
14145 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
14146 if (!SWIG_IsOK(res4)) {
14147 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
14149 arg4 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp4);
14150 std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
14151 resultobj = SWIG_Py_Void();
14158 SWIGINTERN PyObject *_wrap_VectorVertices_insert(PyObject *self, PyObject *args) {
14160 PyObject *argv[5] = {
14165 if (!PyTuple_Check(args)) SWIG_fail;
14166 argc = args ? PyObject_Length(args) : 0;
14167 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
14168 argv[ii] = PyTuple_GET_ITEM(args,ii);
14172 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14173 _v = SWIG_CheckState(res);
14175 swig::SwigPyIterator *iter = 0;
14176 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14177 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
14180 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14181 _v = SWIG_CheckState(res);
14183 return _wrap_VectorVertices_insert__SWIG_0(self, args);
14190 int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14191 _v = SWIG_CheckState(res);
14193 swig::SwigPyIterator *iter = 0;
14194 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14195 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
14198 int res = SWIG_AsVal_size_t(argv[2], NULL);
14199 _v = SWIG_CheckState(res);
14203 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14204 _v = SWIG_CheckState(res);
14206 return _wrap_VectorVertices_insert__SWIG_1(self, args);
14214 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_insert'.\n"
14215 " Possible C/C++ prototypes are:\n"
14216 " std::vector< Hex::Vertex * >::insert(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::value_type)\n"
14217 " std::vector< Hex::Vertex * >::insert(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
14222 SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14223 PyObject *resultobj = 0;
14224 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14225 std::vector< Hex::Vertex * >::size_type arg2 ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14233 if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
14234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
14235 if (!SWIG_IsOK(res1)) {
14236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14238 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14239 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14240 if (!SWIG_IsOK(ecode2)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
14243 arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
14244 (arg1)->reserve(arg2);
14245 resultobj = SWIG_Py_Void();
14252 SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14253 PyObject *resultobj = 0;
14254 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14257 PyObject * obj0 = 0 ;
14258 std::vector< Hex::Vertex * >::size_type result;
14260 if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
14261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
14262 if (!SWIG_IsOK(res1)) {
14263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
14265 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14266 result = ((std::vector< Hex::Vertex * > const *)arg1)->capacity();
14267 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14274 SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275 PyObject *resultobj = 0;
14276 std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14279 PyObject * obj0 = 0 ;
14281 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
14282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_DISOWN | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14286 arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14288 resultobj = SWIG_Py_Void();
14295 SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14297 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
14298 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_NewClientData(obj));
14299 return SWIG_Py_Void();
14302 SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303 PyObject *resultobj = 0;
14304 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14305 PyObject **arg2 = (PyObject **) 0 ;
14308 PyObject * obj0 = 0 ;
14309 swig::SwigPyIterator *result = 0 ;
14312 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
14313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14314 if (!SWIG_IsOK(res1)) {
14315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14317 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14318 result = (swig::SwigPyIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
14319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
14326 SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14331 PyObject * obj0 = 0 ;
14334 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
14335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14336 if (!SWIG_IsOK(res1)) {
14337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14339 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14340 result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector< Hex::NewShape * > const *)arg1);
14341 resultobj = SWIG_From_bool(static_cast< bool >(result));
14348 SWIGINTERN PyObject *_wrap_VectorShapes___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14349 PyObject *resultobj = 0;
14350 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14353 PyObject * obj0 = 0 ;
14356 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___bool__",&obj0)) SWIG_fail;
14357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14358 if (!SWIG_IsOK(res1)) {
14359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___bool__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14361 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14362 result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____bool__((std::vector< Hex::NewShape * > const *)arg1);
14363 resultobj = SWIG_From_bool(static_cast< bool >(result));
14370 SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14371 PyObject *resultobj = 0;
14372 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14375 PyObject * obj0 = 0 ;
14376 std::vector< Hex::NewShape * >::size_type result;
14378 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
14379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14380 if (!SWIG_IsOK(res1)) {
14381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14383 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14384 result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector< Hex::NewShape * > const *)arg1);
14385 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14392 SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14393 PyObject *resultobj = 0;
14394 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14395 std::vector< Hex::NewShape * >::difference_type arg2 ;
14396 std::vector< Hex::NewShape * >::difference_type arg3 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
14408 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14410 if (!SWIG_IsOK(res1)) {
14411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14413 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14414 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14415 if (!SWIG_IsOK(ecode2)) {
14416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14418 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14419 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14420 if (!SWIG_IsOK(ecode3)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14423 arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14425 result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
14427 catch(std::out_of_range &_e) {
14428 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14430 catch(std::invalid_argument &_e) {
14431 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_OWN | 0 );
14441 SWIGINTERN PyObject *_wrap_VectorShapes___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14442 PyObject *resultobj = 0;
14443 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14444 std::vector< Hex::NewShape * >::difference_type arg2 ;
14445 std::vector< Hex::NewShape * >::difference_type arg3 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 PyObject * obj2 = 0 ;
14456 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14458 if (!SWIG_IsOK(res1)) {
14459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14461 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14462 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14463 if (!SWIG_IsOK(ecode2)) {
14464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14466 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14467 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14468 if (!SWIG_IsOK(ecode3)) {
14469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14471 arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14473 std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
14475 catch(std::out_of_range &_e) {
14476 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14478 catch(std::invalid_argument &_e) {
14479 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14482 resultobj = SWIG_Py_Void();
14489 SWIGINTERN PyObject *_wrap_VectorShapes___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14490 PyObject *resultobj = 0;
14491 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14492 std::vector< Hex::NewShape * >::difference_type arg2 ;
14493 std::vector< Hex::NewShape * >::difference_type arg3 ;
14494 std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg4 = 0 ;
14501 int res4 = SWIG_OLDOBJ ;
14502 PyObject * obj0 = 0 ;
14503 PyObject * obj1 = 0 ;
14504 PyObject * obj2 = 0 ;
14505 PyObject * obj3 = 0 ;
14507 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14509 if (!SWIG_IsOK(res1)) {
14510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14512 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14513 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14514 if (!SWIG_IsOK(ecode2)) {
14515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14517 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14518 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14519 if (!SWIG_IsOK(ecode3)) {
14520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14522 arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14524 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
14525 res4 = swig::asptr(obj3, &ptr);
14526 if (!SWIG_IsOK(res4)) {
14527 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14530 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 &""'");
14535 std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg4);
14537 catch(std::out_of_range &_e) {
14538 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14540 catch(std::invalid_argument &_e) {
14541 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14544 resultobj = SWIG_Py_Void();
14545 if (SWIG_IsNewObj(res4)) delete arg4;
14548 if (SWIG_IsNewObj(res4)) delete arg4;
14553 SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *self, PyObject *args) {
14555 PyObject *argv[5] = {
14560 if (!PyTuple_Check(args)) SWIG_fail;
14561 argc = args ? PyObject_Length(args) : 0;
14562 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
14563 argv[ii] = PyTuple_GET_ITEM(args,ii);
14567 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14568 _v = SWIG_CheckState(res);
14571 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14572 _v = SWIG_CheckState(res);
14576 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
14577 _v = SWIG_CheckState(res);
14580 return _wrap_VectorShapes___setslice____SWIG_0(self, args);
14587 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14588 _v = SWIG_CheckState(res);
14591 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14592 _v = SWIG_CheckState(res);
14596 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
14597 _v = SWIG_CheckState(res);
14600 int res = swig::asptr(argv[3], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14601 _v = SWIG_CheckState(res);
14603 return _wrap_VectorShapes___setslice____SWIG_1(self, args);
14611 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___setslice__'.\n"
14612 " Possible C/C++ prototypes are:\n"
14613 " std::vector< Hex::NewShape * >::__setslice__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::difference_type)\n"
14614 " std::vector< Hex::NewShape * >::__setslice__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n");
14619 SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14620 PyObject *resultobj = 0;
14621 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14622 std::vector< Hex::NewShape * >::difference_type arg2 ;
14623 std::vector< Hex::NewShape * >::difference_type arg3 ;
14630 PyObject * obj0 = 0 ;
14631 PyObject * obj1 = 0 ;
14632 PyObject * obj2 = 0 ;
14634 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14639 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14640 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14641 if (!SWIG_IsOK(ecode2)) {
14642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14644 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14645 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14646 if (!SWIG_IsOK(ecode3)) {
14647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14649 arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14651 std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
14653 catch(std::out_of_range &_e) {
14654 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14656 catch(std::invalid_argument &_e) {
14657 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14660 resultobj = SWIG_Py_Void();
14667 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668 PyObject *resultobj = 0;
14669 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14670 std::vector< Hex::NewShape * >::difference_type arg2 ;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14678 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
14679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14680 if (!SWIG_IsOK(res1)) {
14681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14683 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14684 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14685 if (!SWIG_IsOK(ecode2)) {
14686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14688 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14690 std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(arg1,arg2);
14692 catch(std::out_of_range &_e) {
14693 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14695 catch(std::invalid_argument &_e) {
14696 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14699 resultobj = SWIG_Py_Void();
14706 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707 PyObject *resultobj = 0;
14708 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14709 PySliceObject *arg2 = (PySliceObject *) 0 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
14716 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14721 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14723 if (!PySlice_Check(obj1)) {
14724 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14726 arg2 = (PySliceObject *) obj1;
14729 result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(arg1,arg2);
14731 catch(std::out_of_range &_e) {
14732 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14734 catch(std::invalid_argument &_e) {
14735 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_OWN | 0 );
14745 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746 PyObject *resultobj = 0;
14747 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14748 PySliceObject *arg2 = (PySliceObject *) 0 ;
14749 std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg3 = 0 ;
14752 int res3 = SWIG_OLDOBJ ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14757 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14762 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14764 if (!PySlice_Check(obj1)) {
14765 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14767 arg2 = (PySliceObject *) obj1;
14770 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
14771 res3 = swig::asptr(obj2, &ptr);
14772 if (!SWIG_IsOK(res3)) {
14773 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14781 std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg3);
14783 catch(std::out_of_range &_e) {
14784 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14786 catch(std::invalid_argument &_e) {
14787 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14790 resultobj = SWIG_Py_Void();
14791 if (SWIG_IsNewObj(res3)) delete arg3;
14794 if (SWIG_IsNewObj(res3)) delete arg3;
14799 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14800 PyObject *resultobj = 0;
14801 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14802 PySliceObject *arg2 = (PySliceObject *) 0 ;
14805 PyObject * obj0 = 0 ;
14806 PyObject * obj1 = 0 ;
14808 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___setitem__",&obj0,&obj1)) SWIG_fail;
14809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14810 if (!SWIG_IsOK(res1)) {
14811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14813 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14815 if (!PySlice_Check(obj1)) {
14816 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14818 arg2 = (PySliceObject *) obj1;
14821 std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(arg1,arg2);
14823 catch(std::out_of_range &_e) {
14824 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14826 catch(std::invalid_argument &_e) {
14827 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14830 resultobj = SWIG_Py_Void();
14837 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14838 PyObject *resultobj = 0;
14839 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14840 PySliceObject *arg2 = (PySliceObject *) 0 ;
14843 PyObject * obj0 = 0 ;
14844 PyObject * obj1 = 0 ;
14846 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
14847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14848 if (!SWIG_IsOK(res1)) {
14849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14851 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14853 if (!PySlice_Check(obj1)) {
14854 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14856 arg2 = (PySliceObject *) obj1;
14859 std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(arg1,arg2);
14861 catch(std::out_of_range &_e) {
14862 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14864 catch(std::invalid_argument &_e) {
14865 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14868 resultobj = SWIG_Py_Void();
14875 SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *self, PyObject *args) {
14877 PyObject *argv[3] = {
14882 if (!PyTuple_Check(args)) SWIG_fail;
14883 argc = args ? PyObject_Length(args) : 0;
14884 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
14885 argv[ii] = PyTuple_GET_ITEM(args,ii);
14889 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14890 _v = SWIG_CheckState(res);
14893 _v = PySlice_Check(argv[1]);
14896 return _wrap_VectorShapes___delitem____SWIG_1(self, args);
14902 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14903 _v = SWIG_CheckState(res);
14906 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14907 _v = SWIG_CheckState(res);
14910 return _wrap_VectorShapes___delitem____SWIG_0(self, args);
14916 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___delitem__'.\n"
14917 " Possible C/C++ prototypes are:\n"
14918 " std::vector< Hex::NewShape * >::__delitem__(std::vector< Hex::NewShape * >::difference_type)\n"
14919 " std::vector< Hex::NewShape * >::__delitem__(PySliceObject *)\n");
14924 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14925 PyObject *resultobj = 0;
14926 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14927 std::vector< Hex::NewShape * >::difference_type arg2 ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 std::vector< Hex::NewShape * >::value_type result;
14936 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
14937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
14938 if (!SWIG_IsOK(res1)) {
14939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14941 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14942 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14943 if (!SWIG_IsOK(ecode2)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14946 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14948 result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(arg1,arg2);
14950 catch(std::out_of_range &_e) {
14951 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
14961 SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *self, PyObject *args) {
14963 PyObject *argv[3] = {
14968 if (!PyTuple_Check(args)) SWIG_fail;
14969 argc = args ? PyObject_Length(args) : 0;
14970 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
14971 argv[ii] = PyTuple_GET_ITEM(args,ii);
14975 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14976 _v = SWIG_CheckState(res);
14979 _v = PySlice_Check(argv[1]);
14982 return _wrap_VectorShapes___getitem____SWIG_0(self, args);
14988 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14989 _v = SWIG_CheckState(res);
14992 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14993 _v = SWIG_CheckState(res);
14996 return _wrap_VectorShapes___getitem____SWIG_1(self, args);
15002 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___getitem__'.\n"
15003 " Possible C/C++ prototypes are:\n"
15004 " std::vector< Hex::NewShape * >::__getitem__(PySliceObject *)\n"
15005 " std::vector< Hex::NewShape * >::__getitem__(std::vector< Hex::NewShape * >::difference_type)\n");
15010 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15011 PyObject *resultobj = 0;
15012 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15013 std::vector< Hex::NewShape * >::difference_type arg2 ;
15014 std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15021 PyObject * obj0 = 0 ;
15022 PyObject * obj1 = 0 ;
15023 PyObject * obj2 = 0 ;
15025 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
15026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15027 if (!SWIG_IsOK(res1)) {
15028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15030 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15031 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15032 if (!SWIG_IsOK(ecode2)) {
15033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
15035 arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
15036 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15037 if (!SWIG_IsOK(res3)) {
15038 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15040 arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15042 std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
15044 catch(std::out_of_range &_e) {
15045 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15048 resultobj = SWIG_Py_Void();
15055 SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *self, PyObject *args) {
15057 PyObject *argv[4] = {
15062 if (!PyTuple_Check(args)) SWIG_fail;
15063 argc = args ? PyObject_Length(args) : 0;
15064 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15065 argv[ii] = PyTuple_GET_ITEM(args,ii);
15069 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15070 _v = SWIG_CheckState(res);
15073 _v = PySlice_Check(argv[1]);
15076 return _wrap_VectorShapes___setitem____SWIG_1(self, args);
15082 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15083 _v = SWIG_CheckState(res);
15086 _v = PySlice_Check(argv[1]);
15089 int res = swig::asptr(argv[2], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15090 _v = SWIG_CheckState(res);
15092 return _wrap_VectorShapes___setitem____SWIG_0(self, args);
15099 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15100 _v = SWIG_CheckState(res);
15103 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
15104 _v = SWIG_CheckState(res);
15108 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15109 _v = SWIG_CheckState(res);
15111 return _wrap_VectorShapes___setitem____SWIG_2(self, args);
15118 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___setitem__'.\n"
15119 " Possible C/C++ prototypes are:\n"
15120 " std::vector< Hex::NewShape * >::__setitem__(PySliceObject *,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n"
15121 " std::vector< Hex::NewShape * >::__setitem__(PySliceObject *)\n"
15122 " std::vector< Hex::NewShape * >::__setitem__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::value_type)\n");
15127 SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15132 PyObject * obj0 = 0 ;
15133 std::vector< Hex::NewShape * >::value_type result;
15135 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
15136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15140 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15142 result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
15144 catch(std::out_of_range &_e) {
15145 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15155 SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15156 PyObject *resultobj = 0;
15157 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15158 std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15166 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
15167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15168 if (!SWIG_IsOK(res1)) {
15169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15171 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15173 if (!SWIG_IsOK(res2)) {
15174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15176 arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15177 std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
15178 resultobj = SWIG_Py_Void();
15185 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15186 PyObject *resultobj = 0;
15187 std::vector< Hex::NewShape * > *result = 0 ;
15189 if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
15190 result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >();
15191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
15198 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 std::vector< Hex::NewShape * > *arg1 = 0 ;
15201 int res1 = SWIG_OLDOBJ ;
15202 PyObject * obj0 = 0 ;
15203 std::vector< Hex::NewShape * > *result = 0 ;
15205 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
15207 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
15208 res1 = swig::asptr(obj0, &ptr);
15209 if (!SWIG_IsOK(res1)) {
15210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
15213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
15217 result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >((std::vector< Hex::NewShape * > const &)*arg1);
15218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
15219 if (SWIG_IsNewObj(res1)) delete arg1;
15222 if (SWIG_IsNewObj(res1)) delete arg1;
15227 SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228 PyObject *resultobj = 0;
15229 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15232 PyObject * obj0 = 0 ;
15235 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
15236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15240 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15241 result = (bool)((std::vector< Hex::NewShape * > const *)arg1)->empty();
15242 resultobj = SWIG_From_bool(static_cast< bool >(result));
15249 SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15250 PyObject *resultobj = 0;
15251 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15254 PyObject * obj0 = 0 ;
15255 std::vector< Hex::NewShape * >::size_type result;
15257 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
15258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15259 if (!SWIG_IsOK(res1)) {
15260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15262 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15263 result = ((std::vector< Hex::NewShape * > const *)arg1)->size();
15264 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15271 SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15274 std::vector< Hex::NewShape * > *arg2 = 0 ;
15279 PyObject * obj0 = 0 ;
15280 PyObject * obj1 = 0 ;
15282 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
15283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15284 if (!SWIG_IsOK(res1)) {
15285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15287 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 );
15289 if (!SWIG_IsOK(res2)) {
15290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
15293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
15295 arg2 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp2);
15296 (arg1)->swap(*arg2);
15297 resultobj = SWIG_Py_Void();
15304 SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15305 PyObject *resultobj = 0;
15306 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15309 PyObject * obj0 = 0 ;
15310 std::vector< Hex::NewShape * >::iterator result;
15312 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
15313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15317 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15318 result = (arg1)->begin();
15319 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15320 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15327 SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15332 PyObject * obj0 = 0 ;
15333 std::vector< Hex::NewShape * >::iterator result;
15335 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
15336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15337 if (!SWIG_IsOK(res1)) {
15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15340 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15341 result = (arg1)->end();
15342 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15343 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15350 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351 PyObject *resultobj = 0;
15352 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15355 PyObject * obj0 = 0 ;
15356 std::vector< Hex::NewShape * >::reverse_iterator result;
15358 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
15359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15360 if (!SWIG_IsOK(res1)) {
15361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15363 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15364 result = (arg1)->rbegin();
15365 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::reverse_iterator & >(result)),
15366 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15373 SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15374 PyObject *resultobj = 0;
15375 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15378 PyObject * obj0 = 0 ;
15379 std::vector< Hex::NewShape * >::reverse_iterator result;
15381 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
15382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15386 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15387 result = (arg1)->rend();
15388 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::reverse_iterator & >(result)),
15389 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15396 SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397 PyObject *resultobj = 0;
15398 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15401 PyObject * obj0 = 0 ;
15403 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
15404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15405 if (!SWIG_IsOK(res1)) {
15406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15408 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15410 resultobj = SWIG_Py_Void();
15417 SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418 PyObject *resultobj = 0;
15419 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15422 PyObject * obj0 = 0 ;
15423 SwigValueWrapper< std::allocator< Hex::NewShape * > > result;
15425 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15430 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15431 result = ((std::vector< Hex::NewShape * > const *)arg1)->get_allocator();
15432 resultobj = SWIG_NewPointerObj((new std::vector< Hex::NewShape * >::allocator_type(static_cast< const std::vector< Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__NewShape_p_t, SWIG_POINTER_OWN | 0 );
15439 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 std::vector< Hex::NewShape * >::size_type arg1 ;
15444 PyObject * obj0 = 0 ;
15445 std::vector< Hex::NewShape * > *result = 0 ;
15447 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
15448 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15449 if (!SWIG_IsOK(ecode1)) {
15450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15452 arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
15453 result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1);
15454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
15461 SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15462 PyObject *resultobj = 0;
15463 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15466 PyObject * obj0 = 0 ;
15468 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
15469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15473 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15474 (arg1)->pop_back();
15475 resultobj = SWIG_Py_Void();
15482 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483 PyObject *resultobj = 0;
15484 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15485 std::vector< Hex::NewShape * >::size_type arg2 ;
15490 PyObject * obj0 = 0 ;
15491 PyObject * obj1 = 0 ;
15493 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
15494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15495 if (!SWIG_IsOK(res1)) {
15496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15498 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15499 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15500 if (!SWIG_IsOK(ecode2)) {
15501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15503 arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15504 (arg1)->resize(arg2);
15505 resultobj = SWIG_Py_Void();
15512 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15513 PyObject *resultobj = 0;
15514 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15515 std::vector< Hex::NewShape * >::iterator arg2 ;
15518 swig::SwigPyIterator *iter2 = 0 ;
15520 PyObject * obj0 = 0 ;
15521 PyObject * obj1 = 0 ;
15522 std::vector< Hex::NewShape * >::iterator result;
15524 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
15525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15526 if (!SWIG_IsOK(res1)) {
15527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15529 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15530 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15531 if (!SWIG_IsOK(res2) || !iter2) {
15532 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15534 swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15536 arg2 = iter_t->get_current();
15538 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15541 result = std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_0(arg1,arg2);
15542 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15543 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15550 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15551 PyObject *resultobj = 0;
15552 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15553 std::vector< Hex::NewShape * >::iterator arg2 ;
15554 std::vector< Hex::NewShape * >::iterator arg3 ;
15557 swig::SwigPyIterator *iter2 = 0 ;
15559 swig::SwigPyIterator *iter3 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 PyObject * obj2 = 0 ;
15564 std::vector< Hex::NewShape * >::iterator result;
15566 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15571 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15572 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15573 if (!SWIG_IsOK(res2) || !iter2) {
15574 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15576 swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15578 arg2 = iter_t->get_current();
15580 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15583 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
15584 if (!SWIG_IsOK(res3) || !iter3) {
15585 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15587 swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter3);
15589 arg3 = iter_t->get_current();
15591 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15594 result = std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
15595 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15596 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15603 SWIGINTERN PyObject *_wrap_VectorShapes_erase(PyObject *self, PyObject *args) {
15605 PyObject *argv[4] = {
15610 if (!PyTuple_Check(args)) SWIG_fail;
15611 argc = args ? PyObject_Length(args) : 0;
15612 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15613 argv[ii] = PyTuple_GET_ITEM(args,ii);
15617 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15618 _v = SWIG_CheckState(res);
15620 swig::SwigPyIterator *iter = 0;
15621 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15622 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15624 return _wrap_VectorShapes_erase__SWIG_0(self, args);
15630 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15631 _v = SWIG_CheckState(res);
15633 swig::SwigPyIterator *iter = 0;
15634 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15635 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15637 swig::SwigPyIterator *iter = 0;
15638 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15639 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15641 return _wrap_VectorShapes_erase__SWIG_1(self, args);
15648 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_erase'.\n"
15649 " Possible C/C++ prototypes are:\n"
15650 " std::vector< Hex::NewShape * >::erase(std::vector< Hex::NewShape * >::iterator)\n"
15651 " std::vector< Hex::NewShape * >::erase(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::iterator)\n");
15656 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 std::vector< Hex::NewShape * >::size_type arg1 ;
15659 std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15664 PyObject * obj0 = 0 ;
15665 PyObject * obj1 = 0 ;
15666 std::vector< Hex::NewShape * > *result = 0 ;
15668 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
15669 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15670 if (!SWIG_IsOK(ecode1)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15673 arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
15674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15675 if (!SWIG_IsOK(res2)) {
15676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15678 arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15679 result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1,arg2);
15680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
15687 SWIGINTERN PyObject *_wrap_new_VectorShapes(PyObject *self, PyObject *args) {
15689 PyObject *argv[3] = {
15694 if (!PyTuple_Check(args)) SWIG_fail;
15695 argc = args ? PyObject_Length(args) : 0;
15696 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
15697 argv[ii] = PyTuple_GET_ITEM(args,ii);
15700 return _wrap_new_VectorShapes__SWIG_0(self, args);
15705 int res = SWIG_AsVal_size_t(argv[0], NULL);
15706 _v = SWIG_CheckState(res);
15709 return _wrap_new_VectorShapes__SWIG_2(self, args);
15714 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15715 _v = SWIG_CheckState(res);
15717 return _wrap_new_VectorShapes__SWIG_1(self, args);
15723 int res = SWIG_AsVal_size_t(argv[0], NULL);
15724 _v = SWIG_CheckState(res);
15728 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15729 _v = SWIG_CheckState(res);
15731 return _wrap_new_VectorShapes__SWIG_3(self, args);
15737 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorShapes'.\n"
15738 " Possible C/C++ prototypes are:\n"
15739 " std::vector< Hex::NewShape * >::vector()\n"
15740 " std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * > const &)\n"
15741 " std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * >::size_type)\n"
15742 " std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
15747 SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15748 PyObject *resultobj = 0;
15749 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15750 std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15755 PyObject * obj0 = 0 ;
15756 PyObject * obj1 = 0 ;
15758 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
15759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15760 if (!SWIG_IsOK(res1)) {
15761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15763 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15764 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15765 if (!SWIG_IsOK(res2)) {
15766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15768 arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15769 (arg1)->push_back(arg2);
15770 resultobj = SWIG_Py_Void();
15777 SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778 PyObject *resultobj = 0;
15779 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15782 PyObject * obj0 = 0 ;
15783 std::vector< Hex::NewShape * >::value_type result;
15785 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
15786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15790 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15791 result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->front();
15792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15799 SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15800 PyObject *resultobj = 0;
15801 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15804 PyObject * obj0 = 0 ;
15805 std::vector< Hex::NewShape * >::value_type result;
15807 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
15808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15809 if (!SWIG_IsOK(res1)) {
15810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15812 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15813 result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->back();
15814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15821 SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15824 std::vector< Hex::NewShape * >::size_type arg2 ;
15825 std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15832 PyObject * obj0 = 0 ;
15833 PyObject * obj1 = 0 ;
15834 PyObject * obj2 = 0 ;
15836 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
15837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15838 if (!SWIG_IsOK(res1)) {
15839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15841 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15842 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15843 if (!SWIG_IsOK(ecode2)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15846 arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15847 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15848 if (!SWIG_IsOK(res3)) {
15849 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15851 arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15852 (arg1)->assign(arg2,arg3);
15853 resultobj = SWIG_Py_Void();
15860 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15861 PyObject *resultobj = 0;
15862 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15863 std::vector< Hex::NewShape * >::size_type arg2 ;
15864 std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15871 PyObject * obj0 = 0 ;
15872 PyObject * obj1 = 0 ;
15873 PyObject * obj2 = 0 ;
15875 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
15876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15877 if (!SWIG_IsOK(res1)) {
15878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15880 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15881 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15882 if (!SWIG_IsOK(ecode2)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15885 arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15886 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15887 if (!SWIG_IsOK(res3)) {
15888 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15890 arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15891 (arg1)->resize(arg2,arg3);
15892 resultobj = SWIG_Py_Void();
15899 SWIGINTERN PyObject *_wrap_VectorShapes_resize(PyObject *self, PyObject *args) {
15901 PyObject *argv[4] = {
15906 if (!PyTuple_Check(args)) SWIG_fail;
15907 argc = args ? PyObject_Length(args) : 0;
15908 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15909 argv[ii] = PyTuple_GET_ITEM(args,ii);
15913 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15914 _v = SWIG_CheckState(res);
15917 int res = SWIG_AsVal_size_t(argv[1], NULL);
15918 _v = SWIG_CheckState(res);
15921 return _wrap_VectorShapes_resize__SWIG_0(self, args);
15927 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15928 _v = SWIG_CheckState(res);
15931 int res = SWIG_AsVal_size_t(argv[1], NULL);
15932 _v = SWIG_CheckState(res);
15936 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15937 _v = SWIG_CheckState(res);
15939 return _wrap_VectorShapes_resize__SWIG_1(self, args);
15946 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_resize'.\n"
15947 " Possible C/C++ prototypes are:\n"
15948 " std::vector< Hex::NewShape * >::resize(std::vector< Hex::NewShape * >::size_type)\n"
15949 " std::vector< Hex::NewShape * >::resize(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
15954 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15955 PyObject *resultobj = 0;
15956 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15957 std::vector< Hex::NewShape * >::iterator arg2 ;
15958 std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15961 swig::SwigPyIterator *iter2 = 0 ;
15965 PyObject * obj0 = 0 ;
15966 PyObject * obj1 = 0 ;
15967 PyObject * obj2 = 0 ;
15968 std::vector< Hex::NewShape * >::iterator result;
15970 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
15971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15975 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15976 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15977 if (!SWIG_IsOK(res2) || !iter2) {
15978 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15980 swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15982 arg2 = iter_t->get_current();
15984 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15987 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
15988 if (!SWIG_IsOK(res3)) {
15989 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15991 arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15992 result = std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
15993 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15994 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
16001 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16002 PyObject *resultobj = 0;
16003 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16004 std::vector< Hex::NewShape * >::iterator arg2 ;
16005 std::vector< Hex::NewShape * >::size_type arg3 ;
16006 std::vector< Hex::NewShape * >::value_type arg4 = (std::vector< Hex::NewShape * >::value_type) 0 ;
16009 swig::SwigPyIterator *iter2 = 0 ;
16015 PyObject * obj0 = 0 ;
16016 PyObject * obj1 = 0 ;
16017 PyObject * obj2 = 0 ;
16018 PyObject * obj3 = 0 ;
16020 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
16022 if (!SWIG_IsOK(res1)) {
16023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16025 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16026 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
16027 if (!SWIG_IsOK(res2) || !iter2) {
16028 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
16030 swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
16032 arg2 = iter_t->get_current();
16034 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
16037 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16038 if (!SWIG_IsOK(ecode3)) {
16039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
16041 arg3 = static_cast< std::vector< Hex::NewShape * >::size_type >(val3);
16042 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
16043 if (!SWIG_IsOK(res4)) {
16044 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
16046 arg4 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp4);
16047 std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
16048 resultobj = SWIG_Py_Void();
16055 SWIGINTERN PyObject *_wrap_VectorShapes_insert(PyObject *self, PyObject *args) {
16057 PyObject *argv[5] = {
16062 if (!PyTuple_Check(args)) SWIG_fail;
16063 argc = args ? PyObject_Length(args) : 0;
16064 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
16065 argv[ii] = PyTuple_GET_ITEM(args,ii);
16069 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
16070 _v = SWIG_CheckState(res);
16072 swig::SwigPyIterator *iter = 0;
16073 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
16074 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
16077 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
16078 _v = SWIG_CheckState(res);
16080 return _wrap_VectorShapes_insert__SWIG_0(self, args);
16087 int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
16088 _v = SWIG_CheckState(res);
16090 swig::SwigPyIterator *iter = 0;
16091 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
16092 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
16095 int res = SWIG_AsVal_size_t(argv[2], NULL);
16096 _v = SWIG_CheckState(res);
16100 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
16101 _v = SWIG_CheckState(res);
16103 return _wrap_VectorShapes_insert__SWIG_1(self, args);
16111 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_insert'.\n"
16112 " Possible C/C++ prototypes are:\n"
16113 " std::vector< Hex::NewShape * >::insert(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::value_type)\n"
16114 " std::vector< Hex::NewShape * >::insert(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
16119 SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16120 PyObject *resultobj = 0;
16121 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16122 std::vector< Hex::NewShape * >::size_type arg2 ;
16127 PyObject * obj0 = 0 ;
16128 PyObject * obj1 = 0 ;
16130 if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16135 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16136 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16137 if (!SWIG_IsOK(ecode2)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
16140 arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
16141 (arg1)->reserve(arg2);
16142 resultobj = SWIG_Py_Void();
16149 SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16150 PyObject *resultobj = 0;
16151 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16154 PyObject * obj0 = 0 ;
16155 std::vector< Hex::NewShape * >::size_type result;
16157 if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
16158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
16162 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16163 result = ((std::vector< Hex::NewShape * > const *)arg1)->capacity();
16164 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16171 SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16172 PyObject *resultobj = 0;
16173 std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16176 PyObject * obj0 = 0 ;
16178 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_DISOWN | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16183 arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16185 resultobj = SWIG_Py_Void();
16192 SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16194 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
16195 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_NewClientData(obj));
16196 return SWIG_Py_Void();
16199 SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16200 PyObject *resultobj = 0;
16201 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16202 PyObject **arg2 = (PyObject **) 0 ;
16205 PyObject * obj0 = 0 ;
16206 swig::SwigPyIterator *result = 0 ;
16209 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
16210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16211 if (!SWIG_IsOK(res1)) {
16212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
16214 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16215 result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
16216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
16223 SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16224 PyObject *resultobj = 0;
16225 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16228 PyObject * obj0 = 0 ;
16231 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
16232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16233 if (!SWIG_IsOK(res1)) {
16234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16236 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16237 result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
16238 resultobj = SWIG_From_bool(static_cast< bool >(result));
16245 SWIGINTERN PyObject *_wrap_VectorReal___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16246 PyObject *resultobj = 0;
16247 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16250 PyObject * obj0 = 0 ;
16253 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___bool__",&obj0)) SWIG_fail;
16254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16258 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16259 result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
16260 resultobj = SWIG_From_bool(static_cast< bool >(result));
16267 SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16268 PyObject *resultobj = 0;
16269 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16272 PyObject * obj0 = 0 ;
16273 std::vector< double >::size_type result;
16275 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
16276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16277 if (!SWIG_IsOK(res1)) {
16278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16280 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16281 result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
16282 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16289 SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290 PyObject *resultobj = 0;
16291 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16292 std::vector< double >::difference_type arg2 ;
16293 std::vector< double >::difference_type arg3 ;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 PyObject * obj2 = 0 ;
16303 std::vector< double,std::allocator< double > > *result = 0 ;
16305 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16307 if (!SWIG_IsOK(res1)) {
16308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16310 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16311 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16312 if (!SWIG_IsOK(ecode2)) {
16313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16315 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16316 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16317 if (!SWIG_IsOK(ecode3)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16320 arg3 = static_cast< std::vector< double >::difference_type >(val3);
16322 result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
16324 catch(std::out_of_range &_e) {
16325 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16327 catch(std::invalid_argument &_e) {
16328 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
16338 SWIGINTERN PyObject *_wrap_VectorReal___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16339 PyObject *resultobj = 0;
16340 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16341 std::vector< double >::difference_type arg2 ;
16342 std::vector< double >::difference_type arg3 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 PyObject * obj2 = 0 ;
16353 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16358 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16359 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16360 if (!SWIG_IsOK(ecode2)) {
16361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16363 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16364 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16365 if (!SWIG_IsOK(ecode3)) {
16366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16368 arg3 = static_cast< std::vector< double >::difference_type >(val3);
16370 std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
16372 catch(std::out_of_range &_e) {
16373 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16375 catch(std::invalid_argument &_e) {
16376 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16379 resultobj = SWIG_Py_Void();
16386 SWIGINTERN PyObject *_wrap_VectorReal___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16387 PyObject *resultobj = 0;
16388 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16389 std::vector< double >::difference_type arg2 ;
16390 std::vector< double >::difference_type arg3 ;
16391 std::vector< double,std::allocator< double > > *arg4 = 0 ;
16398 int res4 = SWIG_OLDOBJ ;
16399 PyObject * obj0 = 0 ;
16400 PyObject * obj1 = 0 ;
16401 PyObject * obj2 = 0 ;
16402 PyObject * obj3 = 0 ;
16404 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16409 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16410 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16411 if (!SWIG_IsOK(ecode2)) {
16412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16414 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16415 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16416 if (!SWIG_IsOK(ecode3)) {
16417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16419 arg3 = static_cast< std::vector< double >::difference_type >(val3);
16421 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
16422 res4 = swig::asptr(obj3, &ptr);
16423 if (!SWIG_IsOK(res4)) {
16424 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16432 std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
16434 catch(std::out_of_range &_e) {
16435 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16437 catch(std::invalid_argument &_e) {
16438 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16441 resultobj = SWIG_Py_Void();
16442 if (SWIG_IsNewObj(res4)) delete arg4;
16445 if (SWIG_IsNewObj(res4)) delete arg4;
16450 SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *self, PyObject *args) {
16452 PyObject *argv[5] = {
16457 if (!PyTuple_Check(args)) SWIG_fail;
16458 argc = args ? PyObject_Length(args) : 0;
16459 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
16460 argv[ii] = PyTuple_GET_ITEM(args,ii);
16464 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16465 _v = SWIG_CheckState(res);
16468 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16469 _v = SWIG_CheckState(res);
16473 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
16474 _v = SWIG_CheckState(res);
16477 return _wrap_VectorReal___setslice____SWIG_0(self, args);
16484 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16485 _v = SWIG_CheckState(res);
16488 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16489 _v = SWIG_CheckState(res);
16493 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
16494 _v = SWIG_CheckState(res);
16497 int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
16498 _v = SWIG_CheckState(res);
16500 return _wrap_VectorReal___setslice____SWIG_1(self, args);
16508 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___setslice__'.\n"
16509 " Possible C/C++ prototypes are:\n"
16510 " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
16511 " std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
16516 SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16517 PyObject *resultobj = 0;
16518 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16519 std::vector< double >::difference_type arg2 ;
16520 std::vector< double >::difference_type arg3 ;
16527 PyObject * obj0 = 0 ;
16528 PyObject * obj1 = 0 ;
16529 PyObject * obj2 = 0 ;
16531 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16533 if (!SWIG_IsOK(res1)) {
16534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16536 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16537 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16538 if (!SWIG_IsOK(ecode2)) {
16539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16541 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16542 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16543 if (!SWIG_IsOK(ecode3)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16546 arg3 = static_cast< std::vector< double >::difference_type >(val3);
16548 std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
16550 catch(std::out_of_range &_e) {
16551 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16553 catch(std::invalid_argument &_e) {
16554 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16557 resultobj = SWIG_Py_Void();
16564 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16565 PyObject *resultobj = 0;
16566 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16567 std::vector< double >::difference_type arg2 ;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16575 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
16576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16577 if (!SWIG_IsOK(res1)) {
16578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16580 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16581 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16582 if (!SWIG_IsOK(ecode2)) {
16583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16585 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16587 std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
16589 catch(std::out_of_range &_e) {
16590 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16592 catch(std::invalid_argument &_e) {
16593 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16596 resultobj = SWIG_Py_Void();
16603 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16604 PyObject *resultobj = 0;
16605 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16606 PySliceObject *arg2 = (PySliceObject *) 0 ;
16609 PyObject * obj0 = 0 ;
16610 PyObject * obj1 = 0 ;
16611 std::vector< double,std::allocator< double > > *result = 0 ;
16613 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
16614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16618 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16620 if (!PySlice_Check(obj1)) {
16621 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16623 arg2 = (PySliceObject *) obj1;
16626 result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
16628 catch(std::out_of_range &_e) {
16629 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16631 catch(std::invalid_argument &_e) {
16632 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
16642 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16643 PyObject *resultobj = 0;
16644 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16645 PySliceObject *arg2 = (PySliceObject *) 0 ;
16646 std::vector< double,std::allocator< double > > *arg3 = 0 ;
16649 int res3 = SWIG_OLDOBJ ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 PyObject * obj2 = 0 ;
16654 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16659 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16661 if (!PySlice_Check(obj1)) {
16662 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16664 arg2 = (PySliceObject *) obj1;
16667 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
16668 res3 = swig::asptr(obj2, &ptr);
16669 if (!SWIG_IsOK(res3)) {
16670 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16678 std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
16680 catch(std::out_of_range &_e) {
16681 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16683 catch(std::invalid_argument &_e) {
16684 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16687 resultobj = SWIG_Py_Void();
16688 if (SWIG_IsNewObj(res3)) delete arg3;
16691 if (SWIG_IsNewObj(res3)) delete arg3;
16696 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697 PyObject *resultobj = 0;
16698 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16699 PySliceObject *arg2 = (PySliceObject *) 0 ;
16702 PyObject * obj0 = 0 ;
16703 PyObject * obj1 = 0 ;
16705 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___setitem__",&obj0,&obj1)) SWIG_fail;
16706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16707 if (!SWIG_IsOK(res1)) {
16708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16710 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16712 if (!PySlice_Check(obj1)) {
16713 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16715 arg2 = (PySliceObject *) obj1;
16718 std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
16720 catch(std::out_of_range &_e) {
16721 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16723 catch(std::invalid_argument &_e) {
16724 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16727 resultobj = SWIG_Py_Void();
16734 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16735 PyObject *resultobj = 0;
16736 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16737 PySliceObject *arg2 = (PySliceObject *) 0 ;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16743 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
16744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16745 if (!SWIG_IsOK(res1)) {
16746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16748 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16750 if (!PySlice_Check(obj1)) {
16751 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16753 arg2 = (PySliceObject *) obj1;
16756 std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
16758 catch(std::out_of_range &_e) {
16759 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16761 catch(std::invalid_argument &_e) {
16762 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16765 resultobj = SWIG_Py_Void();
16772 SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *self, PyObject *args) {
16774 PyObject *argv[3] = {
16779 if (!PyTuple_Check(args)) SWIG_fail;
16780 argc = args ? PyObject_Length(args) : 0;
16781 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
16782 argv[ii] = PyTuple_GET_ITEM(args,ii);
16786 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16787 _v = SWIG_CheckState(res);
16790 _v = PySlice_Check(argv[1]);
16793 return _wrap_VectorReal___delitem____SWIG_1(self, args);
16799 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16800 _v = SWIG_CheckState(res);
16803 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16804 _v = SWIG_CheckState(res);
16807 return _wrap_VectorReal___delitem____SWIG_0(self, args);
16813 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___delitem__'.\n"
16814 " Possible C/C++ prototypes are:\n"
16815 " std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
16816 " std::vector< double >::__delitem__(PySliceObject *)\n");
16821 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16822 PyObject *resultobj = 0;
16823 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16824 std::vector< double >::difference_type arg2 ;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 std::vector< double >::value_type *result = 0 ;
16833 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
16834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16838 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16839 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16840 if (!SWIG_IsOK(ecode2)) {
16841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16843 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16845 result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
16847 catch(std::out_of_range &_e) {
16848 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16851 resultobj = SWIG_From_double(static_cast< double >(*result));
16858 SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *self, PyObject *args) {
16860 PyObject *argv[3] = {
16865 if (!PyTuple_Check(args)) SWIG_fail;
16866 argc = args ? PyObject_Length(args) : 0;
16867 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
16868 argv[ii] = PyTuple_GET_ITEM(args,ii);
16872 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16873 _v = SWIG_CheckState(res);
16876 _v = PySlice_Check(argv[1]);
16879 return _wrap_VectorReal___getitem____SWIG_0(self, args);
16885 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16886 _v = SWIG_CheckState(res);
16889 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16890 _v = SWIG_CheckState(res);
16893 return _wrap_VectorReal___getitem____SWIG_1(self, args);
16899 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___getitem__'.\n"
16900 " Possible C/C++ prototypes are:\n"
16901 " std::vector< double >::__getitem__(PySliceObject *)\n"
16902 " std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
16907 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16908 PyObject *resultobj = 0;
16909 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16910 std::vector< double >::difference_type arg2 ;
16911 std::vector< double >::value_type *arg3 = 0 ;
16916 std::vector< double >::value_type temp3 ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 PyObject * obj2 = 0 ;
16923 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
16925 if (!SWIG_IsOK(res1)) {
16926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16928 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16929 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16930 if (!SWIG_IsOK(ecode2)) {
16931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16933 arg2 = static_cast< std::vector< double >::difference_type >(val2);
16934 ecode3 = SWIG_AsVal_double(obj2, &val3);
16935 if (!SWIG_IsOK(ecode3)) {
16936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
16938 temp3 = static_cast< std::vector< double >::value_type >(val3);
16941 std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
16943 catch(std::out_of_range &_e) {
16944 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16947 resultobj = SWIG_Py_Void();
16954 SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *self, PyObject *args) {
16956 PyObject *argv[4] = {
16961 if (!PyTuple_Check(args)) SWIG_fail;
16962 argc = args ? PyObject_Length(args) : 0;
16963 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
16964 argv[ii] = PyTuple_GET_ITEM(args,ii);
16968 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16969 _v = SWIG_CheckState(res);
16972 _v = PySlice_Check(argv[1]);
16975 return _wrap_VectorReal___setitem____SWIG_1(self, args);
16981 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16982 _v = SWIG_CheckState(res);
16985 _v = PySlice_Check(argv[1]);
16988 int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
16989 _v = SWIG_CheckState(res);
16991 return _wrap_VectorReal___setitem____SWIG_0(self, args);
16998 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16999 _v = SWIG_CheckState(res);
17002 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
17003 _v = SWIG_CheckState(res);
17007 int res = SWIG_AsVal_double(argv[2], NULL);
17008 _v = SWIG_CheckState(res);
17011 return _wrap_VectorReal___setitem____SWIG_2(self, args);
17018 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___setitem__'.\n"
17019 " Possible C/C++ prototypes are:\n"
17020 " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
17021 " std::vector< double >::__setitem__(PySliceObject *)\n"
17022 " std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
17027 SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17028 PyObject *resultobj = 0;
17029 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17032 PyObject * obj0 = 0 ;
17033 std::vector< double >::value_type result;
17035 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
17036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
17040 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17042 result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
17044 catch(std::out_of_range &_e) {
17045 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
17048 resultobj = SWIG_From_double(static_cast< double >(result));
17055 SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17056 PyObject *resultobj = 0;
17057 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17058 std::vector< double >::value_type *arg2 = 0 ;
17061 std::vector< double >::value_type temp2 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17067 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
17068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17069 if (!SWIG_IsOK(res1)) {
17070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector< double > *""'");
17072 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17073 ecode2 = SWIG_AsVal_double(obj1, &val2);
17074 if (!SWIG_IsOK(ecode2)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17077 temp2 = static_cast< std::vector< double >::value_type >(val2);
17079 std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
17080 resultobj = SWIG_Py_Void();
17087 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17088 PyObject *resultobj = 0;
17089 std::vector< double > *result = 0 ;
17091 if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
17092 result = (std::vector< double > *)new std::vector< double >();
17093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
17100 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101 PyObject *resultobj = 0;
17102 std::vector< double > *arg1 = 0 ;
17103 int res1 = SWIG_OLDOBJ ;
17104 PyObject * obj0 = 0 ;
17105 std::vector< double > *result = 0 ;
17107 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
17109 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
17110 res1 = swig::asptr(obj0, &ptr);
17111 if (!SWIG_IsOK(res1)) {
17112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
17115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
17119 result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
17120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
17121 if (SWIG_IsNewObj(res1)) delete arg1;
17124 if (SWIG_IsNewObj(res1)) delete arg1;
17129 SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *resultobj = 0;
17131 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17134 PyObject * obj0 = 0 ;
17137 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
17142 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17143 result = (bool)((std::vector< double > const *)arg1)->empty();
17144 resultobj = SWIG_From_bool(static_cast< bool >(result));
17151 SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17152 PyObject *resultobj = 0;
17153 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17156 PyObject * obj0 = 0 ;
17157 std::vector< double >::size_type result;
17159 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
17160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17161 if (!SWIG_IsOK(res1)) {
17162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
17164 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17165 result = ((std::vector< double > const *)arg1)->size();
17166 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17173 SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17174 PyObject *resultobj = 0;
17175 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17176 std::vector< double > *arg2 = 0 ;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17184 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
17185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17186 if (!SWIG_IsOK(res1)) {
17187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
17189 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
17191 if (!SWIG_IsOK(res2)) {
17192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
17195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
17197 arg2 = reinterpret_cast< std::vector< double > * >(argp2);
17198 (arg1)->swap(*arg2);
17199 resultobj = SWIG_Py_Void();
17206 SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17207 PyObject *resultobj = 0;
17208 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17211 PyObject * obj0 = 0 ;
17212 std::vector< double >::iterator result;
17214 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
17215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17216 if (!SWIG_IsOK(res1)) {
17217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector< double > *""'");
17219 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17220 result = (arg1)->begin();
17221 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17222 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17229 SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 PyObject *resultobj = 0;
17231 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17234 PyObject * obj0 = 0 ;
17235 std::vector< double >::iterator result;
17237 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
17238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17239 if (!SWIG_IsOK(res1)) {
17240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector< double > *""'");
17242 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17243 result = (arg1)->end();
17244 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17245 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17252 SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17253 PyObject *resultobj = 0;
17254 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17257 PyObject * obj0 = 0 ;
17258 std::vector< double >::reverse_iterator result;
17260 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
17261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17262 if (!SWIG_IsOK(res1)) {
17263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'");
17265 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17266 result = (arg1)->rbegin();
17267 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
17268 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17275 SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276 PyObject *resultobj = 0;
17277 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17280 PyObject * obj0 = 0 ;
17281 std::vector< double >::reverse_iterator result;
17283 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
17284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17285 if (!SWIG_IsOK(res1)) {
17286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector< double > *""'");
17288 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17289 result = (arg1)->rend();
17290 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
17291 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17298 SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299 PyObject *resultobj = 0;
17300 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17303 PyObject * obj0 = 0 ;
17305 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
17306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17307 if (!SWIG_IsOK(res1)) {
17308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
17310 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17312 resultobj = SWIG_Py_Void();
17319 SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 PyObject *resultobj = 0;
17321 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17324 PyObject * obj0 = 0 ;
17325 SwigValueWrapper< std::allocator< double > > result;
17327 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
17328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17329 if (!SWIG_IsOK(res1)) {
17330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
17332 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17333 result = ((std::vector< double > const *)arg1)->get_allocator();
17334 resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN | 0 );
17341 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342 PyObject *resultobj = 0;
17343 std::vector< double >::size_type arg1 ;
17346 PyObject * obj0 = 0 ;
17347 std::vector< double > *result = 0 ;
17349 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
17350 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
17351 if (!SWIG_IsOK(ecode1)) {
17352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
17354 arg1 = static_cast< std::vector< double >::size_type >(val1);
17355 result = (std::vector< double > *)new std::vector< double >(arg1);
17356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
17363 SWIGINTERN PyObject *_wrap_VectorReal_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17364 PyObject *resultobj = 0;
17365 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17368 PyObject * obj0 = 0 ;
17370 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
17371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17372 if (!SWIG_IsOK(res1)) {
17373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
17375 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17376 (arg1)->pop_back();
17377 resultobj = SWIG_Py_Void();
17384 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *resultobj = 0;
17386 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17387 std::vector< double >::size_type arg2 ;
17392 PyObject * obj0 = 0 ;
17393 PyObject * obj1 = 0 ;
17395 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
17396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17397 if (!SWIG_IsOK(res1)) {
17398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
17400 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17401 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17402 if (!SWIG_IsOK(ecode2)) {
17403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17405 arg2 = static_cast< std::vector< double >::size_type >(val2);
17406 (arg1)->resize(arg2);
17407 resultobj = SWIG_Py_Void();
17414 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 PyObject *resultobj = 0;
17416 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17417 std::vector< double >::iterator arg2 ;
17420 swig::SwigPyIterator *iter2 = 0 ;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 std::vector< double >::iterator result;
17426 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
17431 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17432 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17433 if (!SWIG_IsOK(res2) || !iter2) {
17434 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17436 swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17438 arg2 = iter_t->get_current();
17440 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17443 result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
17444 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17445 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17452 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453 PyObject *resultobj = 0;
17454 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17455 std::vector< double >::iterator arg2 ;
17456 std::vector< double >::iterator arg3 ;
17459 swig::SwigPyIterator *iter2 = 0 ;
17461 swig::SwigPyIterator *iter3 = 0 ;
17463 PyObject * obj0 = 0 ;
17464 PyObject * obj1 = 0 ;
17465 PyObject * obj2 = 0 ;
17466 std::vector< double >::iterator result;
17468 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
17469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17470 if (!SWIG_IsOK(res1)) {
17471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
17473 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17474 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17475 if (!SWIG_IsOK(res2) || !iter2) {
17476 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17478 swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17480 arg2 = iter_t->get_current();
17482 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17485 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
17486 if (!SWIG_IsOK(res3) || !iter3) {
17487 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
17489 swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
17491 arg3 = iter_t->get_current();
17493 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
17496 result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
17497 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17498 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17505 SWIGINTERN PyObject *_wrap_VectorReal_erase(PyObject *self, PyObject *args) {
17507 PyObject *argv[4] = {
17512 if (!PyTuple_Check(args)) SWIG_fail;
17513 argc = args ? PyObject_Length(args) : 0;
17514 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
17515 argv[ii] = PyTuple_GET_ITEM(args,ii);
17519 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17520 _v = SWIG_CheckState(res);
17522 swig::SwigPyIterator *iter = 0;
17523 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17524 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17526 return _wrap_VectorReal_erase__SWIG_0(self, args);
17532 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17533 _v = SWIG_CheckState(res);
17535 swig::SwigPyIterator *iter = 0;
17536 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17537 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17539 swig::SwigPyIterator *iter = 0;
17540 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17541 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17543 return _wrap_VectorReal_erase__SWIG_1(self, args);
17550 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_erase'.\n"
17551 " Possible C/C++ prototypes are:\n"
17552 " std::vector< double >::erase(std::vector< double >::iterator)\n"
17553 " std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
17558 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 PyObject *resultobj = 0;
17560 std::vector< double >::size_type arg1 ;
17561 std::vector< double >::value_type *arg2 = 0 ;
17564 std::vector< double >::value_type temp2 ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 std::vector< double > *result = 0 ;
17571 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
17572 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
17573 if (!SWIG_IsOK(ecode1)) {
17574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
17576 arg1 = static_cast< std::vector< double >::size_type >(val1);
17577 ecode2 = SWIG_AsVal_double(obj1, &val2);
17578 if (!SWIG_IsOK(ecode2)) {
17579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17581 temp2 = static_cast< std::vector< double >::value_type >(val2);
17583 result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
17584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
17591 SWIGINTERN PyObject *_wrap_new_VectorReal(PyObject *self, PyObject *args) {
17593 PyObject *argv[3] = {
17598 if (!PyTuple_Check(args)) SWIG_fail;
17599 argc = args ? PyObject_Length(args) : 0;
17600 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
17601 argv[ii] = PyTuple_GET_ITEM(args,ii);
17604 return _wrap_new_VectorReal__SWIG_0(self, args);
17609 int res = SWIG_AsVal_size_t(argv[0], NULL);
17610 _v = SWIG_CheckState(res);
17613 return _wrap_new_VectorReal__SWIG_2(self, args);
17618 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17619 _v = SWIG_CheckState(res);
17621 return _wrap_new_VectorReal__SWIG_1(self, args);
17627 int res = SWIG_AsVal_size_t(argv[0], NULL);
17628 _v = SWIG_CheckState(res);
17632 int res = SWIG_AsVal_double(argv[1], NULL);
17633 _v = SWIG_CheckState(res);
17636 return _wrap_new_VectorReal__SWIG_3(self, args);
17642 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorReal'.\n"
17643 " Possible C/C++ prototypes are:\n"
17644 " std::vector< double >::vector()\n"
17645 " std::vector< double >::vector(std::vector< double > const &)\n"
17646 " std::vector< double >::vector(std::vector< double >::size_type)\n"
17647 " std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
17652 SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17653 PyObject *resultobj = 0;
17654 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17655 std::vector< double >::value_type *arg2 = 0 ;
17658 std::vector< double >::value_type temp2 ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17664 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
17665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17666 if (!SWIG_IsOK(res1)) {
17667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
17669 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17670 ecode2 = SWIG_AsVal_double(obj1, &val2);
17671 if (!SWIG_IsOK(ecode2)) {
17672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17674 temp2 = static_cast< std::vector< double >::value_type >(val2);
17676 (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
17677 resultobj = SWIG_Py_Void();
17684 SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17685 PyObject *resultobj = 0;
17686 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17689 PyObject * obj0 = 0 ;
17690 std::vector< double >::value_type *result = 0 ;
17692 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
17693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17694 if (!SWIG_IsOK(res1)) {
17695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
17697 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17698 result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
17699 resultobj = SWIG_From_double(static_cast< double >(*result));
17706 SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17711 PyObject * obj0 = 0 ;
17712 std::vector< double >::value_type *result = 0 ;
17714 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
17715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17716 if (!SWIG_IsOK(res1)) {
17717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
17719 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17720 result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
17721 resultobj = SWIG_From_double(static_cast< double >(*result));
17728 SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17729 PyObject *resultobj = 0;
17730 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17731 std::vector< double >::size_type arg2 ;
17732 std::vector< double >::value_type *arg3 = 0 ;
17737 std::vector< double >::value_type temp3 ;
17740 PyObject * obj0 = 0 ;
17741 PyObject * obj1 = 0 ;
17742 PyObject * obj2 = 0 ;
17744 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
17745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17746 if (!SWIG_IsOK(res1)) {
17747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
17749 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17750 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17751 if (!SWIG_IsOK(ecode2)) {
17752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17754 arg2 = static_cast< std::vector< double >::size_type >(val2);
17755 ecode3 = SWIG_AsVal_double(obj2, &val3);
17756 if (!SWIG_IsOK(ecode3)) {
17757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17759 temp3 = static_cast< std::vector< double >::value_type >(val3);
17761 (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
17762 resultobj = SWIG_Py_Void();
17769 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770 PyObject *resultobj = 0;
17771 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17772 std::vector< double >::size_type arg2 ;
17773 std::vector< double >::value_type *arg3 = 0 ;
17778 std::vector< double >::value_type temp3 ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 PyObject * obj2 = 0 ;
17785 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
17786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17787 if (!SWIG_IsOK(res1)) {
17788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
17790 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17791 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17792 if (!SWIG_IsOK(ecode2)) {
17793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17795 arg2 = static_cast< std::vector< double >::size_type >(val2);
17796 ecode3 = SWIG_AsVal_double(obj2, &val3);
17797 if (!SWIG_IsOK(ecode3)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17800 temp3 = static_cast< std::vector< double >::value_type >(val3);
17802 (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
17803 resultobj = SWIG_Py_Void();
17810 SWIGINTERN PyObject *_wrap_VectorReal_resize(PyObject *self, PyObject *args) {
17812 PyObject *argv[4] = {
17817 if (!PyTuple_Check(args)) SWIG_fail;
17818 argc = args ? PyObject_Length(args) : 0;
17819 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
17820 argv[ii] = PyTuple_GET_ITEM(args,ii);
17824 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17825 _v = SWIG_CheckState(res);
17828 int res = SWIG_AsVal_size_t(argv[1], NULL);
17829 _v = SWIG_CheckState(res);
17832 return _wrap_VectorReal_resize__SWIG_0(self, args);
17838 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17839 _v = SWIG_CheckState(res);
17842 int res = SWIG_AsVal_size_t(argv[1], NULL);
17843 _v = SWIG_CheckState(res);
17847 int res = SWIG_AsVal_double(argv[2], NULL);
17848 _v = SWIG_CheckState(res);
17851 return _wrap_VectorReal_resize__SWIG_1(self, args);
17858 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_resize'.\n"
17859 " Possible C/C++ prototypes are:\n"
17860 " std::vector< double >::resize(std::vector< double >::size_type)\n"
17861 " std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
17866 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17867 PyObject *resultobj = 0;
17868 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17869 std::vector< double >::iterator arg2 ;
17870 std::vector< double >::value_type *arg3 = 0 ;
17873 swig::SwigPyIterator *iter2 = 0 ;
17875 std::vector< double >::value_type temp3 ;
17878 PyObject * obj0 = 0 ;
17879 PyObject * obj1 = 0 ;
17880 PyObject * obj2 = 0 ;
17881 std::vector< double >::iterator result;
17883 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
17884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17885 if (!SWIG_IsOK(res1)) {
17886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
17888 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17889 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17890 if (!SWIG_IsOK(res2) || !iter2) {
17891 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17893 swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17895 arg2 = iter_t->get_current();
17897 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17900 ecode3 = SWIG_AsVal_double(obj2, &val3);
17901 if (!SWIG_IsOK(ecode3)) {
17902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17904 temp3 = static_cast< std::vector< double >::value_type >(val3);
17906 result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
17907 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17908 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17915 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17916 PyObject *resultobj = 0;
17917 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17918 std::vector< double >::iterator arg2 ;
17919 std::vector< double >::size_type arg3 ;
17920 std::vector< double >::value_type *arg4 = 0 ;
17923 swig::SwigPyIterator *iter2 = 0 ;
17927 std::vector< double >::value_type temp4 ;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 PyObject * obj2 = 0 ;
17933 PyObject * obj3 = 0 ;
17935 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
17937 if (!SWIG_IsOK(res1)) {
17938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
17940 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17941 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17942 if (!SWIG_IsOK(res2) || !iter2) {
17943 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17945 swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17947 arg2 = iter_t->get_current();
17949 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17952 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17953 if (!SWIG_IsOK(ecode3)) {
17954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
17956 arg3 = static_cast< std::vector< double >::size_type >(val3);
17957 ecode4 = SWIG_AsVal_double(obj3, &val4);
17958 if (!SWIG_IsOK(ecode4)) {
17959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
17961 temp4 = static_cast< std::vector< double >::value_type >(val4);
17963 std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
17964 resultobj = SWIG_Py_Void();
17971 SWIGINTERN PyObject *_wrap_VectorReal_insert(PyObject *self, PyObject *args) {
17973 PyObject *argv[5] = {
17978 if (!PyTuple_Check(args)) SWIG_fail;
17979 argc = args ? PyObject_Length(args) : 0;
17980 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
17981 argv[ii] = PyTuple_GET_ITEM(args,ii);
17985 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17986 _v = SWIG_CheckState(res);
17988 swig::SwigPyIterator *iter = 0;
17989 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17990 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17993 int res = SWIG_AsVal_double(argv[2], NULL);
17994 _v = SWIG_CheckState(res);
17997 return _wrap_VectorReal_insert__SWIG_0(self, args);
18004 int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
18005 _v = SWIG_CheckState(res);
18007 swig::SwigPyIterator *iter = 0;
18008 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
18009 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
18012 int res = SWIG_AsVal_size_t(argv[2], NULL);
18013 _v = SWIG_CheckState(res);
18017 int res = SWIG_AsVal_double(argv[3], NULL);
18018 _v = SWIG_CheckState(res);
18021 return _wrap_VectorReal_insert__SWIG_1(self, args);
18029 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_insert'.\n"
18030 " Possible C/C++ prototypes are:\n"
18031 " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
18032 " std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
18037 SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *resultobj = 0;
18039 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18040 std::vector< double >::size_type arg2 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18048 if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
18049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
18053 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18054 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18055 if (!SWIG_IsOK(ecode2)) {
18056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
18058 arg2 = static_cast< std::vector< double >::size_type >(val2);
18059 (arg1)->reserve(arg2);
18060 resultobj = SWIG_Py_Void();
18067 SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18068 PyObject *resultobj = 0;
18069 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18072 PyObject * obj0 = 0 ;
18073 std::vector< double >::size_type result;
18075 if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
18076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
18077 if (!SWIG_IsOK(res1)) {
18078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
18080 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18081 result = ((std::vector< double > const *)arg1)->capacity();
18082 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18089 SWIGINTERN PyObject *_wrap_delete_VectorReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 PyObject *resultobj = 0;
18091 std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18094 PyObject * obj0 = 0 ;
18096 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
18097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector< double > *""'");
18101 arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18103 resultobj = SWIG_Py_Void();
18110 SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18112 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
18113 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
18114 return SWIG_Py_Void();
18117 SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118 PyObject *resultobj = 0;
18119 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18120 PyObject **arg2 = (PyObject **) 0 ;
18123 PyObject * obj0 = 0 ;
18124 swig::SwigPyIterator *result = 0 ;
18127 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
18128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18129 if (!SWIG_IsOK(res1)) {
18130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
18132 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18133 result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
18134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
18141 SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18142 PyObject *resultobj = 0;
18143 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18146 PyObject * obj0 = 0 ;
18149 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
18150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18151 if (!SWIG_IsOK(res1)) {
18152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18154 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18155 result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
18156 resultobj = SWIG_From_bool(static_cast< bool >(result));
18163 SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18168 PyObject * obj0 = 0 ;
18171 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail;
18172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18176 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18177 result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
18178 resultobj = SWIG_From_bool(static_cast< bool >(result));
18185 SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18186 PyObject *resultobj = 0;
18187 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18190 PyObject * obj0 = 0 ;
18191 std::vector< int >::size_type result;
18193 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
18194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18195 if (!SWIG_IsOK(res1)) {
18196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18198 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18199 result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
18200 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18207 SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208 PyObject *resultobj = 0;
18209 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18210 std::vector< int >::difference_type arg2 ;
18211 std::vector< int >::difference_type arg3 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 PyObject * obj2 = 0 ;
18221 std::vector< int,std::allocator< int > > *result = 0 ;
18223 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18225 if (!SWIG_IsOK(res1)) {
18226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18228 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18229 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18230 if (!SWIG_IsOK(ecode2)) {
18231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18233 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18234 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18235 if (!SWIG_IsOK(ecode3)) {
18236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18238 arg3 = static_cast< std::vector< int >::difference_type >(val3);
18240 result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
18242 catch(std::out_of_range &_e) {
18243 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18245 catch(std::invalid_argument &_e) {
18246 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
18256 SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18257 PyObject *resultobj = 0;
18258 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18259 std::vector< int >::difference_type arg2 ;
18260 std::vector< int >::difference_type arg3 ;
18267 PyObject * obj0 = 0 ;
18268 PyObject * obj1 = 0 ;
18269 PyObject * obj2 = 0 ;
18271 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18273 if (!SWIG_IsOK(res1)) {
18274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18276 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18277 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18278 if (!SWIG_IsOK(ecode2)) {
18279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18281 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18282 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18283 if (!SWIG_IsOK(ecode3)) {
18284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18286 arg3 = static_cast< std::vector< int >::difference_type >(val3);
18288 std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
18290 catch(std::out_of_range &_e) {
18291 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18293 catch(std::invalid_argument &_e) {
18294 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18297 resultobj = SWIG_Py_Void();
18304 SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18305 PyObject *resultobj = 0;
18306 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18307 std::vector< int >::difference_type arg2 ;
18308 std::vector< int >::difference_type arg3 ;
18309 std::vector< int,std::allocator< int > > *arg4 = 0 ;
18316 int res4 = SWIG_OLDOBJ ;
18317 PyObject * obj0 = 0 ;
18318 PyObject * obj1 = 0 ;
18319 PyObject * obj2 = 0 ;
18320 PyObject * obj3 = 0 ;
18322 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18324 if (!SWIG_IsOK(res1)) {
18325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18327 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18328 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18329 if (!SWIG_IsOK(ecode2)) {
18330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18332 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18333 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18334 if (!SWIG_IsOK(ecode3)) {
18335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18337 arg3 = static_cast< std::vector< int >::difference_type >(val3);
18339 std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
18340 res4 = swig::asptr(obj3, &ptr);
18341 if (!SWIG_IsOK(res4)) {
18342 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18350 std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
18352 catch(std::out_of_range &_e) {
18353 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18355 catch(std::invalid_argument &_e) {
18356 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18359 resultobj = SWIG_Py_Void();
18360 if (SWIG_IsNewObj(res4)) delete arg4;
18363 if (SWIG_IsNewObj(res4)) delete arg4;
18368 SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *self, PyObject *args) {
18370 PyObject *argv[5] = {
18375 if (!PyTuple_Check(args)) SWIG_fail;
18376 argc = args ? PyObject_Length(args) : 0;
18377 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
18378 argv[ii] = PyTuple_GET_ITEM(args,ii);
18382 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18383 _v = SWIG_CheckState(res);
18386 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18387 _v = SWIG_CheckState(res);
18391 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
18392 _v = SWIG_CheckState(res);
18395 return _wrap_VectorInt___setslice____SWIG_0(self, args);
18402 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18403 _v = SWIG_CheckState(res);
18406 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18407 _v = SWIG_CheckState(res);
18411 int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
18412 _v = SWIG_CheckState(res);
18415 int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
18416 _v = SWIG_CheckState(res);
18418 return _wrap_VectorInt___setslice____SWIG_1(self, args);
18426 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setslice__'.\n"
18427 " Possible C/C++ prototypes are:\n"
18428 " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
18429 " std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
18434 SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18435 PyObject *resultobj = 0;
18436 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18437 std::vector< int >::difference_type arg2 ;
18438 std::vector< int >::difference_type arg3 ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 PyObject * obj2 = 0 ;
18449 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18451 if (!SWIG_IsOK(res1)) {
18452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18454 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18455 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18456 if (!SWIG_IsOK(ecode2)) {
18457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18459 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18460 ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18461 if (!SWIG_IsOK(ecode3)) {
18462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18464 arg3 = static_cast< std::vector< int >::difference_type >(val3);
18466 std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
18468 catch(std::out_of_range &_e) {
18469 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18471 catch(std::invalid_argument &_e) {
18472 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18475 resultobj = SWIG_Py_Void();
18482 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18485 std::vector< int >::difference_type arg2 ;
18490 PyObject * obj0 = 0 ;
18491 PyObject * obj1 = 0 ;
18493 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
18494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18498 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18499 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18500 if (!SWIG_IsOK(ecode2)) {
18501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18503 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18505 std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
18507 catch(std::out_of_range &_e) {
18508 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18510 catch(std::invalid_argument &_e) {
18511 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18514 resultobj = SWIG_Py_Void();
18521 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18522 PyObject *resultobj = 0;
18523 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18524 PySliceObject *arg2 = (PySliceObject *) 0 ;
18527 PyObject * obj0 = 0 ;
18528 PyObject * obj1 = 0 ;
18529 std::vector< int,std::allocator< int > > *result = 0 ;
18531 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
18532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18533 if (!SWIG_IsOK(res1)) {
18534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18536 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18538 if (!PySlice_Check(obj1)) {
18539 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18541 arg2 = (PySliceObject *) obj1;
18544 result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
18546 catch(std::out_of_range &_e) {
18547 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18549 catch(std::invalid_argument &_e) {
18550 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
18560 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18561 PyObject *resultobj = 0;
18562 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18563 PySliceObject *arg2 = (PySliceObject *) 0 ;
18564 std::vector< int,std::allocator< int > > *arg3 = 0 ;
18567 int res3 = SWIG_OLDOBJ ;
18568 PyObject * obj0 = 0 ;
18569 PyObject * obj1 = 0 ;
18570 PyObject * obj2 = 0 ;
18572 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
18573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18577 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18579 if (!PySlice_Check(obj1)) {
18580 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18582 arg2 = (PySliceObject *) obj1;
18585 std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
18586 res3 = swig::asptr(obj2, &ptr);
18587 if (!SWIG_IsOK(res3)) {
18588 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18596 std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
18598 catch(std::out_of_range &_e) {
18599 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18601 catch(std::invalid_argument &_e) {
18602 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18605 resultobj = SWIG_Py_Void();
18606 if (SWIG_IsNewObj(res3)) delete arg3;
18609 if (SWIG_IsNewObj(res3)) delete arg3;
18614 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18615 PyObject *resultobj = 0;
18616 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18617 PySliceObject *arg2 = (PySliceObject *) 0 ;
18620 PyObject * obj0 = 0 ;
18621 PyObject * obj1 = 0 ;
18623 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___setitem__",&obj0,&obj1)) SWIG_fail;
18624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18625 if (!SWIG_IsOK(res1)) {
18626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18628 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18630 if (!PySlice_Check(obj1)) {
18631 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18633 arg2 = (PySliceObject *) obj1;
18636 std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
18638 catch(std::out_of_range &_e) {
18639 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18641 catch(std::invalid_argument &_e) {
18642 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18645 resultobj = SWIG_Py_Void();
18652 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18653 PyObject *resultobj = 0;
18654 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18655 PySliceObject *arg2 = (PySliceObject *) 0 ;
18658 PyObject * obj0 = 0 ;
18659 PyObject * obj1 = 0 ;
18661 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
18662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18663 if (!SWIG_IsOK(res1)) {
18664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18666 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18668 if (!PySlice_Check(obj1)) {
18669 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18671 arg2 = (PySliceObject *) obj1;
18674 std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
18676 catch(std::out_of_range &_e) {
18677 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18679 catch(std::invalid_argument &_e) {
18680 SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18683 resultobj = SWIG_Py_Void();
18690 SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) {
18692 PyObject *argv[3] = {
18697 if (!PyTuple_Check(args)) SWIG_fail;
18698 argc = args ? PyObject_Length(args) : 0;
18699 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18700 argv[ii] = PyTuple_GET_ITEM(args,ii);
18704 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18705 _v = SWIG_CheckState(res);
18708 _v = PySlice_Check(argv[1]);
18711 return _wrap_VectorInt___delitem____SWIG_1(self, args);
18717 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18718 _v = SWIG_CheckState(res);
18721 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18722 _v = SWIG_CheckState(res);
18725 return _wrap_VectorInt___delitem____SWIG_0(self, args);
18731 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___delitem__'.\n"
18732 " Possible C/C++ prototypes are:\n"
18733 " std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
18734 " std::vector< int >::__delitem__(PySliceObject *)\n");
18739 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18740 PyObject *resultobj = 0;
18741 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18742 std::vector< int >::difference_type arg2 ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 std::vector< int >::value_type *result = 0 ;
18751 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
18752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18753 if (!SWIG_IsOK(res1)) {
18754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18756 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18757 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18758 if (!SWIG_IsOK(ecode2)) {
18759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18761 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18763 result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
18765 catch(std::out_of_range &_e) {
18766 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18769 resultobj = SWIG_From_int(static_cast< int >(*result));
18776 SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) {
18778 PyObject *argv[3] = {
18783 if (!PyTuple_Check(args)) SWIG_fail;
18784 argc = args ? PyObject_Length(args) : 0;
18785 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18786 argv[ii] = PyTuple_GET_ITEM(args,ii);
18790 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18791 _v = SWIG_CheckState(res);
18794 _v = PySlice_Check(argv[1]);
18797 return _wrap_VectorInt___getitem____SWIG_0(self, args);
18803 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18804 _v = SWIG_CheckState(res);
18807 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18808 _v = SWIG_CheckState(res);
18811 return _wrap_VectorInt___getitem____SWIG_1(self, args);
18817 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___getitem__'.\n"
18818 " Possible C/C++ prototypes are:\n"
18819 " std::vector< int >::__getitem__(PySliceObject *)\n"
18820 " std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
18825 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18826 PyObject *resultobj = 0;
18827 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18828 std::vector< int >::difference_type arg2 ;
18829 std::vector< int >::value_type *arg3 = 0 ;
18834 std::vector< int >::value_type temp3 ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 PyObject * obj2 = 0 ;
18841 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
18842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18846 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18847 ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18848 if (!SWIG_IsOK(ecode2)) {
18849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18851 arg2 = static_cast< std::vector< int >::difference_type >(val2);
18852 ecode3 = SWIG_AsVal_int(obj2, &val3);
18853 if (!SWIG_IsOK(ecode3)) {
18854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
18856 temp3 = static_cast< std::vector< int >::value_type >(val3);
18859 std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int const &)*arg3);
18861 catch(std::out_of_range &_e) {
18862 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18865 resultobj = SWIG_Py_Void();
18872 SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) {
18874 PyObject *argv[4] = {
18879 if (!PyTuple_Check(args)) SWIG_fail;
18880 argc = args ? PyObject_Length(args) : 0;
18881 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
18882 argv[ii] = PyTuple_GET_ITEM(args,ii);
18886 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18887 _v = SWIG_CheckState(res);
18890 _v = PySlice_Check(argv[1]);
18893 return _wrap_VectorInt___setitem____SWIG_1(self, args);
18899 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18900 _v = SWIG_CheckState(res);
18903 _v = PySlice_Check(argv[1]);
18906 int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
18907 _v = SWIG_CheckState(res);
18909 return _wrap_VectorInt___setitem____SWIG_0(self, args);
18916 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18917 _v = SWIG_CheckState(res);
18920 int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18921 _v = SWIG_CheckState(res);
18925 int res = SWIG_AsVal_int(argv[2], NULL);
18926 _v = SWIG_CheckState(res);
18929 return _wrap_VectorInt___setitem____SWIG_2(self, args);
18936 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setitem__'.\n"
18937 " Possible C/C++ prototypes are:\n"
18938 " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
18939 " std::vector< int >::__setitem__(PySliceObject *)\n"
18940 " std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
18945 SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18946 PyObject *resultobj = 0;
18947 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18950 PyObject * obj0 = 0 ;
18951 std::vector< int >::value_type result;
18953 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
18954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18955 if (!SWIG_IsOK(res1)) {
18956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
18958 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18960 result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
18962 catch(std::out_of_range &_e) {
18963 SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18966 resultobj = SWIG_From_int(static_cast< int >(result));
18973 SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974 PyObject *resultobj = 0;
18975 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18976 std::vector< int >::value_type *arg2 = 0 ;
18979 std::vector< int >::value_type temp2 ;
18982 PyObject * obj0 = 0 ;
18983 PyObject * obj1 = 0 ;
18985 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
18986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
18987 if (!SWIG_IsOK(res1)) {
18988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'");
18990 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18991 ecode2 = SWIG_AsVal_int(obj1, &val2);
18992 if (!SWIG_IsOK(ecode2)) {
18993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
18995 temp2 = static_cast< std::vector< int >::value_type >(val2);
18997 std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
18998 resultobj = SWIG_Py_Void();
19005 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006 PyObject *resultobj = 0;
19007 std::vector< int > *result = 0 ;
19009 if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
19010 result = (std::vector< int > *)new std::vector< int >();
19011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19018 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19019 PyObject *resultobj = 0;
19020 std::vector< int > *arg1 = 0 ;
19021 int res1 = SWIG_OLDOBJ ;
19022 PyObject * obj0 = 0 ;
19023 std::vector< int > *result = 0 ;
19025 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
19027 std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
19028 res1 = swig::asptr(obj0, &ptr);
19029 if (!SWIG_IsOK(res1)) {
19030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
19033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
19037 result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
19038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19039 if (SWIG_IsNewObj(res1)) delete arg1;
19042 if (SWIG_IsNewObj(res1)) delete arg1;
19047 SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19048 PyObject *resultobj = 0;
19049 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19052 PyObject * obj0 = 0 ;
19055 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
19056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19057 if (!SWIG_IsOK(res1)) {
19058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
19060 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19061 result = (bool)((std::vector< int > const *)arg1)->empty();
19062 resultobj = SWIG_From_bool(static_cast< bool >(result));
19069 SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19070 PyObject *resultobj = 0;
19071 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19074 PyObject * obj0 = 0 ;
19075 std::vector< int >::size_type result;
19077 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
19078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
19082 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19083 result = ((std::vector< int > const *)arg1)->size();
19084 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19091 SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092 PyObject *resultobj = 0;
19093 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19094 std::vector< int > *arg2 = 0 ;
19099 PyObject * obj0 = 0 ;
19100 PyObject * obj1 = 0 ;
19102 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
19103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
19107 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
19109 if (!SWIG_IsOK(res2)) {
19110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19115 arg2 = reinterpret_cast< std::vector< int > * >(argp2);
19116 (arg1)->swap(*arg2);
19117 resultobj = SWIG_Py_Void();
19124 SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19125 PyObject *resultobj = 0;
19126 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19129 PyObject * obj0 = 0 ;
19130 std::vector< int >::iterator result;
19132 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
19133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19134 if (!SWIG_IsOK(res1)) {
19135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > *""'");
19137 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19138 result = (arg1)->begin();
19139 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19140 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19147 SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19148 PyObject *resultobj = 0;
19149 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19152 PyObject * obj0 = 0 ;
19153 std::vector< int >::iterator result;
19155 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
19156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > *""'");
19160 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19161 result = (arg1)->end();
19162 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19163 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19170 SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19171 PyObject *resultobj = 0;
19172 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19175 PyObject * obj0 = 0 ;
19176 std::vector< int >::reverse_iterator result;
19178 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
19179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'");
19183 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19184 result = (arg1)->rbegin();
19185 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
19186 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19193 SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194 PyObject *resultobj = 0;
19195 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19198 PyObject * obj0 = 0 ;
19199 std::vector< int >::reverse_iterator result;
19201 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
19202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19203 if (!SWIG_IsOK(res1)) {
19204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > *""'");
19206 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19207 result = (arg1)->rend();
19208 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
19209 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19216 SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19217 PyObject *resultobj = 0;
19218 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19221 PyObject * obj0 = 0 ;
19223 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
19224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
19228 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19230 resultobj = SWIG_Py_Void();
19237 SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19238 PyObject *resultobj = 0;
19239 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19242 PyObject * obj0 = 0 ;
19243 SwigValueWrapper< std::allocator< int > > result;
19245 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
19246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
19250 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19251 result = ((std::vector< int > const *)arg1)->get_allocator();
19252 resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN | 0 );
19259 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260 PyObject *resultobj = 0;
19261 std::vector< int >::size_type arg1 ;
19264 PyObject * obj0 = 0 ;
19265 std::vector< int > *result = 0 ;
19267 if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
19268 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
19269 if (!SWIG_IsOK(ecode1)) {
19270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
19272 arg1 = static_cast< std::vector< int >::size_type >(val1);
19273 result = (std::vector< int > *)new std::vector< int >(arg1);
19274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19281 SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19282 PyObject *resultobj = 0;
19283 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19286 PyObject * obj0 = 0 ;
19288 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
19289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19290 if (!SWIG_IsOK(res1)) {
19291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
19293 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19294 (arg1)->pop_back();
19295 resultobj = SWIG_Py_Void();
19302 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19303 PyObject *resultobj = 0;
19304 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19305 std::vector< int >::size_type arg2 ;
19310 PyObject * obj0 = 0 ;
19311 PyObject * obj1 = 0 ;
19313 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
19314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19315 if (!SWIG_IsOK(res1)) {
19316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
19318 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19319 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19320 if (!SWIG_IsOK(ecode2)) {
19321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19323 arg2 = static_cast< std::vector< int >::size_type >(val2);
19324 (arg1)->resize(arg2);
19325 resultobj = SWIG_Py_Void();
19332 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 PyObject *resultobj = 0;
19334 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19335 std::vector< int >::iterator arg2 ;
19338 swig::SwigPyIterator *iter2 = 0 ;
19340 PyObject * obj0 = 0 ;
19341 PyObject * obj1 = 0 ;
19342 std::vector< int >::iterator result;
19344 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
19345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
19349 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19351 if (!SWIG_IsOK(res2) || !iter2) {
19352 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19354 swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19356 arg2 = iter_t->get_current();
19358 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19361 result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2);
19362 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19363 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19370 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19371 PyObject *resultobj = 0;
19372 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19373 std::vector< int >::iterator arg2 ;
19374 std::vector< int >::iterator arg3 ;
19377 swig::SwigPyIterator *iter2 = 0 ;
19379 swig::SwigPyIterator *iter3 = 0 ;
19381 PyObject * obj0 = 0 ;
19382 PyObject * obj1 = 0 ;
19383 PyObject * obj2 = 0 ;
19384 std::vector< int >::iterator result;
19386 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
19387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19388 if (!SWIG_IsOK(res1)) {
19389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
19391 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19392 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19393 if (!SWIG_IsOK(res2) || !iter2) {
19394 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19396 swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19398 arg2 = iter_t->get_current();
19400 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19403 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
19404 if (!SWIG_IsOK(res3) || !iter3) {
19405 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
19407 swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
19409 arg3 = iter_t->get_current();
19411 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
19414 result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
19415 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19416 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19423 SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
19425 PyObject *argv[4] = {
19430 if (!PyTuple_Check(args)) SWIG_fail;
19431 argc = args ? PyObject_Length(args) : 0;
19432 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
19433 argv[ii] = PyTuple_GET_ITEM(args,ii);
19437 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19438 _v = SWIG_CheckState(res);
19440 swig::SwigPyIterator *iter = 0;
19441 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19442 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19444 return _wrap_VectorInt_erase__SWIG_0(self, args);
19450 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19451 _v = SWIG_CheckState(res);
19453 swig::SwigPyIterator *iter = 0;
19454 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19455 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19457 swig::SwigPyIterator *iter = 0;
19458 int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19459 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19461 return _wrap_VectorInt_erase__SWIG_1(self, args);
19468 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_erase'.\n"
19469 " Possible C/C++ prototypes are:\n"
19470 " std::vector< int >::erase(std::vector< int >::iterator)\n"
19471 " std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
19476 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 std::vector< int >::size_type arg1 ;
19479 std::vector< int >::value_type *arg2 = 0 ;
19482 std::vector< int >::value_type temp2 ;
19485 PyObject * obj0 = 0 ;
19486 PyObject * obj1 = 0 ;
19487 std::vector< int > *result = 0 ;
19489 if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
19490 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
19491 if (!SWIG_IsOK(ecode1)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
19494 arg1 = static_cast< std::vector< int >::size_type >(val1);
19495 ecode2 = SWIG_AsVal_int(obj1, &val2);
19496 if (!SWIG_IsOK(ecode2)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
19499 temp2 = static_cast< std::vector< int >::value_type >(val2);
19501 result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
19502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
19509 SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
19511 PyObject *argv[3] = {
19516 if (!PyTuple_Check(args)) SWIG_fail;
19517 argc = args ? PyObject_Length(args) : 0;
19518 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19519 argv[ii] = PyTuple_GET_ITEM(args,ii);
19522 return _wrap_new_VectorInt__SWIG_0(self, args);
19527 int res = SWIG_AsVal_size_t(argv[0], NULL);
19528 _v = SWIG_CheckState(res);
19531 return _wrap_new_VectorInt__SWIG_2(self, args);
19536 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19537 _v = SWIG_CheckState(res);
19539 return _wrap_new_VectorInt__SWIG_1(self, args);
19545 int res = SWIG_AsVal_size_t(argv[0], NULL);
19546 _v = SWIG_CheckState(res);
19550 int res = SWIG_AsVal_int(argv[1], NULL);
19551 _v = SWIG_CheckState(res);
19554 return _wrap_new_VectorInt__SWIG_3(self, args);
19560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorInt'.\n"
19561 " Possible C/C++ prototypes are:\n"
19562 " std::vector< int >::vector()\n"
19563 " std::vector< int >::vector(std::vector< int > const &)\n"
19564 " std::vector< int >::vector(std::vector< int >::size_type)\n"
19565 " std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19570 SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19571 PyObject *resultobj = 0;
19572 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19573 std::vector< int >::value_type *arg2 = 0 ;
19576 std::vector< int >::value_type temp2 ;
19579 PyObject * obj0 = 0 ;
19580 PyObject * obj1 = 0 ;
19582 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
19583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19584 if (!SWIG_IsOK(res1)) {
19585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
19587 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19588 ecode2 = SWIG_AsVal_int(obj1, &val2);
19589 if (!SWIG_IsOK(ecode2)) {
19590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
19592 temp2 = static_cast< std::vector< int >::value_type >(val2);
19594 (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
19595 resultobj = SWIG_Py_Void();
19602 SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19603 PyObject *resultobj = 0;
19604 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19607 PyObject * obj0 = 0 ;
19608 std::vector< int >::value_type *result = 0 ;
19610 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
19611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19612 if (!SWIG_IsOK(res1)) {
19613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
19615 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19616 result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
19617 resultobj = SWIG_From_int(static_cast< int >(*result));
19624 SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19625 PyObject *resultobj = 0;
19626 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19629 PyObject * obj0 = 0 ;
19630 std::vector< int >::value_type *result = 0 ;
19632 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
19633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19634 if (!SWIG_IsOK(res1)) {
19635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
19637 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19638 result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
19639 resultobj = SWIG_From_int(static_cast< int >(*result));
19646 SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19647 PyObject *resultobj = 0;
19648 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19649 std::vector< int >::size_type arg2 ;
19650 std::vector< int >::value_type *arg3 = 0 ;
19655 std::vector< int >::value_type temp3 ;
19658 PyObject * obj0 = 0 ;
19659 PyObject * obj1 = 0 ;
19660 PyObject * obj2 = 0 ;
19662 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
19663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19664 if (!SWIG_IsOK(res1)) {
19665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
19667 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19668 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19669 if (!SWIG_IsOK(ecode2)) {
19670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19672 arg2 = static_cast< std::vector< int >::size_type >(val2);
19673 ecode3 = SWIG_AsVal_int(obj2, &val3);
19674 if (!SWIG_IsOK(ecode3)) {
19675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19677 temp3 = static_cast< std::vector< int >::value_type >(val3);
19679 (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
19680 resultobj = SWIG_Py_Void();
19687 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19688 PyObject *resultobj = 0;
19689 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19690 std::vector< int >::size_type arg2 ;
19691 std::vector< int >::value_type *arg3 = 0 ;
19696 std::vector< int >::value_type temp3 ;
19699 PyObject * obj0 = 0 ;
19700 PyObject * obj1 = 0 ;
19701 PyObject * obj2 = 0 ;
19703 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
19704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19705 if (!SWIG_IsOK(res1)) {
19706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
19708 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19710 if (!SWIG_IsOK(ecode2)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19713 arg2 = static_cast< std::vector< int >::size_type >(val2);
19714 ecode3 = SWIG_AsVal_int(obj2, &val3);
19715 if (!SWIG_IsOK(ecode3)) {
19716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19718 temp3 = static_cast< std::vector< int >::value_type >(val3);
19720 (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
19721 resultobj = SWIG_Py_Void();
19728 SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
19730 PyObject *argv[4] = {
19735 if (!PyTuple_Check(args)) SWIG_fail;
19736 argc = args ? PyObject_Length(args) : 0;
19737 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
19738 argv[ii] = PyTuple_GET_ITEM(args,ii);
19742 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19743 _v = SWIG_CheckState(res);
19746 int res = SWIG_AsVal_size_t(argv[1], NULL);
19747 _v = SWIG_CheckState(res);
19750 return _wrap_VectorInt_resize__SWIG_0(self, args);
19756 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19757 _v = SWIG_CheckState(res);
19760 int res = SWIG_AsVal_size_t(argv[1], NULL);
19761 _v = SWIG_CheckState(res);
19765 int res = SWIG_AsVal_int(argv[2], NULL);
19766 _v = SWIG_CheckState(res);
19769 return _wrap_VectorInt_resize__SWIG_1(self, args);
19776 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_resize'.\n"
19777 " Possible C/C++ prototypes are:\n"
19778 " std::vector< int >::resize(std::vector< int >::size_type)\n"
19779 " std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19784 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *resultobj = 0;
19786 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19787 std::vector< int >::iterator arg2 ;
19788 std::vector< int >::value_type *arg3 = 0 ;
19791 swig::SwigPyIterator *iter2 = 0 ;
19793 std::vector< int >::value_type temp3 ;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 PyObject * obj2 = 0 ;
19799 std::vector< int >::iterator result;
19801 if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
19802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19803 if (!SWIG_IsOK(res1)) {
19804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
19806 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19807 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19808 if (!SWIG_IsOK(res2) || !iter2) {
19809 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19811 swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19813 arg2 = iter_t->get_current();
19815 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19818 ecode3 = SWIG_AsVal_int(obj2, &val3);
19819 if (!SWIG_IsOK(ecode3)) {
19820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19822 temp3 = static_cast< std::vector< int >::value_type >(val3);
19824 result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3);
19825 resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19826 swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19833 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19834 PyObject *resultobj = 0;
19835 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19836 std::vector< int >::iterator arg2 ;
19837 std::vector< int >::size_type arg3 ;
19838 std::vector< int >::value_type *arg4 = 0 ;
19841 swig::SwigPyIterator *iter2 = 0 ;
19845 std::vector< int >::value_type temp4 ;
19848 PyObject * obj0 = 0 ;
19849 PyObject * obj1 = 0 ;
19850 PyObject * obj2 = 0 ;
19851 PyObject * obj3 = 0 ;
19853 if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19855 if (!SWIG_IsOK(res1)) {
19856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
19858 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19859 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19860 if (!SWIG_IsOK(res2) || !iter2) {
19861 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19863 swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19865 arg2 = iter_t->get_current();
19867 SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19870 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19871 if (!SWIG_IsOK(ecode3)) {
19872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
19874 arg3 = static_cast< std::vector< int >::size_type >(val3);
19875 ecode4 = SWIG_AsVal_int(obj3, &val4);
19876 if (!SWIG_IsOK(ecode4)) {
19877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
19879 temp4 = static_cast< std::vector< int >::value_type >(val4);
19881 std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4);
19882 resultobj = SWIG_Py_Void();
19889 SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
19891 PyObject *argv[5] = {
19896 if (!PyTuple_Check(args)) SWIG_fail;
19897 argc = args ? PyObject_Length(args) : 0;
19898 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
19899 argv[ii] = PyTuple_GET_ITEM(args,ii);
19903 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19904 _v = SWIG_CheckState(res);
19906 swig::SwigPyIterator *iter = 0;
19907 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19908 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19911 int res = SWIG_AsVal_int(argv[2], NULL);
19912 _v = SWIG_CheckState(res);
19915 return _wrap_VectorInt_insert__SWIG_0(self, args);
19922 int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19923 _v = SWIG_CheckState(res);
19925 swig::SwigPyIterator *iter = 0;
19926 int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19927 _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19930 int res = SWIG_AsVal_size_t(argv[2], NULL);
19931 _v = SWIG_CheckState(res);
19935 int res = SWIG_AsVal_int(argv[3], NULL);
19936 _v = SWIG_CheckState(res);
19939 return _wrap_VectorInt_insert__SWIG_1(self, args);
19947 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_insert'.\n"
19948 " Possible C/C++ prototypes are:\n"
19949 " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
19950 " std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19955 SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19956 PyObject *resultobj = 0;
19957 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19958 std::vector< int >::size_type arg2 ;
19963 PyObject * obj0 = 0 ;
19964 PyObject * obj1 = 0 ;
19966 if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
19967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19968 if (!SWIG_IsOK(res1)) {
19969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
19971 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19972 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19973 if (!SWIG_IsOK(ecode2)) {
19974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19976 arg2 = static_cast< std::vector< int >::size_type >(val2);
19977 (arg1)->reserve(arg2);
19978 resultobj = SWIG_Py_Void();
19985 SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19986 PyObject *resultobj = 0;
19987 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19990 PyObject * obj0 = 0 ;
19991 std::vector< int >::size_type result;
19993 if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
19998 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19999 result = ((std::vector< int > const *)arg1)->capacity();
20000 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20007 SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20008 PyObject *resultobj = 0;
20009 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20012 PyObject * obj0 = 0 ;
20014 if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
20015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 );
20016 if (!SWIG_IsOK(res1)) {
20017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'");
20019 arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20021 resultobj = SWIG_Py_Void();
20028 SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20030 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
20031 SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
20032 return SWIG_Py_Void();
20035 SWIGINTERN int Swig_var_ABR_TYPES_set(PyObject *) {
20036 SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
20041 SWIGINTERN PyObject *Swig_var_ABR_TYPES_get(void) {
20042 PyObject *pyobj = 0;
20044 pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
20049 SWIGINTERN PyObject *_wrap_get_temp_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20050 PyObject *resultobj = 0;
20051 cpchar arg1 = (cpchar) 0 ;
20052 pchar arg2 = (pchar) 0 ;
20059 PyObject * obj0 = 0 ;
20060 PyObject * obj1 = 0 ;
20063 if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
20064 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20065 if (!SWIG_IsOK(res1)) {
20066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_temp_name" "', argument " "1"" of type '" "cpchar""'");
20068 arg1 = reinterpret_cast< cpchar >(buf1);
20069 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20070 if (!SWIG_IsOK(res2)) {
20071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_temp_name" "', argument " "2"" of type '" "pchar""'");
20073 arg2 = reinterpret_cast< pchar >(buf2);
20074 result = (pchar)Hex::get_temp_name((char const *)arg1,arg2);
20075 resultobj = SWIG_FromCharPtr((const char *)result);
20076 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20077 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20080 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20081 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20086 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20087 PyObject *resultobj = 0;
20088 cpchar arg1 = (cpchar) 0 ;
20089 cpchar arg2 = (cpchar) 0 ;
20090 cpchar arg3 = (cpchar) 0 ;
20100 PyObject * obj0 = 0 ;
20101 PyObject * obj1 = 0 ;
20102 PyObject * obj2 = 0 ;
20104 if (!PyArg_ParseTuple(args,(char *)"OOO:fatal_error",&obj0,&obj1,&obj2)) SWIG_fail;
20105 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20106 if (!SWIG_IsOK(res1)) {
20107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20109 arg1 = reinterpret_cast< cpchar >(buf1);
20110 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20111 if (!SWIG_IsOK(res2)) {
20112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
20114 arg2 = reinterpret_cast< cpchar >(buf2);
20115 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
20116 if (!SWIG_IsOK(res3)) {
20117 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fatal_error" "', argument " "3"" of type '" "cpchar""'");
20119 arg3 = reinterpret_cast< cpchar >(buf3);
20120 Hex::fatal_error((char const *)arg1,(char const *)arg2,(char const *)arg3);
20121 resultobj = SWIG_Py_Void();
20122 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20123 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20124 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20127 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20128 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20129 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20134 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20135 PyObject *resultobj = 0;
20136 cpchar arg1 = (cpchar) 0 ;
20137 cpchar arg2 = (cpchar) 0 ;
20144 PyObject * obj0 = 0 ;
20145 PyObject * obj1 = 0 ;
20147 if (!PyArg_ParseTuple(args,(char *)"OO:fatal_error",&obj0,&obj1)) SWIG_fail;
20148 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20152 arg1 = reinterpret_cast< cpchar >(buf1);
20153 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20154 if (!SWIG_IsOK(res2)) {
20155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
20157 arg2 = reinterpret_cast< cpchar >(buf2);
20158 Hex::fatal_error((char const *)arg1,(char const *)arg2);
20159 resultobj = SWIG_Py_Void();
20160 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20161 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20164 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20165 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20170 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20171 PyObject *resultobj = 0;
20172 cpchar arg1 = (cpchar) 0 ;
20176 PyObject * obj0 = 0 ;
20178 if (!PyArg_ParseTuple(args,(char *)"O:fatal_error",&obj0)) SWIG_fail;
20179 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20180 if (!SWIG_IsOK(res1)) {
20181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20183 arg1 = reinterpret_cast< cpchar >(buf1);
20184 Hex::fatal_error((char const *)arg1);
20185 resultobj = SWIG_Py_Void();
20186 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20189 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20194 SWIGINTERN PyObject *_wrap_fatal_error(PyObject *self, PyObject *args) {
20196 PyObject *argv[4] = {
20201 if (!PyTuple_Check(args)) SWIG_fail;
20202 argc = args ? PyObject_Length(args) : 0;
20203 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
20204 argv[ii] = PyTuple_GET_ITEM(args,ii);
20208 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20209 _v = SWIG_CheckState(res);
20211 return _wrap_fatal_error__SWIG_2(self, args);
20216 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20217 _v = SWIG_CheckState(res);
20219 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20220 _v = SWIG_CheckState(res);
20222 return _wrap_fatal_error__SWIG_1(self, args);
20228 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20229 _v = SWIG_CheckState(res);
20231 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20232 _v = SWIG_CheckState(res);
20234 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
20235 _v = SWIG_CheckState(res);
20237 return _wrap_fatal_error__SWIG_0(self, args);
20244 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'fatal_error'.\n"
20245 " Possible C/C++ prototypes are:\n"
20246 " Hex::fatal_error(cpchar,cpchar,cpchar)\n"
20247 " Hex::fatal_error(cpchar,cpchar)\n"
20248 " Hex::fatal_error(cpchar)\n");
20253 SWIGINTERN PyObject *_wrap_prod_scalaire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20254 PyObject *resultobj = 0;
20261 PyObject * obj0 = 0 ;
20262 PyObject * obj1 = 0 ;
20265 if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
20266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20267 if (!SWIG_IsOK(res1)) {
20268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_scalaire" "', argument " "1"" of type '" "double []""'");
20270 arg1 = reinterpret_cast< double * >(argp1);
20271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20272 if (!SWIG_IsOK(res2)) {
20273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_scalaire" "', argument " "2"" of type '" "double []""'");
20275 arg2 = reinterpret_cast< double * >(argp2);
20276 result = (double)Hex::prod_scalaire(arg1,arg2);
20277 resultobj = SWIG_From_double(static_cast< double >(result));
20284 SWIGINTERN PyObject *_wrap_prod_vectoriel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20285 PyObject *resultobj = 0;
20295 PyObject * obj0 = 0 ;
20296 PyObject * obj1 = 0 ;
20297 PyObject * obj2 = 0 ;
20298 double *result = 0 ;
20300 if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
20301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20302 if (!SWIG_IsOK(res1)) {
20303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_vectoriel" "', argument " "1"" of type '" "double []""'");
20305 arg1 = reinterpret_cast< double * >(argp1);
20306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20307 if (!SWIG_IsOK(res2)) {
20308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_vectoriel" "', argument " "2"" of type '" "double []""'");
20310 arg2 = reinterpret_cast< double * >(argp2);
20311 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
20312 if (!SWIG_IsOK(res3)) {
20313 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_vectoriel" "', argument " "3"" of type '" "double []""'");
20315 arg3 = reinterpret_cast< double * >(argp3);
20316 result = (double *)Hex::prod_vectoriel(arg1,arg2,arg3);
20317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
20324 SWIGINTERN PyObject *_wrap_prod_mixte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 PyObject *resultobj = 0;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 PyObject * obj2 = 0 ;
20340 if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
20341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_mixte" "', argument " "1"" of type '" "double []""'");
20345 arg1 = reinterpret_cast< double * >(argp1);
20346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20347 if (!SWIG_IsOK(res2)) {
20348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_mixte" "', argument " "2"" of type '" "double []""'");
20350 arg2 = reinterpret_cast< double * >(argp2);
20351 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
20352 if (!SWIG_IsOK(res3)) {
20353 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_mixte" "', argument " "3"" of type '" "double []""'");
20355 arg3 = reinterpret_cast< double * >(argp3);
20356 result = (double)Hex::prod_mixte(arg1,arg2,arg3);
20357 resultobj = SWIG_From_double(static_cast< double >(result));
20364 SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20365 PyObject *resultobj = 0;
20369 PyObject * obj0 = 0 ;
20372 if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
20373 ecode1 = SWIG_AsVal_double(obj0, &val1);
20374 if (!SWIG_IsOK(ecode1)) {
20375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deg2radians" "', argument " "1"" of type '" "double""'");
20377 arg1 = static_cast< double >(val1);
20378 result = (double)Hex::deg2radians(arg1);
20379 resultobj = SWIG_From_double(static_cast< double >(result));
20386 SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 PyObject *resultobj = 0;
20391 PyObject * obj0 = 0 ;
20394 if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
20395 ecode1 = SWIG_AsVal_double(obj0, &val1);
20396 if (!SWIG_IsOK(ecode1)) {
20397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rad2degres" "', argument " "1"" of type '" "double""'");
20399 arg1 = static_cast< double >(val1);
20400 result = (double)Hex::rad2degres(arg1);
20401 resultobj = SWIG_From_double(static_cast< double >(result));
20408 SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *resultobj = 0;
20413 PyObject * obj0 = 0 ;
20416 if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
20417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20418 if (!SWIG_IsOK(res1)) {
20419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_norme" "', argument " "1"" of type '" "double []""'");
20421 arg1 = reinterpret_cast< double * >(argp1);
20422 result = (double)Hex::calc_norme(arg1);
20423 resultobj = SWIG_From_double(static_cast< double >(result));
20430 SWIGINTERN PyObject *_wrap_calc_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20431 PyObject *resultobj = 0;
20438 PyObject * obj0 = 0 ;
20439 PyObject * obj1 = 0 ;
20442 if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
20443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20444 if (!SWIG_IsOK(res1)) {
20445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_distance" "', argument " "1"" of type '" "double []""'");
20447 arg1 = reinterpret_cast< double * >(argp1);
20448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20449 if (!SWIG_IsOK(res2)) {
20450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_distance" "', argument " "2"" of type '" "double []""'");
20452 arg2 = reinterpret_cast< double * >(argp2);
20453 result = (double)Hex::calc_distance(arg1,arg2);
20454 resultobj = SWIG_From_double(static_cast< double >(result));
20461 SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20469 PyObject * obj0 = 0 ;
20470 PyObject * obj1 = 0 ;
20473 if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
20474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
20478 arg1 = reinterpret_cast< double * >(argp1);
20479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20480 if (!SWIG_IsOK(res2)) {
20481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
20483 arg2 = reinterpret_cast< double * >(argp2);
20484 result = (double)Hex::calc_d2(arg1,arg2);
20485 resultobj = SWIG_From_double(static_cast< double >(result));
20492 SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *resultobj = 0;
20503 PyObject * obj0 = 0 ;
20504 PyObject * obj1 = 0 ;
20505 PyObject * obj2 = 0 ;
20507 if (!PyArg_ParseTuple(args,(char *)"OOO:calc_vecteur",&obj0,&obj1,&obj2)) SWIG_fail;
20508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20509 if (!SWIG_IsOK(res1)) {
20510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_vecteur" "', argument " "1"" of type '" "double []""'");
20512 arg1 = reinterpret_cast< double * >(argp1);
20513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20514 if (!SWIG_IsOK(res2)) {
20515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_vecteur" "', argument " "2"" of type '" "double []""'");
20517 arg2 = reinterpret_cast< double * >(argp2);
20518 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
20519 if (!SWIG_IsOK(res3)) {
20520 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_vecteur" "', argument " "3"" of type '" "double []""'");
20522 arg3 = reinterpret_cast< double * >(argp3);
20523 Hex::calc_vecteur(arg1,arg2,arg3);
20524 resultobj = SWIG_Py_Void();
20531 SWIGINTERN PyObject *_wrap_copy_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20532 PyObject *resultobj = 0;
20539 PyObject * obj0 = 0 ;
20540 PyObject * obj1 = 0 ;
20542 if (!PyArg_ParseTuple(args,(char *)"OO:copy_vecteur",&obj0,&obj1)) SWIG_fail;
20543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20544 if (!SWIG_IsOK(res1)) {
20545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_vecteur" "', argument " "1"" of type '" "double []""'");
20547 arg1 = reinterpret_cast< double * >(argp1);
20548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20549 if (!SWIG_IsOK(res2)) {
20550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy_vecteur" "', argument " "2"" of type '" "double []""'");
20552 arg2 = reinterpret_cast< double * >(argp2);
20553 Hex::copy_vecteur(arg1,arg2);
20554 resultobj = SWIG_Py_Void();
20561 SWIGINTERN PyObject *_wrap_calc_milieu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20562 PyObject *resultobj = 0;
20572 PyObject * obj0 = 0 ;
20573 PyObject * obj1 = 0 ;
20574 PyObject * obj2 = 0 ;
20576 if (!PyArg_ParseTuple(args,(char *)"OOO:calc_milieu",&obj0,&obj1,&obj2)) SWIG_fail;
20577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20578 if (!SWIG_IsOK(res1)) {
20579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_milieu" "', argument " "1"" of type '" "double []""'");
20581 arg1 = reinterpret_cast< double * >(argp1);
20582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20583 if (!SWIG_IsOK(res2)) {
20584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_milieu" "', argument " "2"" of type '" "double []""'");
20586 arg2 = reinterpret_cast< double * >(argp2);
20587 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
20588 if (!SWIG_IsOK(res3)) {
20589 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_milieu" "', argument " "3"" of type '" "double []""'");
20591 arg3 = reinterpret_cast< double * >(argp3);
20592 Hex::calc_milieu(arg1,arg2,arg3);
20593 resultobj = SWIG_Py_Void();
20600 SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20605 PyObject * obj0 = 0 ;
20608 if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
20609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "normer_vecteur" "', argument " "1"" of type '" "double []""'");
20613 arg1 = reinterpret_cast< double * >(argp1);
20614 result = (int)Hex::normer_vecteur(arg1);
20615 resultobj = SWIG_From_int(static_cast< int >(result));
20622 SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20623 PyObject *resultobj = 0;
20627 PyObject * obj0 = 0 ;
20630 if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
20631 ecode1 = SWIG_AsVal_double(obj0, &val1);
20632 if (!SWIG_IsOK(ecode1)) {
20633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "carre" "', argument " "1"" of type '" "double""'");
20635 arg1 = static_cast< double >(val1);
20636 result = (double)Hex::carre(arg1);
20637 resultobj = SWIG_From_double(static_cast< double >(result));
20644 SWIGINTERN PyObject *_wrap_same_coords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *resultobj = 0;
20646 double *arg1 = (double *) 0 ;
20647 double *arg2 = (double *) 0 ;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 PyObject * obj2 = 0 ;
20660 if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
20661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20662 if (!SWIG_IsOK(res1)) {
20663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
20665 arg1 = reinterpret_cast< double * >(argp1);
20666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20667 if (!SWIG_IsOK(res2)) {
20668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
20670 arg2 = reinterpret_cast< double * >(argp2);
20671 ecode3 = SWIG_AsVal_double(obj2, &val3);
20672 if (!SWIG_IsOK(ecode3)) {
20673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "same_coords" "', argument " "3"" of type '" "double""'");
20675 arg3 = static_cast< double >(val3);
20676 result = (bool)Hex::same_coords(arg1,arg2,arg3);
20677 resultobj = SWIG_From_bool(static_cast< bool >(result));
20684 SWIGINTERN PyObject *_wrap_same_coords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685 PyObject *resultobj = 0;
20686 double *arg1 = (double *) 0 ;
20687 double *arg2 = (double *) 0 ;
20692 PyObject * obj0 = 0 ;
20693 PyObject * obj1 = 0 ;
20696 if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
20697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20698 if (!SWIG_IsOK(res1)) {
20699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
20701 arg1 = reinterpret_cast< double * >(argp1);
20702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20703 if (!SWIG_IsOK(res2)) {
20704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
20706 arg2 = reinterpret_cast< double * >(argp2);
20707 result = (bool)Hex::same_coords(arg1,arg2);
20708 resultobj = SWIG_From_bool(static_cast< bool >(result));
20715 SWIGINTERN PyObject *_wrap_same_coords(PyObject *self, PyObject *args) {
20717 PyObject *argv[4] = {
20722 if (!PyTuple_Check(args)) SWIG_fail;
20723 argc = args ? PyObject_Length(args) : 0;
20724 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
20725 argv[ii] = PyTuple_GET_ITEM(args,ii);
20730 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20731 _v = SWIG_CheckState(res);
20734 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20735 _v = SWIG_CheckState(res);
20737 return _wrap_same_coords__SWIG_1(self, args);
20744 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20745 _v = SWIG_CheckState(res);
20748 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20749 _v = SWIG_CheckState(res);
20752 int res = SWIG_AsVal_double(argv[2], NULL);
20753 _v = SWIG_CheckState(res);
20756 return _wrap_same_coords__SWIG_0(self, args);
20763 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'same_coords'.\n"
20764 " Possible C/C++ prototypes are:\n"
20765 " Hex::same_coords(double *,double *,double)\n"
20766 " Hex::same_coords(double *,double *)\n");
20771 SWIGINTERN PyObject *_wrap_requals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20772 PyObject *resultobj = 0;
20779 PyObject * obj0 = 0 ;
20780 PyObject * obj1 = 0 ;
20783 if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
20784 ecode1 = SWIG_AsVal_double(obj0, &val1);
20785 if (!SWIG_IsOK(ecode1)) {
20786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "requals" "', argument " "1"" of type '" "double""'");
20788 arg1 = static_cast< double >(val1);
20789 ecode2 = SWIG_AsVal_double(obj1, &val2);
20790 if (!SWIG_IsOK(ecode2)) {
20791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "requals" "', argument " "2"" of type '" "double""'");
20793 arg2 = static_cast< double >(val2);
20794 result = (bool)Hex::requals(arg1,arg2);
20795 resultobj = SWIG_From_bool(static_cast< bool >(result));
20802 SWIGINTERN PyObject *_wrap_requals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20803 PyObject *resultobj = 0;
20804 double *arg1 = (double *) 0 ;
20805 double *arg2 = (double *) 0 ;
20810 PyObject * obj0 = 0 ;
20811 PyObject * obj1 = 0 ;
20814 if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
20815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "requals" "', argument " "1"" of type '" "double const *""'");
20819 arg1 = reinterpret_cast< double * >(argp1);
20820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
20821 if (!SWIG_IsOK(res2)) {
20822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "requals" "', argument " "2"" of type '" "double const *""'");
20824 arg2 = reinterpret_cast< double * >(argp2);
20825 result = (bool)Hex::requals((double const *)arg1,(double const *)arg2);
20826 resultobj = SWIG_From_bool(static_cast< bool >(result));
20833 SWIGINTERN PyObject *_wrap_requals(PyObject *self, PyObject *args) {
20835 PyObject *argv[3] = {
20840 if (!PyTuple_Check(args)) SWIG_fail;
20841 argc = args ? PyObject_Length(args) : 0;
20842 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
20843 argv[ii] = PyTuple_GET_ITEM(args,ii);
20848 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20849 _v = SWIG_CheckState(res);
20852 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20853 _v = SWIG_CheckState(res);
20855 return _wrap_requals__SWIG_1(self, args);
20862 int res = SWIG_AsVal_double(argv[0], NULL);
20863 _v = SWIG_CheckState(res);
20867 int res = SWIG_AsVal_double(argv[1], NULL);
20868 _v = SWIG_CheckState(res);
20871 return _wrap_requals__SWIG_0(self, args);
20877 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'requals'.\n"
20878 " Possible C/C++ prototypes are:\n"
20879 " Hex::requals(double const,double const)\n"
20880 " Hex::requals(double const *,double const *)\n");
20885 SWIGINTERN PyObject *_wrap_on_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20886 PyObject *resultobj = 0;
20889 if (!PyArg_ParseTuple(args,(char *)":on_debug")) SWIG_fail;
20890 result = (bool)Hex::on_debug();
20891 resultobj = SWIG_From_bool(static_cast< bool >(result));
20898 SWIGINTERN PyObject *_wrap_in_test(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899 PyObject *resultobj = 0;
20902 if (!PyArg_ParseTuple(args,(char *)":in_test")) SWIG_fail;
20903 result = (bool)Hex::in_test();
20904 resultobj = SWIG_From_bool(static_cast< bool >(result));
20911 SWIGINTERN PyObject *_wrap_niv_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20915 if (!PyArg_ParseTuple(args,(char *)":niv_debug")) SWIG_fail;
20916 result = (int)Hex::niv_debug();
20917 resultobj = SWIG_From_int(static_cast< int >(result));
20924 SWIGINTERN PyObject *_wrap_set_minus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925 PyObject *resultobj = 0;
20926 std::string *arg1 = 0 ;
20929 PyObject * obj0 = 0 ;
20931 if (!PyArg_ParseTuple(args,(char *)"O:set_minus",&obj0)) SWIG_fail;
20932 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string, 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
20937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
20939 arg1 = reinterpret_cast< std::string * >(argp1);
20940 Hex::set_minus(*arg1);
20941 resultobj = SWIG_Py_Void();
20948 SWIGINTERN PyObject *_wrap_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20952 if (!PyArg_ParseTuple(args,(char *)":special_option")) SWIG_fail;
20953 result = (bool)Hex::special_option();
20954 resultobj = SWIG_From_bool(static_cast< bool >(result));
20961 SWIGINTERN PyObject *_wrap_set_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20966 PyObject * obj0 = 0 ;
20968 if (!PyArg_ParseTuple(args,(char *)"O:set_special_option",&obj0)) SWIG_fail;
20969 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20970 if (!SWIG_IsOK(ecode1)) {
20971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_special_option" "', argument " "1"" of type '" "bool""'");
20973 arg1 = static_cast< bool >(val1);
20974 Hex::set_special_option(arg1);
20975 resultobj = SWIG_Py_Void();
20982 SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20983 PyObject *resultobj = 0;
20984 cpchar arg1 = (cpchar) 0 ;
20988 PyObject * obj0 = 0 ;
20991 if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
20992 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20993 if (!SWIG_IsOK(res1)) {
20994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sizeof_file" "', argument " "1"" of type '" "cpchar""'");
20996 arg1 = reinterpret_cast< cpchar >(buf1);
20997 result = (int)Hex::sizeof_file((char const *)arg1);
20998 resultobj = SWIG_From_int(static_cast< int >(result));
20999 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21002 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21007 SWIGINTERN PyObject *_wrap_read_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008 PyObject *resultobj = 0;
21009 cpchar arg1 = (cpchar) 0 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21020 if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
21021 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21022 if (!SWIG_IsOK(res1)) {
21023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_file" "', argument " "1"" of type '" "cpchar""'");
21025 arg1 = reinterpret_cast< cpchar >(buf1);
21026 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 );
21027 if (!SWIG_IsOK(res2)) {
21028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
21031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
21033 arg2 = reinterpret_cast< int * >(argp2);
21034 result = (char *)Hex::read_file((char const *)arg1,*arg2);
21035 resultobj = SWIG_FromCharPtr((const char *)result);
21036 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21039 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21044 SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *resultobj = 0;
21046 std::string *arg1 = 0 ;
21049 PyObject * obj0 = 0 ;
21052 if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
21053 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string, 0 );
21054 if (!SWIG_IsOK(res1)) {
21055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
21058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
21060 arg1 = reinterpret_cast< std::string * >(argp1);
21061 result = (cpchar)Hex::get_time(*arg1);
21062 resultobj = SWIG_FromCharPtr((const char *)result);
21069 SWIGINTERN PyObject *_wrap_make_basename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 cpchar arg1 = (cpchar) 0 ;
21072 std::string *arg2 = 0 ;
21078 PyObject * obj0 = 0 ;
21079 PyObject * obj1 = 0 ;
21082 if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
21083 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_basename" "', argument " "1"" of type '" "cpchar""'");
21087 arg1 = reinterpret_cast< cpchar >(buf1);
21088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 );
21089 if (!SWIG_IsOK(res2)) {
21090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
21093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
21095 arg2 = reinterpret_cast< std::string * >(argp2);
21096 result = (int)Hex::make_basename((char const *)arg1,*arg2);
21097 resultobj = SWIG_From_int(static_cast< int >(result));
21098 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21101 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21106 SWIGINTERN int Swig_var_Epsil_set(PyObject *) {
21107 SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
21112 SWIGINTERN PyObject *Swig_var_Epsil_get(void) {
21113 PyObject *pyobj = 0;
21115 pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
21120 SWIGINTERN int Swig_var_UnEpsil_set(PyObject *) {
21121 SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
21126 SWIGINTERN PyObject *Swig_var_UnEpsil_get(void) {
21127 PyObject *pyobj = 0;
21129 pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
21134 SWIGINTERN int Swig_var_Epsil2_set(PyObject *) {
21135 SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
21140 SWIGINTERN PyObject *Swig_var_Epsil2_get(void) {
21141 PyObject *pyobj = 0;
21143 pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
21148 SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21149 PyObject *resultobj = 0;
21150 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21153 PyObject * obj0 = 0 ;
21156 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
21157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countHexa" "', argument " "1"" of type '" "Hex::EltBase *""'");
21161 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21162 result = (int)(arg1)->countHexa();
21163 resultobj = SWIG_From_int(static_cast< int >(result));
21170 SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21175 PyObject * obj0 = 0 ;
21178 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
21179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countQuad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21183 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21184 result = (int)(arg1)->countQuad();
21185 resultobj = SWIG_From_int(static_cast< int >(result));
21192 SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193 PyObject *resultobj = 0;
21194 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21197 PyObject * obj0 = 0 ;
21200 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
21201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21202 if (!SWIG_IsOK(res1)) {
21203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
21205 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21206 result = (int)(arg1)->countEdge();
21207 resultobj = SWIG_From_int(static_cast< int >(result));
21214 SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21215 PyObject *resultobj = 0;
21216 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21219 PyObject * obj0 = 0 ;
21222 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
21227 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21228 result = (int)(arg1)->countVertex();
21229 resultobj = SWIG_From_int(static_cast< int >(result));
21236 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21237 PyObject *resultobj = 0;
21238 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21244 PyObject * obj0 = 0 ;
21245 PyObject * obj1 = 0 ;
21247 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setError",&obj0,&obj1)) SWIG_fail;
21248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21249 if (!SWIG_IsOK(res1)) {
21250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21252 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21253 ecode2 = SWIG_AsVal_int(obj1, &val2);
21254 if (!SWIG_IsOK(ecode2)) {
21255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setError" "', argument " "2"" of type '" "int""'");
21257 arg2 = static_cast< int >(val2);
21258 (arg1)->setError(arg2);
21259 resultobj = SWIG_Py_Void();
21266 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 PyObject *resultobj = 0;
21268 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21271 PyObject * obj0 = 0 ;
21273 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_setError",&obj0)) SWIG_fail;
21274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21275 if (!SWIG_IsOK(res1)) {
21276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21278 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21279 (arg1)->setError();
21280 resultobj = SWIG_Py_Void();
21287 SWIGINTERN PyObject *_wrap_EltBase_setError(PyObject *self, PyObject *args) {
21289 PyObject *argv[3] = {
21294 if (!PyTuple_Check(args)) SWIG_fail;
21295 argc = args ? PyObject_Length(args) : 0;
21296 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
21297 argv[ii] = PyTuple_GET_ITEM(args,ii);
21302 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
21303 _v = SWIG_CheckState(res);
21305 return _wrap_EltBase_setError__SWIG_1(self, args);
21311 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
21312 _v = SWIG_CheckState(res);
21315 int res = SWIG_AsVal_int(argv[1], NULL);
21316 _v = SWIG_CheckState(res);
21319 return _wrap_EltBase_setError__SWIG_0(self, args);
21325 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_setError'.\n"
21326 " Possible C/C++ prototypes are:\n"
21327 " Hex::EltBase::setError(int)\n"
21328 " Hex::EltBase::setError()\n");
21333 SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21334 PyObject *resultobj = 0;
21335 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21338 PyObject * obj0 = 0 ;
21341 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
21342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21346 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21347 result = (int)(arg1)->getError();
21348 resultobj = SWIG_From_int(static_cast< int >(result));
21355 SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21356 PyObject *resultobj = 0;
21357 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21360 PyObject * obj0 = 0 ;
21363 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
21364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21365 if (!SWIG_IsOK(res1)) {
21366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isValid" "', argument " "1"" of type '" "Hex::EltBase *""'");
21368 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21369 result = (bool)(arg1)->isValid();
21370 resultobj = SWIG_From_bool(static_cast< bool >(result));
21377 SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21382 PyObject * obj0 = 0 ;
21385 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isBad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21390 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21391 result = (bool)(arg1)->isBad();
21392 resultobj = SWIG_From_bool(static_cast< bool >(result));
21399 SWIGINTERN PyObject *_wrap_EltBase_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21400 PyObject *resultobj = 0;
21401 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21404 PyObject * obj0 = 0 ;
21406 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_duplicate",&obj0)) SWIG_fail;
21407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21408 if (!SWIG_IsOK(res1)) {
21409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_duplicate" "', argument " "1"" of type '" "Hex::EltBase *""'");
21411 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21412 (arg1)->duplicate();
21413 resultobj = SWIG_Py_Void();
21420 SWIGINTERN PyObject *_wrap_EltBase_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21421 PyObject *resultobj = 0;
21422 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21425 PyObject * obj0 = 0 ;
21427 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_clearAssociation",&obj0)) SWIG_fail;
21428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21429 if (!SWIG_IsOK(res1)) {
21430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_clearAssociation" "', argument " "1"" of type '" "Hex::EltBase *""'");
21432 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21433 (arg1)->clearAssociation();
21434 resultobj = SWIG_Py_Void();
21441 SWIGINTERN PyObject *_wrap_EltBase_replaceEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21442 PyObject *resultobj = 0;
21443 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21444 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
21445 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
21452 PyObject * obj0 = 0 ;
21453 PyObject * obj1 = 0 ;
21454 PyObject * obj2 = 0 ;
21456 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceEdge",&obj0,&obj1,&obj2)) SWIG_fail;
21457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
21461 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21463 if (!SWIG_IsOK(res2)) {
21464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
21466 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
21467 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
21468 if (!SWIG_IsOK(res3)) {
21469 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
21471 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
21472 (arg1)->replaceEdge(arg2,arg3);
21473 resultobj = SWIG_Py_Void();
21480 SWIGINTERN PyObject *_wrap_EltBase_replaceVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21481 PyObject *resultobj = 0;
21482 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21483 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21484 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21491 PyObject * obj0 = 0 ;
21492 PyObject * obj1 = 0 ;
21493 PyObject * obj2 = 0 ;
21495 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceVertex",&obj0,&obj1,&obj2)) SWIG_fail;
21496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21497 if (!SWIG_IsOK(res1)) {
21498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
21500 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21501 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21502 if (!SWIG_IsOK(res2)) {
21503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
21505 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21506 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
21507 if (!SWIG_IsOK(res3)) {
21508 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
21510 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21511 (arg1)->replaceVertex(arg2,arg3);
21512 resultobj = SWIG_Py_Void();
21519 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *resultobj = 0;
21521 Hex::Document *arg1 = (Hex::Document *) 0 ;
21522 Hex::EnumElt arg2 ;
21527 PyObject * obj0 = 0 ;
21528 PyObject * obj1 = 0 ;
21529 Hex::EltBase *result = 0 ;
21531 if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
21532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21533 if (!SWIG_IsOK(res1)) {
21534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
21536 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21537 ecode2 = SWIG_AsVal_int(obj1, &val2);
21538 if (!SWIG_IsOK(ecode2)) {
21539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EltBase" "', argument " "2"" of type '" "Hex::EnumElt""'");
21541 arg2 = static_cast< Hex::EnumElt >(val2);
21542 result = (Hex::EltBase *)new Hex::EltBase(arg1,arg2);
21543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
21550 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21551 PyObject *resultobj = 0;
21552 Hex::Document *arg1 = (Hex::Document *) 0 ;
21555 PyObject * obj0 = 0 ;
21556 Hex::EltBase *result = 0 ;
21558 if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
21559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
21560 if (!SWIG_IsOK(res1)) {
21561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
21563 arg1 = reinterpret_cast< Hex::Document * >(argp1);
21564 result = (Hex::EltBase *)new Hex::EltBase(arg1);
21565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
21572 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 Hex::EnumElt arg1 ;
21577 PyObject * obj0 = 0 ;
21578 Hex::EltBase *result = 0 ;
21580 if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
21581 ecode1 = SWIG_AsVal_int(obj0, &val1);
21582 if (!SWIG_IsOK(ecode1)) {
21583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::EnumElt""'");
21585 arg1 = static_cast< Hex::EnumElt >(val1);
21586 result = (Hex::EltBase *)new Hex::EltBase(arg1);
21587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
21594 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21595 PyObject *resultobj = 0;
21596 Hex::EltBase *result = 0 ;
21598 if (!PyArg_ParseTuple(args,(char *)":new_EltBase")) SWIG_fail;
21599 result = (Hex::EltBase *)new Hex::EltBase();
21600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW | 0 );
21607 SWIGINTERN PyObject *_wrap_new_EltBase(PyObject *self, PyObject *args) {
21609 PyObject *argv[3] = {
21614 if (!PyTuple_Check(args)) SWIG_fail;
21615 argc = args ? PyObject_Length(args) : 0;
21616 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
21617 argv[ii] = PyTuple_GET_ITEM(args,ii);
21620 return _wrap_new_EltBase__SWIG_3(self, args);
21625 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21626 _v = SWIG_CheckState(res);
21628 return _wrap_new_EltBase__SWIG_1(self, args);
21634 int res = SWIG_AsVal_int(argv[0], NULL);
21635 _v = SWIG_CheckState(res);
21638 return _wrap_new_EltBase__SWIG_2(self, args);
21644 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21645 _v = SWIG_CheckState(res);
21648 int res = SWIG_AsVal_int(argv[1], NULL);
21649 _v = SWIG_CheckState(res);
21652 return _wrap_new_EltBase__SWIG_0(self, args);
21658 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EltBase'.\n"
21659 " Possible C/C++ prototypes are:\n"
21660 " Hex::EltBase::EltBase(Hex::Document *,Hex::EnumElt)\n"
21661 " Hex::EltBase::EltBase(Hex::Document *)\n"
21662 " Hex::EltBase::EltBase(Hex::EnumElt)\n"
21663 " Hex::EltBase::EltBase()\n");
21668 SWIGINTERN PyObject *_wrap_delete_EltBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *resultobj = 0;
21670 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21673 PyObject * obj0 = 0 ;
21675 if (!PyArg_ParseTuple(args,(char *)"O:delete_EltBase",&obj0)) SWIG_fail;
21676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_DISOWN | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EltBase" "', argument " "1"" of type '" "Hex::EltBase *""'");
21680 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21682 resultobj = SWIG_Py_Void();
21689 SWIGINTERN PyObject *_wrap_EltBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21694 PyObject * obj0 = 0 ;
21696 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_remove",&obj0)) SWIG_fail;
21697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_remove" "', argument " "1"" of type '" "Hex::EltBase *""'");
21701 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21703 resultobj = SWIG_Py_Void();
21710 SWIGINTERN PyObject *_wrap_EltBase_suppress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711 PyObject *resultobj = 0;
21712 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21715 PyObject * obj0 = 0 ;
21717 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_suppress",&obj0)) SWIG_fail;
21718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21719 if (!SWIG_IsOK(res1)) {
21720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_suppress" "', argument " "1"" of type '" "Hex::EltBase *""'");
21722 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21723 (arg1)->suppress();
21724 resultobj = SWIG_Py_Void();
21731 SWIGINTERN PyObject *_wrap_EltBase_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732 PyObject *resultobj = 0;
21733 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21736 PyObject * obj0 = 0 ;
21738 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dump",&obj0)) SWIG_fail;
21739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21740 if (!SWIG_IsOK(res1)) {
21741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dump" "', argument " "1"" of type '" "Hex::EltBase *""'");
21743 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21745 resultobj = SWIG_Py_Void();
21752 SWIGINTERN PyObject *_wrap_EltBase_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21753 PyObject *resultobj = 0;
21754 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21755 Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21763 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_saveXml",&obj0,&obj1)) SWIG_fail;
21764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_saveXml" "', argument " "1"" of type '" "Hex::EltBase *""'");
21768 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 | 0 );
21770 if (!SWIG_IsOK(res2)) {
21771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
21773 arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
21774 (arg1)->saveXml(arg2);
21775 resultobj = SWIG_Py_Void();
21782 SWIGINTERN PyObject *_wrap_EltBase_majReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21783 PyObject *resultobj = 0;
21784 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21787 PyObject * obj0 = 0 ;
21789 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_majReferences",&obj0)) SWIG_fail;
21790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_majReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
21794 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21795 (arg1)->majReferences();
21796 resultobj = SWIG_Py_Void();
21803 SWIGINTERN PyObject *_wrap_EltBase_makeVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21804 PyObject *resultobj = 0;
21805 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21806 char *arg2 = (char *) 0 ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21816 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
21817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21818 if (!SWIG_IsOK(res1)) {
21819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_makeVarName" "', argument " "1"" of type '" "Hex::EltBase *""'");
21821 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21822 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21823 if (!SWIG_IsOK(res2)) {
21824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_makeVarName" "', argument " "2"" of type '" "char *""'");
21826 arg2 = reinterpret_cast< char * >(buf2);
21827 result = (char *)(arg1)->makeVarName(arg2);
21828 resultobj = SWIG_FromCharPtr((const char *)result);
21829 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21832 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21837 SWIGINTERN PyObject *_wrap_EltBase_makeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21838 PyObject *resultobj = 0;
21841 char *arg3 = (char *) 0 ;
21849 PyObject * obj0 = 0 ;
21850 PyObject * obj1 = 0 ;
21851 PyObject * obj2 = 0 ;
21854 if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
21855 ecode1 = SWIG_AsVal_int(obj0, &val1);
21856 if (!SWIG_IsOK(ecode1)) {
21857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EltBase_makeName" "', argument " "1"" of type '" "int""'");
21859 arg1 = static_cast< int >(val1);
21860 ecode2 = SWIG_AsVal_int(obj1, &val2);
21861 if (!SWIG_IsOK(ecode2)) {
21862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_makeName" "', argument " "2"" of type '" "int""'");
21864 arg2 = static_cast< int >(val2);
21865 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
21866 if (!SWIG_IsOK(res3)) {
21867 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_makeName" "', argument " "3"" of type '" "char *""'");
21869 arg3 = reinterpret_cast< char * >(buf3);
21870 result = (char *)Hex::EltBase::makeName(arg1,arg2,arg3);
21871 resultobj = SWIG_FromCharPtr((const char *)result);
21872 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
21875 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
21880 SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 PyObject *resultobj = 0;
21882 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21885 PyObject * obj0 = 0 ;
21886 Hex::EltBase *result = 0 ;
21888 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
21889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21890 if (!SWIG_IsOK(res1)) {
21891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_next" "', argument " "1"" of type '" "Hex::EltBase *""'");
21893 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21894 result = (Hex::EltBase *)(arg1)->next();
21895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21902 SWIGINTERN PyObject *_wrap_EltBase_setNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21903 PyObject *resultobj = 0;
21904 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21905 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
21910 PyObject * obj0 = 0 ;
21911 PyObject * obj1 = 0 ;
21913 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setNext",&obj0,&obj1)) SWIG_fail;
21914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21915 if (!SWIG_IsOK(res1)) {
21916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setNext" "', argument " "1"" of type '" "Hex::EltBase *""'");
21918 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21920 if (!SWIG_IsOK(res2)) {
21921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setNext" "', argument " "2"" of type '" "Hex::EltBase *""'");
21923 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
21924 (arg1)->setNext(arg2);
21925 resultobj = SWIG_Py_Void();
21932 SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933 PyObject *resultobj = 0;
21934 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21937 PyObject * obj0 = 0 ;
21940 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
21941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21942 if (!SWIG_IsOK(res1)) {
21943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getId" "', argument " "1"" of type '" "Hex::EltBase *""'");
21945 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21946 result = (int)(arg1)->getId();
21947 resultobj = SWIG_From_int(static_cast< int >(result));
21954 SWIGINTERN PyObject *_wrap_EltBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21955 PyObject *resultobj = 0;
21956 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21962 PyObject * obj0 = 0 ;
21963 PyObject * obj1 = 0 ;
21965 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setId",&obj0,&obj1)) SWIG_fail;
21966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21967 if (!SWIG_IsOK(res1)) {
21968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setId" "', argument " "1"" of type '" "Hex::EltBase *""'");
21970 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21971 ecode2 = SWIG_AsVal_int(obj1, &val2);
21972 if (!SWIG_IsOK(ecode2)) {
21973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setId" "', argument " "2"" of type '" "int""'");
21975 arg2 = static_cast< int >(val2);
21976 (arg1)->setId(arg2);
21977 resultobj = SWIG_Py_Void();
21984 SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21989 PyObject * obj0 = 0 ;
21990 Hex::Document *result = 0 ;
21992 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
21993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
21994 if (!SWIG_IsOK(res1)) {
21995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21997 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21998 result = (Hex::Document *)(arg1)->dad();
21999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
22006 SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22011 PyObject * obj0 = 0 ;
22012 Hex::EnumElt result;
22014 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
22015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getType" "', argument " "1"" of type '" "Hex::EltBase *""'");
22019 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22020 result = (Hex::EnumElt)(arg1)->getType();
22021 resultobj = SWIG_From_int(static_cast< int >(result));
22028 SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22033 PyObject * obj0 = 0 ;
22036 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
22037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isHere" "', argument " "1"" of type '" "Hex::EltBase *""'");
22041 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22042 result = (bool)(arg1)->isHere();
22043 resultobj = SWIG_From_bool(static_cast< bool >(result));
22050 SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22055 PyObject * obj0 = 0 ;
22058 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
22059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22060 if (!SWIG_IsOK(res1)) {
22061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isDeleted" "', argument " "1"" of type '" "Hex::EltBase *""'");
22063 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22064 result = (bool)(arg1)->isDeleted();
22065 resultobj = SWIG_From_bool(static_cast< bool >(result));
22072 SWIGINTERN PyObject *_wrap_EltBase_razReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073 PyObject *resultobj = 0;
22074 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22077 PyObject * obj0 = 0 ;
22079 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_razReferences",&obj0)) SWIG_fail;
22080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_razReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
22084 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22085 (arg1)->razReferences();
22086 resultobj = SWIG_Py_Void();
22093 SWIGINTERN PyObject *_wrap_EltBase_addParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22094 PyObject *resultobj = 0;
22095 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22096 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
22101 PyObject * obj0 = 0 ;
22102 PyObject * obj1 = 0 ;
22104 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_addParent",&obj0,&obj1)) SWIG_fail;
22105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_addParent" "', argument " "1"" of type '" "Hex::EltBase *""'");
22109 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22111 if (!SWIG_IsOK(res2)) {
22112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_addParent" "', argument " "2"" of type '" "Hex::EltBase *""'");
22114 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
22115 (arg1)->addParent(arg2);
22116 resultobj = SWIG_Py_Void();
22123 SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22128 PyObject * obj0 = 0 ;
22131 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
22132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22133 if (!SWIG_IsOK(res1)) {
22134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNbrParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
22136 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22137 result = (int)(arg1)->getNbrParents();
22138 resultobj = SWIG_From_int(static_cast< int >(result));
22145 SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146 PyObject *resultobj = 0;
22147 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22150 PyObject * obj0 = 0 ;
22153 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
22154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22155 if (!SWIG_IsOK(res1)) {
22156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_hasParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
22158 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22159 result = (bool)(arg1)->hasParents();
22160 resultobj = SWIG_From_bool(static_cast< bool >(result));
22167 SWIGINTERN PyObject *_wrap_EltBase_getFather(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22168 PyObject *resultobj = 0;
22169 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22175 PyObject * obj0 = 0 ;
22176 PyObject * obj1 = 0 ;
22177 Hex::EltBase *result = 0 ;
22179 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
22180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22181 if (!SWIG_IsOK(res1)) {
22182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getFather" "', argument " "1"" of type '" "Hex::EltBase *""'");
22184 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22185 ecode2 = SWIG_AsVal_int(obj1, &val2);
22186 if (!SWIG_IsOK(ecode2)) {
22187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_getFather" "', argument " "2"" of type '" "int""'");
22189 arg2 = static_cast< int >(val2);
22190 result = (Hex::EltBase *)(arg1)->getFather(arg2);
22191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22198 SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22199 PyObject *resultobj = 0;
22200 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22203 PyObject * obj0 = 0 ;
22206 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
22207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
22211 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22212 result = (int)(arg1)->getMark();
22213 resultobj = SWIG_From_int(static_cast< int >(result));
22220 SWIGINTERN PyObject *_wrap_EltBase_setMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22228 PyObject * obj0 = 0 ;
22229 PyObject * obj1 = 0 ;
22231 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setMark",&obj0,&obj1)) SWIG_fail;
22232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22233 if (!SWIG_IsOK(res1)) {
22234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
22236 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22237 ecode2 = SWIG_AsVal_int(obj1, &val2);
22238 if (!SWIG_IsOK(ecode2)) {
22239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setMark" "', argument " "2"" of type '" "int""'");
22241 arg2 = static_cast< int >(val2);
22242 (arg1)->setMark(arg2);
22243 resultobj = SWIG_Py_Void();
22250 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251 PyObject *resultobj = 0;
22252 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22253 pchar arg2 = (pchar) 0 ;
22259 PyObject * obj0 = 0 ;
22260 PyObject * obj1 = 0 ;
22263 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) SWIG_fail;
22264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22268 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22269 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22270 if (!SWIG_IsOK(res2)) {
22271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_getName" "', argument " "2"" of type '" "pchar""'");
22273 arg2 = reinterpret_cast< pchar >(buf2);
22274 result = (char *)(arg1)->getName(arg2);
22275 resultobj = SWIG_FromCharPtr((const char *)result);
22276 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22279 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22284 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22287 cpchar arg2 = (cpchar) 0 ;
22293 PyObject * obj0 = 0 ;
22294 PyObject * obj1 = 0 ;
22296 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_printName",&obj0,&obj1)) SWIG_fail;
22297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22298 if (!SWIG_IsOK(res1)) {
22299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22301 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22302 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22303 if (!SWIG_IsOK(res2)) {
22304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_printName" "', argument " "2"" of type '" "cpchar""'");
22306 arg2 = reinterpret_cast< cpchar >(buf2);
22307 (arg1)->printName(arg2);
22308 resultobj = SWIG_Py_Void();
22309 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22312 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22317 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22318 PyObject *resultobj = 0;
22319 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22322 PyObject * obj0 = 0 ;
22324 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_printName",&obj0)) SWIG_fail;
22325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22326 if (!SWIG_IsOK(res1)) {
22327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22329 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22330 (arg1)->printName();
22331 resultobj = SWIG_Py_Void();
22338 SWIGINTERN PyObject *_wrap_EltBase_printName(PyObject *self, PyObject *args) {
22340 PyObject *argv[3] = {
22345 if (!PyTuple_Check(args)) SWIG_fail;
22346 argc = args ? PyObject_Length(args) : 0;
22347 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22348 argv[ii] = PyTuple_GET_ITEM(args,ii);
22353 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22354 _v = SWIG_CheckState(res);
22356 return _wrap_EltBase_printName__SWIG_1(self, args);
22362 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22363 _v = SWIG_CheckState(res);
22365 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22366 _v = SWIG_CheckState(res);
22368 return _wrap_EltBase_printName__SWIG_0(self, args);
22374 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_printName'.\n"
22375 " Possible C/C++ prototypes are:\n"
22376 " Hex::EltBase::printName(cpchar)\n"
22377 " Hex::EltBase::printName()\n");
22382 SWIGINTERN PyObject *_wrap_EltBase_dumpRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383 PyObject *resultobj = 0;
22384 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22387 PyObject * obj0 = 0 ;
22389 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dumpRef",&obj0)) SWIG_fail;
22390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dumpRef" "', argument " "1"" of type '" "Hex::EltBase *""'");
22394 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22396 resultobj = SWIG_Py_Void();
22403 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22408 PyObject * obj0 = 0 ;
22411 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
22412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22413 if (!SWIG_IsOK(res1)) {
22414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22416 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22417 result = (cpchar)(arg1)->getName();
22418 resultobj = SWIG_FromCharPtr((const char *)result);
22425 SWIGINTERN PyObject *_wrap_EltBase_getName(PyObject *self, PyObject *args) {
22427 PyObject *argv[3] = {
22432 if (!PyTuple_Check(args)) SWIG_fail;
22433 argc = args ? PyObject_Length(args) : 0;
22434 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22435 argv[ii] = PyTuple_GET_ITEM(args,ii);
22440 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22441 _v = SWIG_CheckState(res);
22443 return _wrap_EltBase_getName__SWIG_1(self, args);
22449 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22450 _v = SWIG_CheckState(res);
22452 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22453 _v = SWIG_CheckState(res);
22455 return _wrap_EltBase_getName__SWIG_0(self, args);
22461 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_getName'.\n"
22462 " Possible C/C++ prototypes are:\n"
22463 " Hex::EltBase::getName(pchar)\n"
22464 " Hex::EltBase::getName()\n");
22469 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22470 PyObject *resultobj = 0;
22471 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22472 std::string *arg2 = 0 ;
22477 PyObject * obj0 = 0 ;
22478 PyObject * obj1 = 0 ;
22480 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
22481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22485 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 | 0);
22487 if (!SWIG_IsOK(res2)) {
22488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
22491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
22493 arg2 = reinterpret_cast< std::string * >(argp2);
22494 (arg1)->setName((std::string const &)*arg2);
22495 resultobj = SWIG_Py_Void();
22502 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22505 cpchar arg2 = (cpchar) 0 ;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22514 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
22515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22516 if (!SWIG_IsOK(res1)) {
22517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22519 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22520 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22521 if (!SWIG_IsOK(res2)) {
22522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "cpchar""'");
22524 arg2 = reinterpret_cast< cpchar >(buf2);
22525 (arg1)->setName(arg2);
22526 resultobj = SWIG_Py_Void();
22527 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22530 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22535 SWIGINTERN PyObject *_wrap_EltBase_setName(PyObject *self, PyObject *args) {
22537 PyObject *argv[3] = {
22542 if (!PyTuple_Check(args)) SWIG_fail;
22543 argc = args ? PyObject_Length(args) : 0;
22544 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22545 argv[ii] = PyTuple_GET_ITEM(args,ii);
22550 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22551 _v = SWIG_CheckState(res);
22553 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
22554 _v = SWIG_CheckState(res);
22556 return _wrap_EltBase_setName__SWIG_0(self, args);
22563 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22564 _v = SWIG_CheckState(res);
22566 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22567 _v = SWIG_CheckState(res);
22569 return _wrap_EltBase_setName__SWIG_1(self, args);
22575 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_setName'.\n"
22576 " Possible C/C++ prototypes are:\n"
22577 " Hex::EltBase::setName(string const &)\n"
22578 " Hex::EltBase::setName(cpchar)\n");
22583 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *resultobj = 0;
22585 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22591 PyObject * obj0 = 0 ;
22592 PyObject * obj1 = 0 ;
22595 if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
22596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22597 if (!SWIG_IsOK(res1)) {
22598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
22600 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22601 ecode2 = SWIG_AsVal_int(obj1, &val2);
22602 if (!SWIG_IsOK(ecode2)) {
22603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_debug" "', argument " "2"" of type '" "int""'");
22605 arg2 = static_cast< int >(val2);
22606 result = (bool)(arg1)->debug(arg2);
22607 resultobj = SWIG_From_bool(static_cast< bool >(result));
22614 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22619 PyObject * obj0 = 0 ;
22622 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
22623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22624 if (!SWIG_IsOK(res1)) {
22625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
22627 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22628 result = (bool)(arg1)->debug();
22629 resultobj = SWIG_From_bool(static_cast< bool >(result));
22636 SWIGINTERN PyObject *_wrap_EltBase_debug(PyObject *self, PyObject *args) {
22638 PyObject *argv[3] = {
22643 if (!PyTuple_Check(args)) SWIG_fail;
22644 argc = args ? PyObject_Length(args) : 0;
22645 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22646 argv[ii] = PyTuple_GET_ITEM(args,ii);
22651 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22652 _v = SWIG_CheckState(res);
22654 return _wrap_EltBase_debug__SWIG_1(self, args);
22660 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22661 _v = SWIG_CheckState(res);
22664 int res = SWIG_AsVal_int(argv[1], NULL);
22665 _v = SWIG_CheckState(res);
22668 return _wrap_EltBase_debug__SWIG_0(self, args);
22674 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_debug'.\n"
22675 " Possible C/C++ prototypes are:\n"
22676 " Hex::EltBase::debug(int)\n"
22677 " Hex::EltBase::debug()\n");
22682 SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22683 PyObject *resultobj = 0;
22684 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22687 PyObject * obj0 = 0 ;
22690 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
22691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isAssociated" "', argument " "1"" of type '" "Hex::EltBase *""'");
22695 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22696 result = (bool)(arg1)->isAssociated();
22697 resultobj = SWIG_From_bool(static_cast< bool >(result));
22704 SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22705 PyObject *resultobj = 0;
22706 Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22709 PyObject * obj0 = 0 ;
22710 std::string result;
22712 if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNextName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22717 arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22718 result = (arg1)->getNextName();
22719 resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_string, SWIG_POINTER_OWN | 0 );
22726 SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22728 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
22729 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
22730 return SWIG_Py_Void();
22733 SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22738 PyObject * obj0 = 0 ;
22741 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
22742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22746 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22747 result = (double)(arg1)->getX();
22748 resultobj = SWIG_From_double(static_cast< double >(result));
22755 SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756 PyObject *resultobj = 0;
22757 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22760 PyObject * obj0 = 0 ;
22763 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
22764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22765 if (!SWIG_IsOK(res1)) {
22766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22768 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22769 result = (double)(arg1)->getY();
22770 resultobj = SWIG_From_double(static_cast< double >(result));
22777 SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22778 PyObject *resultobj = 0;
22779 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22782 PyObject * obj0 = 0 ;
22785 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
22786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22787 if (!SWIG_IsOK(res1)) {
22788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22790 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22791 result = (double)(arg1)->getZ();
22792 resultobj = SWIG_From_double(static_cast< double >(result));
22799 SWIGINTERN PyObject *_wrap_Vertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800 PyObject *resultobj = 0;
22801 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22807 PyObject * obj0 = 0 ;
22808 PyObject * obj1 = 0 ;
22810 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setX",&obj0,&obj1)) SWIG_fail;
22811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22815 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22816 ecode2 = SWIG_AsVal_double(obj1, &val2);
22817 if (!SWIG_IsOK(ecode2)) {
22818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setX" "', argument " "2"" of type '" "double""'");
22820 arg2 = static_cast< double >(val2);
22821 (arg1)->setX(arg2);
22822 resultobj = SWIG_Py_Void();
22829 SWIGINTERN PyObject *_wrap_Vertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 PyObject *resultobj = 0;
22831 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22837 PyObject * obj0 = 0 ;
22838 PyObject * obj1 = 0 ;
22840 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setY",&obj0,&obj1)) SWIG_fail;
22841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22845 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22846 ecode2 = SWIG_AsVal_double(obj1, &val2);
22847 if (!SWIG_IsOK(ecode2)) {
22848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setY" "', argument " "2"" of type '" "double""'");
22850 arg2 = static_cast< double >(val2);
22851 (arg1)->setY(arg2);
22852 resultobj = SWIG_Py_Void();
22859 SWIGINTERN PyObject *_wrap_Vertex_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860 PyObject *resultobj = 0;
22861 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22867 PyObject * obj0 = 0 ;
22868 PyObject * obj1 = 0 ;
22870 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setZ",&obj0,&obj1)) SWIG_fail;
22871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22872 if (!SWIG_IsOK(res1)) {
22873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22875 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22876 ecode2 = SWIG_AsVal_double(obj1, &val2);
22877 if (!SWIG_IsOK(ecode2)) {
22878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setZ" "', argument " "2"" of type '" "double""'");
22880 arg2 = static_cast< double >(val2);
22881 (arg1)->setZ(arg2);
22882 resultobj = SWIG_Py_Void();
22889 SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890 PyObject *resultobj = 0;
22891 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22894 PyObject * obj0 = 0 ;
22897 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
22898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22899 if (!SWIG_IsOK(res1)) {
22900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22902 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22903 result = (double)(arg1)->getAssoX();
22904 resultobj = SWIG_From_double(static_cast< double >(result));
22911 SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22912 PyObject *resultobj = 0;
22913 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22916 PyObject * obj0 = 0 ;
22919 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
22920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22921 if (!SWIG_IsOK(res1)) {
22922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22924 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22925 result = (double)(arg1)->getAssoY();
22926 resultobj = SWIG_From_double(static_cast< double >(result));
22933 SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22934 PyObject *resultobj = 0;
22935 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22938 PyObject * obj0 = 0 ;
22941 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
22942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22946 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22947 result = (double)(arg1)->getAssoZ();
22948 resultobj = SWIG_From_double(static_cast< double >(result));
22955 SWIGINTERN PyObject *_wrap_Vertex_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956 PyObject *resultobj = 0;
22957 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22958 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
22966 PyObject * obj0 = 0 ;
22967 PyObject * obj1 = 0 ;
22968 PyObject * obj2 = 0 ;
22971 if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
22972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
22973 if (!SWIG_IsOK(res1)) {
22974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
22976 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
22978 if (!SWIG_IsOK(res2)) {
22979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vertex_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
22981 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
22982 ecode3 = SWIG_AsVal_int(obj2, &val3);
22983 if (!SWIG_IsOK(ecode3)) {
22984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vertex_setAssociation" "', argument " "3"" of type '" "int""'");
22986 arg3 = static_cast< int >(val3);
22987 result = (int)(arg1)->setAssociation(arg2,arg3);
22988 resultobj = SWIG_From_int(static_cast< int >(result));
22995 SWIGINTERN PyObject *_wrap_Vertex_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22996 PyObject *resultobj = 0;
22997 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23000 PyObject * obj0 = 0 ;
23002 if (!PyArg_ParseTuple(args,(char *)"O:Vertex_clearAssociation",&obj0)) SWIG_fail;
23003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_clearAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
23007 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23008 (arg1)->clearAssociation();
23009 resultobj = SWIG_Py_Void();
23016 SWIGINTERN PyObject *_wrap_Vertex_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23024 PyObject * obj0 = 0 ;
23025 PyObject * obj1 = 0 ;
23027 if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setColor",&obj0,&obj1)) SWIG_fail;
23028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23029 if (!SWIG_IsOK(res1)) {
23030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setColor" "', argument " "1"" of type '" "Hex::Vertex *""'");
23032 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23033 ecode2 = SWIG_AsVal_double(obj1, &val2);
23034 if (!SWIG_IsOK(ecode2)) {
23035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setColor" "', argument " "2"" of type '" "double""'");
23037 arg2 = static_cast< double >(val2);
23038 (arg1)->setColor(arg2);
23039 resultobj = SWIG_Py_Void();
23046 SWIGINTERN PyObject *_wrap_new_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047 PyObject *resultobj = 0;
23048 Hex::Document *arg1 = (Hex::Document *) 0 ;
23060 PyObject * obj0 = 0 ;
23061 PyObject * obj1 = 0 ;
23062 PyObject * obj2 = 0 ;
23063 PyObject * obj3 = 0 ;
23064 Hex::Vertex *result = 0 ;
23066 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
23068 if (!SWIG_IsOK(res1)) {
23069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vertex" "', argument " "1"" of type '" "Hex::Document *""'");
23071 arg1 = reinterpret_cast< Hex::Document * >(argp1);
23072 ecode2 = SWIG_AsVal_double(obj1, &val2);
23073 if (!SWIG_IsOK(ecode2)) {
23074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vertex" "', argument " "2"" of type '" "double""'");
23076 arg2 = static_cast< double >(val2);
23077 ecode3 = SWIG_AsVal_double(obj2, &val3);
23078 if (!SWIG_IsOK(ecode3)) {
23079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vertex" "', argument " "3"" of type '" "double""'");
23081 arg3 = static_cast< double >(val3);
23082 ecode4 = SWIG_AsVal_double(obj3, &val4);
23083 if (!SWIG_IsOK(ecode4)) {
23084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vertex" "', argument " "4"" of type '" "double""'");
23086 arg4 = static_cast< double >(val4);
23087 result = (Hex::Vertex *)new Hex::Vertex(arg1,arg2,arg3,arg4);
23088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_NEW | 0 );
23095 SWIGINTERN PyObject *_wrap_delete_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096 PyObject *resultobj = 0;
23097 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23100 PyObject * obj0 = 0 ;
23102 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vertex",&obj0)) SWIG_fail;
23103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_DISOWN | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vertex" "', argument " "1"" of type '" "Hex::Vertex *""'");
23107 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23109 resultobj = SWIG_Py_Void();
23116 SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23118 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23119 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
23120 return SWIG_Py_Void();
23123 SWIGINTERN PyObject *_wrap_Edge_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23124 PyObject *resultobj = 0;
23125 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23131 PyObject * obj0 = 0 ;
23132 PyObject * obj1 = 0 ;
23133 Hex::Vertex *result = 0 ;
23135 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
23136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23137 if (!SWIG_IsOK(res1)) {
23138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getVertex" "', argument " "1"" of type '" "Hex::Edge *""'");
23140 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23141 ecode2 = SWIG_AsVal_int(obj1, &val2);
23142 if (!SWIG_IsOK(ecode2)) {
23143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_getVertex" "', argument " "2"" of type '" "int""'");
23145 arg2 = static_cast< int >(val2);
23146 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23154 SWIGINTERN PyObject *_wrap_Edge_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23155 PyObject *resultobj = 0;
23156 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23157 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23171 PyObject * obj0 = 0 ;
23172 PyObject * obj1 = 0 ;
23173 PyObject * obj2 = 0 ;
23174 PyObject * obj3 = 0 ;
23175 PyObject * obj4 = 0 ;
23178 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23180 if (!SWIG_IsOK(res1)) {
23181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_addAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23183 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
23185 if (!SWIG_IsOK(res2)) {
23186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23188 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23189 ecode3 = SWIG_AsVal_int(obj2, &val3);
23190 if (!SWIG_IsOK(ecode3)) {
23191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_addAssociation" "', argument " "3"" of type '" "int""'");
23193 arg3 = static_cast< int >(val3);
23194 ecode4 = SWIG_AsVal_double(obj3, &val4);
23195 if (!SWIG_IsOK(ecode4)) {
23196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Edge_addAssociation" "', argument " "4"" of type '" "double""'");
23198 arg4 = static_cast< double >(val4);
23199 ecode5 = SWIG_AsVal_double(obj4, &val5);
23200 if (!SWIG_IsOK(ecode5)) {
23201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Edge_addAssociation" "', argument " "5"" of type '" "double""'");
23203 arg5 = static_cast< double >(val5);
23204 result = (int)(arg1)->addAssociation(arg2,arg3,arg4,arg5);
23205 resultobj = SWIG_From_int(static_cast< int >(result));
23212 SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23215 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 PyObject * obj2 = 0 ;
23228 if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
23229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23230 if (!SWIG_IsOK(res1)) {
23231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23233 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
23235 if (!SWIG_IsOK(res2)) {
23236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23238 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23239 ecode3 = SWIG_AsVal_int(obj2, &val3);
23240 if (!SWIG_IsOK(ecode3)) {
23241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
23243 arg3 = static_cast< int >(val3);
23244 result = (int)(arg1)->setAssociation(arg2,arg3);
23245 resultobj = SWIG_From_int(static_cast< int >(result));
23252 SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23253 PyObject *resultobj = 0;
23254 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23255 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23260 PyObject * obj0 = 0 ;
23261 PyObject * obj1 = 0 ;
23264 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
23265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23266 if (!SWIG_IsOK(res1)) {
23267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23269 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
23271 if (!SWIG_IsOK(res2)) {
23272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23274 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23275 result = (int)(arg1)->findAssociation(arg2);
23276 resultobj = SWIG_From_int(static_cast< int >(result));
23283 SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284 PyObject *resultobj = 0;
23285 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23288 PyObject * obj0 = 0 ;
23290 if (!PyArg_ParseTuple(args,(char *)"O:Edge_clearAssociation",&obj0)) SWIG_fail;
23291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_clearAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23295 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23296 (arg1)->clearAssociation();
23297 resultobj = SWIG_Py_Void();
23304 SWIGINTERN PyObject *_wrap_Edge_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23305 PyObject *resultobj = 0;
23306 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23315 if (!PyArg_ParseTuple(args,(char *)"OO:Edge_setColor",&obj0,&obj1)) SWIG_fail;
23316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setColor" "', argument " "1"" of type '" "Hex::Edge *""'");
23320 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23321 ecode2 = SWIG_AsVal_double(obj1, &val2);
23322 if (!SWIG_IsOK(ecode2)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_setColor" "', argument " "2"" of type '" "double""'");
23325 arg2 = static_cast< double >(val2);
23326 (arg1)->setColor(arg2);
23327 resultobj = SWIG_Py_Void();
23334 SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23335 PyObject *resultobj = 0;
23336 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23339 PyObject * obj0 = 0 ;
23342 if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
23343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23344 if (!SWIG_IsOK(res1)) {
23345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getWay" "', argument " "1"" of type '" "Hex::Edge *""'");
23347 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23348 result = (bool)(arg1)->getWay();
23349 resultobj = SWIG_From_bool(static_cast< bool >(result));
23356 SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23357 PyObject *resultobj = 0;
23358 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23361 PyObject * obj0 = 0 ;
23364 if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
23365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
23366 if (!SWIG_IsOK(res1)) {
23367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getLength" "', argument " "1"" of type '" "Hex::Edge *""'");
23369 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23370 result = (double)(arg1)->getLength();
23371 resultobj = SWIG_From_double(static_cast< double >(result));
23378 SWIGINTERN PyObject *_wrap_new_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23381 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23386 PyObject * obj0 = 0 ;
23387 PyObject * obj1 = 0 ;
23388 Hex::Edge *result = 0 ;
23390 if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
23391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "Hex::Vertex *""'");
23395 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23397 if (!SWIG_IsOK(res2)) {
23398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Edge" "', argument " "2"" of type '" "Hex::Vertex *""'");
23400 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23401 result = (Hex::Edge *)new Hex::Edge(arg1,arg2);
23402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, SWIG_POINTER_NEW | 0 );
23409 SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410 PyObject *resultobj = 0;
23411 Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23414 PyObject * obj0 = 0 ;
23416 if (!PyArg_ParseTuple(args,(char *)"O:delete_Edge",&obj0)) SWIG_fail;
23417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, SWIG_POINTER_DISOWN | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "Hex::Edge *""'");
23421 arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23423 resultobj = SWIG_Py_Void();
23430 SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23432 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23433 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
23434 return SWIG_Py_Void();
23437 SWIGINTERN PyObject *_wrap_Quad_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *resultobj = 0;
23439 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23445 PyObject * obj0 = 0 ;
23446 PyObject * obj1 = 0 ;
23447 Hex::Edge *result = 0 ;
23449 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
23450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23451 if (!SWIG_IsOK(res1)) {
23452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getEdge" "', argument " "1"" of type '" "Hex::Quad *""'");
23454 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23455 ecode2 = SWIG_AsVal_int(obj1, &val2);
23456 if (!SWIG_IsOK(ecode2)) {
23457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getEdge" "', argument " "2"" of type '" "int""'");
23459 arg2 = static_cast< int >(val2);
23460 result = (Hex::Edge *)(arg1)->getEdge(arg2);
23461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
23468 SWIGINTERN PyObject *_wrap_Quad_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469 PyObject *resultobj = 0;
23470 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23476 PyObject * obj0 = 0 ;
23477 PyObject * obj1 = 0 ;
23478 Hex::Vertex *result = 0 ;
23480 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
23481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
23485 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23486 ecode2 = SWIG_AsVal_int(obj1, &val2);
23487 if (!SWIG_IsOK(ecode2)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getVertex" "', argument " "2"" of type '" "int""'");
23490 arg2 = static_cast< int >(val2);
23491 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23499 SWIGINTERN PyObject *_wrap_Quad_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23500 PyObject *resultobj = 0;
23501 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23502 Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23510 PyObject * obj0 = 0 ;
23511 PyObject * obj1 = 0 ;
23512 PyObject * obj2 = 0 ;
23515 if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
23516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_addAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
23520 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
23522 if (!SWIG_IsOK(res2)) {
23523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23525 arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23526 ecode3 = SWIG_AsVal_int(obj2, &val3);
23527 if (!SWIG_IsOK(ecode3)) {
23528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quad_addAssociation" "', argument " "3"" of type '" "int""'");
23530 arg3 = static_cast< int >(val3);
23531 result = (int)(arg1)->addAssociation(arg2,arg3);
23532 resultobj = SWIG_From_int(static_cast< int >(result));
23539 SWIGINTERN PyObject *_wrap_Quad_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 PyObject *resultobj = 0;
23541 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23544 PyObject * obj0 = 0 ;
23546 if (!PyArg_ParseTuple(args,(char *)"O:Quad_clearAssociation",&obj0)) SWIG_fail;
23547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23548 if (!SWIG_IsOK(res1)) {
23549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_clearAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
23551 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23552 (arg1)->clearAssociation();
23553 resultobj = SWIG_Py_Void();
23560 SWIGINTERN PyObject *_wrap_Quad_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23561 PyObject *resultobj = 0;
23562 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23568 PyObject * obj0 = 0 ;
23569 PyObject * obj1 = 0 ;
23571 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_setColor",&obj0,&obj1)) SWIG_fail;
23572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23573 if (!SWIG_IsOK(res1)) {
23574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_setColor" "', argument " "1"" of type '" "Hex::Quad *""'");
23576 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23577 ecode2 = SWIG_AsVal_double(obj1, &val2);
23578 if (!SWIG_IsOK(ecode2)) {
23579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_setColor" "', argument " "2"" of type '" "double""'");
23581 arg2 = static_cast< double >(val2);
23582 (arg1)->setColor(arg2);
23583 resultobj = SWIG_Py_Void();
23590 SWIGINTERN PyObject *_wrap_Quad_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591 PyObject *resultobj = 0;
23592 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23593 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 Hex::Vertex *result = 0 ;
23602 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
23603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23604 if (!SWIG_IsOK(res1)) {
23605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_nearestVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
23607 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23609 if (!SWIG_IsOK(res2)) {
23610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
23612 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23613 result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
23614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23621 SWIGINTERN PyObject *_wrap_Quad_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23624 double *arg2 = (double *) 0 ;
23629 PyObject * obj0 = 0 ;
23630 PyObject * obj1 = 0 ;
23631 double *result = 0 ;
23633 if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
23634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23635 if (!SWIG_IsOK(res1)) {
23636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getCenter" "', argument " "1"" of type '" "Hex::Quad *""'");
23638 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
23640 if (!SWIG_IsOK(res2)) {
23641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_getCenter" "', argument " "2"" of type '" "double *""'");
23643 arg2 = reinterpret_cast< double * >(argp2);
23644 result = (double *)(arg1)->getCenter(arg2);
23645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
23652 SWIGINTERN PyObject *_wrap_new_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23653 PyObject *resultobj = 0;
23654 Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23655 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23656 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23657 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23666 PyObject * obj0 = 0 ;
23667 PyObject * obj1 = 0 ;
23668 PyObject * obj2 = 0 ;
23669 PyObject * obj3 = 0 ;
23670 Hex::Quad *result = 0 ;
23672 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23674 if (!SWIG_IsOK(res1)) {
23675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quad" "', argument " "1"" of type '" "Hex::Vertex *""'");
23677 arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23679 if (!SWIG_IsOK(res2)) {
23680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Quad" "', argument " "2"" of type '" "Hex::Vertex *""'");
23682 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23683 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23684 if (!SWIG_IsOK(res3)) {
23685 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Quad" "', argument " "3"" of type '" "Hex::Vertex *""'");
23687 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23688 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23689 if (!SWIG_IsOK(res4)) {
23690 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Quad" "', argument " "4"" of type '" "Hex::Vertex *""'");
23692 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23693 result = (Hex::Quad *)new Hex::Quad(arg1,arg2,arg3,arg4);
23694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, SWIG_POINTER_NEW | 0 );
23701 SWIGINTERN PyObject *_wrap_delete_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23706 PyObject * obj0 = 0 ;
23708 if (!PyArg_ParseTuple(args,(char *)"O:delete_Quad",&obj0)) SWIG_fail;
23709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, SWIG_POINTER_DISOWN | 0 );
23710 if (!SWIG_IsOK(res1)) {
23711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quad" "', argument " "1"" of type '" "Hex::Quad *""'");
23713 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23715 resultobj = SWIG_Py_Void();
23722 SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23725 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
23726 return SWIG_Py_Void();
23729 SWIGINTERN PyObject *_wrap_Hexa_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23730 PyObject *resultobj = 0;
23731 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23737 PyObject * obj0 = 0 ;
23738 PyObject * obj1 = 0 ;
23739 Hex::Quad *result = 0 ;
23741 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
23742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getQuad" "', argument " "1"" of type '" "Hex::Hexa *""'");
23746 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23747 ecode2 = SWIG_AsVal_int(obj1, &val2);
23748 if (!SWIG_IsOK(ecode2)) {
23749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getQuad" "', argument " "2"" of type '" "int""'");
23751 arg2 = static_cast< int >(val2);
23752 result = (Hex::Quad *)(arg1)->getQuad(arg2);
23753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
23760 SWIGINTERN PyObject *_wrap_Hexa_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 PyObject *resultobj = 0;
23762 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23768 PyObject * obj0 = 0 ;
23769 PyObject * obj1 = 0 ;
23770 Hex::Edge *result = 0 ;
23772 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
23773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23774 if (!SWIG_IsOK(res1)) {
23775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getEdge" "', argument " "1"" of type '" "Hex::Hexa *""'");
23777 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23778 ecode2 = SWIG_AsVal_int(obj1, &val2);
23779 if (!SWIG_IsOK(ecode2)) {
23780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getEdge" "', argument " "2"" of type '" "int""'");
23782 arg2 = static_cast< int >(val2);
23783 result = (Hex::Edge *)(arg1)->getEdge(arg2);
23784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
23791 SWIGINTERN PyObject *_wrap_Hexa_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 PyObject *resultobj = 0;
23793 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23799 PyObject * obj0 = 0 ;
23800 PyObject * obj1 = 0 ;
23801 Hex::Vertex *result = 0 ;
23803 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
23804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23805 if (!SWIG_IsOK(res1)) {
23806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getVertex" "', argument " "1"" of type '" "Hex::Hexa *""'");
23808 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23809 ecode2 = SWIG_AsVal_int(obj1, &val2);
23810 if (!SWIG_IsOK(ecode2)) {
23811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getVertex" "', argument " "2"" of type '" "int""'");
23813 arg2 = static_cast< int >(val2);
23814 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
23822 SWIGINTERN PyObject *_wrap_Hexa_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23823 PyObject *resultobj = 0;
23824 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23830 PyObject * obj0 = 0 ;
23831 PyObject * obj1 = 0 ;
23833 if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_setColor",&obj0,&obj1)) SWIG_fail;
23834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_setColor" "', argument " "1"" of type '" "Hex::Hexa *""'");
23838 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23839 ecode2 = SWIG_AsVal_double(obj1, &val2);
23840 if (!SWIG_IsOK(ecode2)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_setColor" "', argument " "2"" of type '" "double""'");
23843 arg2 = static_cast< double >(val2);
23844 (arg1)->setColor(arg2);
23845 resultobj = SWIG_Py_Void();
23852 SWIGINTERN PyObject *_wrap_new_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23855 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23856 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23857 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
23858 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
23859 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
23872 PyObject * obj0 = 0 ;
23873 PyObject * obj1 = 0 ;
23874 PyObject * obj2 = 0 ;
23875 PyObject * obj3 = 0 ;
23876 PyObject * obj4 = 0 ;
23877 PyObject * obj5 = 0 ;
23878 Hex::Hexa *result = 0 ;
23880 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23882 if (!SWIG_IsOK(res1)) {
23883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hexa" "', argument " "1"" of type '" "Hex::Quad *""'");
23885 arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23887 if (!SWIG_IsOK(res2)) {
23888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hexa" "', argument " "2"" of type '" "Hex::Quad *""'");
23890 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23891 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23892 if (!SWIG_IsOK(res3)) {
23893 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Hexa" "', argument " "3"" of type '" "Hex::Quad *""'");
23895 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23896 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23897 if (!SWIG_IsOK(res4)) {
23898 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Hexa" "', argument " "4"" of type '" "Hex::Quad *""'");
23900 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
23901 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23902 if (!SWIG_IsOK(res5)) {
23903 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Hexa" "', argument " "5"" of type '" "Hex::Quad *""'");
23905 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
23906 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
23907 if (!SWIG_IsOK(res6)) {
23908 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Hexa" "', argument " "6"" of type '" "Hex::Quad *""'");
23910 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
23911 result = (Hex::Hexa *)new Hex::Hexa(arg1,arg2,arg3,arg4,arg5,arg6);
23912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_NEW | 0 );
23919 SWIGINTERN PyObject *_wrap_delete_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 PyObject *resultobj = 0;
23921 Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23924 PyObject * obj0 = 0 ;
23926 if (!PyArg_ParseTuple(args,(char *)"O:delete_Hexa",&obj0)) SWIG_fail;
23927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_DISOWN | 0 );
23928 if (!SWIG_IsOK(res1)) {
23929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hexa" "', argument " "1"" of type '" "Hex::Hexa *""'");
23931 arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23933 resultobj = SWIG_Py_Void();
23940 SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23942 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23943 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
23944 return SWIG_Py_Void();
23947 SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23952 PyObject * obj0 = 0 ;
23955 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
23956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDx" "', argument " "1"" of type '" "Hex::Vector *""'");
23960 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
23961 result = (double)(arg1)->getDx();
23962 resultobj = SWIG_From_double(static_cast< double >(result));
23969 SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23970 PyObject *resultobj = 0;
23971 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23974 PyObject * obj0 = 0 ;
23977 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
23978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDy" "', argument " "1"" of type '" "Hex::Vector *""'");
23982 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
23983 result = (double)(arg1)->getDy();
23984 resultobj = SWIG_From_double(static_cast< double >(result));
23991 SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23996 PyObject * obj0 = 0 ;
23999 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
24000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
24001 if (!SWIG_IsOK(res1)) {
24002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDz" "', argument " "1"" of type '" "Hex::Vector *""'");
24004 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24005 result = (double)(arg1)->getDz();
24006 resultobj = SWIG_From_double(static_cast< double >(result));
24013 SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 PyObject *resultobj = 0;
24015 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24018 PyObject * obj0 = 0 ;
24021 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
24022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
24023 if (!SWIG_IsOK(res1)) {
24024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getNorm" "', argument " "1"" of type '" "Hex::Vector *""'");
24026 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24027 result = (double)(arg1)->getNorm();
24028 resultobj = SWIG_From_double(static_cast< double >(result));
24035 SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036 PyObject *resultobj = 0;
24037 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24040 PyObject * obj0 = 0 ;
24043 if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
24044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
24045 if (!SWIG_IsOK(res1)) {
24046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getAngleX" "', argument " "1"" of type '" "Hex::Vector *""'");
24048 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24049 result = (double)(arg1)->getAngleX();
24050 resultobj = SWIG_From_double(static_cast< double >(result));
24057 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24058 PyObject *resultobj = 0;
24059 Hex::Document *arg1 = (Hex::Document *) 0 ;
24071 PyObject * obj0 = 0 ;
24072 PyObject * obj1 = 0 ;
24073 PyObject * obj2 = 0 ;
24074 PyObject * obj3 = 0 ;
24075 Hex::Vector *result = 0 ;
24077 if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24082 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24083 ecode2 = SWIG_AsVal_double(obj1, &val2);
24084 if (!SWIG_IsOK(ecode2)) {
24085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24087 arg2 = static_cast< double >(val2);
24088 ecode3 = SWIG_AsVal_double(obj2, &val3);
24089 if (!SWIG_IsOK(ecode3)) {
24090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
24092 arg3 = static_cast< double >(val3);
24093 ecode4 = SWIG_AsVal_double(obj3, &val4);
24094 if (!SWIG_IsOK(ecode4)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vector" "', argument " "4"" of type '" "double""'");
24097 arg4 = static_cast< double >(val4);
24098 result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3,arg4);
24099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
24106 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 PyObject *resultobj = 0;
24108 Hex::Document *arg1 = (Hex::Document *) 0 ;
24117 PyObject * obj0 = 0 ;
24118 PyObject * obj1 = 0 ;
24119 PyObject * obj2 = 0 ;
24120 Hex::Vector *result = 0 ;
24122 if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
24123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24127 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24128 ecode2 = SWIG_AsVal_double(obj1, &val2);
24129 if (!SWIG_IsOK(ecode2)) {
24130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24132 arg2 = static_cast< double >(val2);
24133 ecode3 = SWIG_AsVal_double(obj2, &val3);
24134 if (!SWIG_IsOK(ecode3)) {
24135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
24137 arg3 = static_cast< double >(val3);
24138 result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3);
24139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
24146 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24147 PyObject *resultobj = 0;
24148 Hex::Document *arg1 = (Hex::Document *) 0 ;
24154 PyObject * obj0 = 0 ;
24155 PyObject * obj1 = 0 ;
24156 Hex::Vector *result = 0 ;
24158 if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
24159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24160 if (!SWIG_IsOK(res1)) {
24161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24163 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24164 ecode2 = SWIG_AsVal_double(obj1, &val2);
24165 if (!SWIG_IsOK(ecode2)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24168 arg2 = static_cast< double >(val2);
24169 result = (Hex::Vector *)new Hex::Vector(arg1,arg2);
24170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
24177 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24178 PyObject *resultobj = 0;
24179 Hex::Document *arg1 = (Hex::Document *) 0 ;
24182 PyObject * obj0 = 0 ;
24183 Hex::Vector *result = 0 ;
24185 if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
24186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24187 if (!SWIG_IsOK(res1)) {
24188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24190 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24191 result = (Hex::Vector *)new Hex::Vector(arg1);
24192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW | 0 );
24199 SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
24201 PyObject *argv[5] = {
24206 if (!PyTuple_Check(args)) SWIG_fail;
24207 argc = args ? PyObject_Length(args) : 0;
24208 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
24209 argv[ii] = PyTuple_GET_ITEM(args,ii);
24214 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24215 _v = SWIG_CheckState(res);
24217 return _wrap_new_Vector__SWIG_3(self, args);
24223 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24224 _v = SWIG_CheckState(res);
24227 int res = SWIG_AsVal_double(argv[1], NULL);
24228 _v = SWIG_CheckState(res);
24231 return _wrap_new_Vector__SWIG_2(self, args);
24238 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24239 _v = SWIG_CheckState(res);
24242 int res = SWIG_AsVal_double(argv[1], NULL);
24243 _v = SWIG_CheckState(res);
24247 int res = SWIG_AsVal_double(argv[2], NULL);
24248 _v = SWIG_CheckState(res);
24251 return _wrap_new_Vector__SWIG_1(self, args);
24259 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24260 _v = SWIG_CheckState(res);
24263 int res = SWIG_AsVal_double(argv[1], NULL);
24264 _v = SWIG_CheckState(res);
24268 int res = SWIG_AsVal_double(argv[2], NULL);
24269 _v = SWIG_CheckState(res);
24273 int res = SWIG_AsVal_double(argv[3], NULL);
24274 _v = SWIG_CheckState(res);
24277 return _wrap_new_Vector__SWIG_0(self, args);
24285 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Vector'.\n"
24286 " Possible C/C++ prototypes are:\n"
24287 " Hex::Vector::Vector(Hex::Document *,double,double,double)\n"
24288 " Hex::Vector::Vector(Hex::Document *,double,double)\n"
24289 " Hex::Vector::Vector(Hex::Document *,double)\n"
24290 " Hex::Vector::Vector(Hex::Document *)\n");
24295 SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24296 PyObject *resultobj = 0;
24297 Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24300 PyObject * obj0 = 0 ;
24302 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vector",&obj0)) SWIG_fail;
24303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, SWIG_POINTER_DISOWN | 0 );
24304 if (!SWIG_IsOK(res1)) {
24305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "Hex::Vector *""'");
24307 arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24309 resultobj = SWIG_Py_Void();
24316 SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24318 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
24319 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
24320 return SWIG_Py_Void();
24323 SWIGINTERN PyObject *_wrap_new_Document__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *resultobj = 0;
24325 cpchar arg1 = (cpchar) 0 ;
24326 Hex::Hex *arg2 = (Hex::Hex *) 0 ;
24332 PyObject * obj0 = 0 ;
24333 PyObject * obj1 = 0 ;
24334 Hex::Document *result = 0 ;
24336 if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
24337 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
24338 if (!SWIG_IsOK(res1)) {
24339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
24341 arg1 = reinterpret_cast< cpchar >(buf1);
24342 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hex, 0 | 0 );
24343 if (!SWIG_IsOK(res2)) {
24344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Document" "', argument " "2"" of type '" "Hex::Hex *""'");
24346 arg2 = reinterpret_cast< Hex::Hex * >(argp2);
24347 result = (Hex::Document *)new Hex::Document(arg1,arg2);
24348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW | 0 );
24349 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24352 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24357 SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24358 PyObject *resultobj = 0;
24359 cpchar arg1 = (cpchar) 0 ;
24363 PyObject * obj0 = 0 ;
24364 Hex::Document *result = 0 ;
24366 if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
24367 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
24368 if (!SWIG_IsOK(res1)) {
24369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
24371 arg1 = reinterpret_cast< cpchar >(buf1);
24372 result = (Hex::Document *)new Hex::Document(arg1);
24373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW | 0 );
24374 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24377 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24382 SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
24384 PyObject *argv[3] = {
24389 if (!PyTuple_Check(args)) SWIG_fail;
24390 argc = args ? PyObject_Length(args) : 0;
24391 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24392 argv[ii] = PyTuple_GET_ITEM(args,ii);
24396 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
24397 _v = SWIG_CheckState(res);
24399 return _wrap_new_Document__SWIG_1(self, args);
24404 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
24405 _v = SWIG_CheckState(res);
24408 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hex, 0);
24409 _v = SWIG_CheckState(res);
24411 return _wrap_new_Document__SWIG_0(self, args);
24417 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Document'.\n"
24418 " Possible C/C++ prototypes are:\n"
24419 " Hex::Document::Document(cpchar,Hex::Hex *)\n"
24420 " Hex::Document::Document(cpchar)\n");
24425 SWIGINTERN PyObject *_wrap_Document_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24426 PyObject *resultobj = 0;
24427 Hex::Document *arg1 = (Hex::Document *) 0 ;
24430 PyObject * obj0 = 0 ;
24432 if (!PyArg_ParseTuple(args,(char *)"O:Document_dump",&obj0)) SWIG_fail;
24433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24434 if (!SWIG_IsOK(res1)) {
24435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_dump" "', argument " "1"" of type '" "Hex::Document *""'");
24437 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24439 resultobj = SWIG_Py_Void();
24446 SWIGINTERN PyObject *_wrap_Document_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *resultobj = 0;
24448 Hex::Document *arg1 = (Hex::Document *) 0 ;
24449 char *arg2 = (char *) 0 ;
24455 PyObject * obj0 = 0 ;
24456 PyObject * obj1 = 0 ;
24459 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
24460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24461 if (!SWIG_IsOK(res1)) {
24462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setName" "', argument " "1"" of type '" "Hex::Document *""'");
24464 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24465 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24466 if (!SWIG_IsOK(res2)) {
24467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_setName" "', argument " "2"" of type '" "char const *""'");
24469 arg2 = reinterpret_cast< char * >(buf2);
24470 result = (int)(arg1)->setName((char const *)arg2);
24471 resultobj = SWIG_From_int(static_cast< int >(result));
24472 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24475 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24480 SWIGINTERN PyObject *_wrap_Document_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24481 PyObject *resultobj = 0;
24482 Hex::Document *arg1 = (Hex::Document *) 0 ;
24488 PyObject * obj0 = 0 ;
24489 PyObject * obj1 = 0 ;
24491 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setLevel",&obj0,&obj1)) SWIG_fail;
24492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24493 if (!SWIG_IsOK(res1)) {
24494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setLevel" "', argument " "1"" of type '" "Hex::Document *""'");
24496 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24497 ecode2 = SWIG_AsVal_int(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setLevel" "', argument " "2"" of type '" "int""'");
24501 arg2 = static_cast< int >(val2);
24502 (arg1)->setLevel(arg2);
24503 resultobj = SWIG_Py_Void();
24510 SWIGINTERN PyObject *_wrap_Document_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24511 PyObject *resultobj = 0;
24512 Hex::Document *arg1 = (Hex::Document *) 0 ;
24513 char *arg2 = (char *) 0 ;
24519 PyObject * obj0 = 0 ;
24520 PyObject * obj1 = 0 ;
24523 if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
24524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24525 if (!SWIG_IsOK(res1)) {
24526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_save" "', argument " "1"" of type '" "Hex::Document *""'");
24528 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24529 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24530 if (!SWIG_IsOK(res2)) {
24531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_save" "', argument " "2"" of type '" "char const *""'");
24533 arg2 = reinterpret_cast< char * >(buf2);
24534 result = (int)(arg1)->save((char const *)arg2);
24535 resultobj = SWIG_From_int(static_cast< int >(result));
24536 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24539 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24544 SWIGINTERN PyObject *_wrap_Document_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 Hex::Document *arg1 = (Hex::Document *) 0 ;
24547 cpchar arg2 = (cpchar) 0 ;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24557 if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
24558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24559 if (!SWIG_IsOK(res1)) {
24560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_saveVtk" "', argument " "1"" of type '" "Hex::Document *""'");
24562 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24563 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24564 if (!SWIG_IsOK(res2)) {
24565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_saveVtk" "', argument " "2"" of type '" "cpchar""'");
24567 arg2 = reinterpret_cast< cpchar >(buf2);
24568 result = (int)(arg1)->saveVtk(arg2);
24569 resultobj = SWIG_From_int(static_cast< int >(result));
24570 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24573 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24578 SWIGINTERN PyObject *_wrap_Document_purge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24579 PyObject *resultobj = 0;
24580 Hex::Document *arg1 = (Hex::Document *) 0 ;
24583 PyObject * obj0 = 0 ;
24585 if (!PyArg_ParseTuple(args,(char *)"O:Document_purge",&obj0)) SWIG_fail;
24586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24587 if (!SWIG_IsOK(res1)) {
24588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_purge" "', argument " "1"" of type '" "Hex::Document *""'");
24590 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24592 resultobj = SWIG_Py_Void();
24599 SWIGINTERN PyObject *_wrap_Document_setTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 Hex::Document *arg1 = (Hex::Document *) 0 ;
24607 PyObject * obj0 = 0 ;
24608 PyObject * obj1 = 0 ;
24610 if (!PyArg_ParseTuple(args,(char *)"OO:Document_setTolerance",&obj0,&obj1)) SWIG_fail;
24611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24612 if (!SWIG_IsOK(res1)) {
24613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
24615 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24616 ecode2 = SWIG_AsVal_double(obj1, &val2);
24617 if (!SWIG_IsOK(ecode2)) {
24618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setTolerance" "', argument " "2"" of type '" "double""'");
24620 arg2 = static_cast< double >(val2);
24621 (arg1)->setTolerance(arg2);
24622 resultobj = SWIG_Py_Void();
24629 SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *resultobj = 0;
24631 Hex::Document *arg1 = (Hex::Document *) 0 ;
24634 PyObject * obj0 = 0 ;
24637 if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
24638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
24642 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24643 result = (double)(arg1)->getTolerance();
24644 resultobj = SWIG_From_double(static_cast< double >(result));
24651 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24652 PyObject *resultobj = 0;
24653 Hex::Document *arg1 = (Hex::Document *) 0 ;
24665 PyObject * obj0 = 0 ;
24666 PyObject * obj1 = 0 ;
24667 PyObject * obj2 = 0 ;
24668 PyObject * obj3 = 0 ;
24669 Hex::Vertex *result = 0 ;
24671 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24676 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24677 ecode2 = SWIG_AsVal_double(obj1, &val2);
24678 if (!SWIG_IsOK(ecode2)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24681 arg2 = static_cast< double >(val2);
24682 ecode3 = SWIG_AsVal_double(obj2, &val3);
24683 if (!SWIG_IsOK(ecode3)) {
24684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
24686 arg3 = static_cast< double >(val3);
24687 ecode4 = SWIG_AsVal_double(obj3, &val4);
24688 if (!SWIG_IsOK(ecode4)) {
24689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVertex" "', argument " "4"" of type '" "double""'");
24691 arg4 = static_cast< double >(val4);
24692 result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3,arg4);
24693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24700 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24701 PyObject *resultobj = 0;
24702 Hex::Document *arg1 = (Hex::Document *) 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 PyObject * obj2 = 0 ;
24714 Hex::Vertex *result = 0 ;
24716 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
24717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24721 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24722 ecode2 = SWIG_AsVal_double(obj1, &val2);
24723 if (!SWIG_IsOK(ecode2)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24726 arg2 = static_cast< double >(val2);
24727 ecode3 = SWIG_AsVal_double(obj2, &val3);
24728 if (!SWIG_IsOK(ecode3)) {
24729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
24731 arg3 = static_cast< double >(val3);
24732 result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3);
24733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24740 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24741 PyObject *resultobj = 0;
24742 Hex::Document *arg1 = (Hex::Document *) 0 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 Hex::Vertex *result = 0 ;
24752 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
24753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24754 if (!SWIG_IsOK(res1)) {
24755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24757 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24758 ecode2 = SWIG_AsVal_double(obj1, &val2);
24759 if (!SWIG_IsOK(ecode2)) {
24760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24762 arg2 = static_cast< double >(val2);
24763 result = (Hex::Vertex *)(arg1)->addVertex(arg2);
24764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24771 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24772 PyObject *resultobj = 0;
24773 Hex::Document *arg1 = (Hex::Document *) 0 ;
24776 PyObject * obj0 = 0 ;
24777 Hex::Vertex *result = 0 ;
24779 if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
24780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24781 if (!SWIG_IsOK(res1)) {
24782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24784 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24785 result = (Hex::Vertex *)(arg1)->addVertex();
24786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24793 SWIGINTERN PyObject *_wrap_Document_addVertex(PyObject *self, PyObject *args) {
24795 PyObject *argv[5] = {
24800 if (!PyTuple_Check(args)) SWIG_fail;
24801 argc = args ? PyObject_Length(args) : 0;
24802 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
24803 argv[ii] = PyTuple_GET_ITEM(args,ii);
24808 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24809 _v = SWIG_CheckState(res);
24811 return _wrap_Document_addVertex__SWIG_3(self, args);
24817 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24818 _v = SWIG_CheckState(res);
24821 int res = SWIG_AsVal_double(argv[1], NULL);
24822 _v = SWIG_CheckState(res);
24825 return _wrap_Document_addVertex__SWIG_2(self, args);
24832 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24833 _v = SWIG_CheckState(res);
24836 int res = SWIG_AsVal_double(argv[1], NULL);
24837 _v = SWIG_CheckState(res);
24841 int res = SWIG_AsVal_double(argv[2], NULL);
24842 _v = SWIG_CheckState(res);
24845 return _wrap_Document_addVertex__SWIG_1(self, args);
24853 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24854 _v = SWIG_CheckState(res);
24857 int res = SWIG_AsVal_double(argv[1], NULL);
24858 _v = SWIG_CheckState(res);
24862 int res = SWIG_AsVal_double(argv[2], NULL);
24863 _v = SWIG_CheckState(res);
24867 int res = SWIG_AsVal_double(argv[3], NULL);
24868 _v = SWIG_CheckState(res);
24871 return _wrap_Document_addVertex__SWIG_0(self, args);
24879 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addVertex'.\n"
24880 " Possible C/C++ prototypes are:\n"
24881 " Hex::Document::addVertex(double,double,double)\n"
24882 " Hex::Document::addVertex(double,double)\n"
24883 " Hex::Document::addVertex(double)\n"
24884 " Hex::Document::addVertex()\n");
24889 SWIGINTERN PyObject *_wrap_Document_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 Hex::Document *arg1 = (Hex::Document *) 0 ;
24892 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24893 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 PyObject * obj2 = 0 ;
24903 Hex::Edge *result = 0 ;
24905 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24910 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24912 if (!SWIG_IsOK(res2)) {
24913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
24915 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24916 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24917 if (!SWIG_IsOK(res3)) {
24918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
24920 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24921 result = (Hex::Edge *)(arg1)->addEdge(arg2,arg3);
24922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
24929 SWIGINTERN PyObject *_wrap_Document_addEdgeVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24930 PyObject *resultobj = 0;
24931 Hex::Document *arg1 = (Hex::Document *) 0 ;
24932 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24933 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 PyObject * obj2 = 0 ;
24943 Hex::Edge *result = 0 ;
24945 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
24946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeVector" "', argument " "1"" of type '" "Hex::Document *""'");
24950 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
24952 if (!SWIG_IsOK(res2)) {
24953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeVector" "', argument " "2"" of type '" "Hex::Vertex *""'");
24955 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24956 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
24957 if (!SWIG_IsOK(res3)) {
24958 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdgeVector" "', argument " "3"" of type '" "Hex::Vector *""'");
24960 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
24961 result = (Hex::Edge *)(arg1)->addEdgeVector(arg2,arg3);
24962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
24969 SWIGINTERN PyObject *_wrap_Document_addQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 PyObject *resultobj = 0;
24971 Hex::Document *arg1 = (Hex::Document *) 0 ;
24972 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24973 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24974 Hex::Edge *arg4 = (Hex::Edge *) 0 ;
24975 Hex::Edge *arg5 = (Hex::Edge *) 0 ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 PyObject * obj2 = 0 ;
24989 PyObject * obj3 = 0 ;
24990 PyObject * obj4 = 0 ;
24991 Hex::Quad *result = 0 ;
24993 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
24995 if (!SWIG_IsOK(res1)) {
24996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24998 arg1 = reinterpret_cast< Hex::Document * >(argp1);
24999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
25000 if (!SWIG_IsOK(res2)) {
25001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
25003 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
25004 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
25005 if (!SWIG_IsOK(res3)) {
25006 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
25008 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
25009 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 | 0 );
25010 if (!SWIG_IsOK(res4)) {
25011 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuad" "', argument " "4"" of type '" "Hex::Edge *""'");
25013 arg4 = reinterpret_cast< Hex::Edge * >(argp4);
25014 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Edge, 0 | 0 );
25015 if (!SWIG_IsOK(res5)) {
25016 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuad" "', argument " "5"" of type '" "Hex::Edge *""'");
25018 arg5 = reinterpret_cast< Hex::Edge * >(argp5);
25019 result = (Hex::Quad *)(arg1)->addQuad(arg2,arg3,arg4,arg5);
25020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
25027 SWIGINTERN PyObject *_wrap_Document_addQuadVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25028 PyObject *resultobj = 0;
25029 Hex::Document *arg1 = (Hex::Document *) 0 ;
25030 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25031 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25032 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
25033 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
25044 PyObject * obj0 = 0 ;
25045 PyObject * obj1 = 0 ;
25046 PyObject * obj2 = 0 ;
25047 PyObject * obj3 = 0 ;
25048 PyObject * obj4 = 0 ;
25049 Hex::Quad *result = 0 ;
25051 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25053 if (!SWIG_IsOK(res1)) {
25054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25056 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25058 if (!SWIG_IsOK(res2)) {
25059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25061 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25062 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25063 if (!SWIG_IsOK(res3)) {
25064 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuadVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25066 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25067 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25068 if (!SWIG_IsOK(res4)) {
25069 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuadVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
25071 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
25072 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25073 if (!SWIG_IsOK(res5)) {
25074 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuadVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
25076 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
25077 result = (Hex::Quad *)(arg1)->addQuadVertices(arg2,arg3,arg4,arg5);
25078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
25085 SWIGINTERN PyObject *_wrap_Document_addHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086 PyObject *resultobj = 0;
25087 Hex::Document *arg1 = (Hex::Document *) 0 ;
25088 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25089 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25090 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25091 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25092 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
25093 Hex::Quad *arg7 = (Hex::Quad *) 0 ;
25108 PyObject * obj0 = 0 ;
25109 PyObject * obj1 = 0 ;
25110 PyObject * obj2 = 0 ;
25111 PyObject * obj3 = 0 ;
25112 PyObject * obj4 = 0 ;
25113 PyObject * obj5 = 0 ;
25114 PyObject * obj6 = 0 ;
25115 Hex::Hexa *result = 0 ;
25117 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25122 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25124 if (!SWIG_IsOK(res2)) {
25125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa" "', argument " "2"" of type '" "Hex::Quad *""'");
25127 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25128 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25129 if (!SWIG_IsOK(res3)) {
25130 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa" "', argument " "3"" of type '" "Hex::Quad *""'");
25132 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25133 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25134 if (!SWIG_IsOK(res4)) {
25135 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa" "', argument " "4"" of type '" "Hex::Quad *""'");
25137 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25138 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25139 if (!SWIG_IsOK(res5)) {
25140 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa" "', argument " "5"" of type '" "Hex::Quad *""'");
25142 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25143 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25144 if (!SWIG_IsOK(res6)) {
25145 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa" "', argument " "6"" of type '" "Hex::Quad *""'");
25147 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
25148 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25149 if (!SWIG_IsOK(res7)) {
25150 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexa" "', argument " "7"" of type '" "Hex::Quad *""'");
25152 arg7 = reinterpret_cast< Hex::Quad * >(argp7);
25153 result = (Hex::Hexa *)(arg1)->addHexa(arg2,arg3,arg4,arg5,arg6,arg7);
25154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25161 SWIGINTERN PyObject *_wrap_Document_addHexaVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25162 PyObject *resultobj = 0;
25163 Hex::Document *arg1 = (Hex::Document *) 0 ;
25164 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25165 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25166 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
25167 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
25168 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
25169 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
25170 Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
25171 Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
25190 PyObject * obj0 = 0 ;
25191 PyObject * obj1 = 0 ;
25192 PyObject * obj2 = 0 ;
25193 PyObject * obj3 = 0 ;
25194 PyObject * obj4 = 0 ;
25195 PyObject * obj5 = 0 ;
25196 PyObject * obj6 = 0 ;
25197 PyObject * obj7 = 0 ;
25198 PyObject * obj8 = 0 ;
25199 Hex::Hexa *result = 0 ;
25201 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
25202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25206 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25208 if (!SWIG_IsOK(res2)) {
25209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25211 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25212 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25213 if (!SWIG_IsOK(res3)) {
25214 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexaVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25216 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25217 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25218 if (!SWIG_IsOK(res4)) {
25219 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexaVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
25221 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
25222 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25223 if (!SWIG_IsOK(res5)) {
25224 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexaVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
25226 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
25227 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25228 if (!SWIG_IsOK(res6)) {
25229 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexaVertices" "', argument " "6"" of type '" "Hex::Vertex *""'");
25231 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
25232 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25233 if (!SWIG_IsOK(res7)) {
25234 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexaVertices" "', argument " "7"" of type '" "Hex::Vertex *""'");
25236 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
25237 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25238 if (!SWIG_IsOK(res8)) {
25239 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_addHexaVertices" "', argument " "8"" of type '" "Hex::Vertex *""'");
25241 arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
25242 res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25243 if (!SWIG_IsOK(res9)) {
25244 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_addHexaVertices" "', argument " "9"" of type '" "Hex::Vertex *""'");
25246 arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
25247 result = (Hex::Hexa *)(arg1)->addHexaVertices(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
25248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25255 SWIGINTERN PyObject *_wrap_Document_addHexa2Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25256 PyObject *resultobj = 0;
25257 Hex::Document *arg1 = (Hex::Document *) 0 ;
25258 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25259 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25266 PyObject * obj0 = 0 ;
25267 PyObject * obj1 = 0 ;
25268 PyObject * obj2 = 0 ;
25269 Hex::Hexa *result = 0 ;
25271 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
25272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa2Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25276 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25278 if (!SWIG_IsOK(res2)) {
25279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa2Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25281 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25282 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25283 if (!SWIG_IsOK(res3)) {
25284 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa2Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25286 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25287 result = (Hex::Hexa *)(arg1)->addHexa2Quads(arg2,arg3);
25288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25295 SWIGINTERN PyObject *_wrap_Document_addHexa3Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 Hex::Document *arg1 = (Hex::Document *) 0 ;
25298 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25299 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25300 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25309 PyObject * obj0 = 0 ;
25310 PyObject * obj1 = 0 ;
25311 PyObject * obj2 = 0 ;
25312 PyObject * obj3 = 0 ;
25313 Hex::Hexa *result = 0 ;
25315 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa3Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25320 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25322 if (!SWIG_IsOK(res2)) {
25323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa3Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25325 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25326 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25327 if (!SWIG_IsOK(res3)) {
25328 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa3Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25330 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25331 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25332 if (!SWIG_IsOK(res4)) {
25333 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa3Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25335 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25336 result = (Hex::Hexa *)(arg1)->addHexa3Quads(arg2,arg3,arg4);
25337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25344 SWIGINTERN PyObject *_wrap_Document_addHexa4Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345 PyObject *resultobj = 0;
25346 Hex::Document *arg1 = (Hex::Document *) 0 ;
25347 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25348 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25349 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25350 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25361 PyObject * obj0 = 0 ;
25362 PyObject * obj1 = 0 ;
25363 PyObject * obj2 = 0 ;
25364 PyObject * obj3 = 0 ;
25365 PyObject * obj4 = 0 ;
25366 Hex::Hexa *result = 0 ;
25368 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25370 if (!SWIG_IsOK(res1)) {
25371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa4Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25373 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25375 if (!SWIG_IsOK(res2)) {
25376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa4Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25378 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25379 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25380 if (!SWIG_IsOK(res3)) {
25381 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa4Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25383 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25384 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25385 if (!SWIG_IsOK(res4)) {
25386 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa4Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25388 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25389 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25390 if (!SWIG_IsOK(res5)) {
25391 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa4Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
25393 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25394 result = (Hex::Hexa *)(arg1)->addHexa4Quads(arg2,arg3,arg4,arg5);
25395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25402 SWIGINTERN PyObject *_wrap_Document_addHexa5Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 PyObject *resultobj = 0;
25404 Hex::Document *arg1 = (Hex::Document *) 0 ;
25405 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25406 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25407 Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25408 Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25409 Hex::Quad *arg6 = (Hex::Quad *) 0 ;
25422 PyObject * obj0 = 0 ;
25423 PyObject * obj1 = 0 ;
25424 PyObject * obj2 = 0 ;
25425 PyObject * obj3 = 0 ;
25426 PyObject * obj4 = 0 ;
25427 PyObject * obj5 = 0 ;
25428 Hex::Hexa *result = 0 ;
25430 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
25431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25432 if (!SWIG_IsOK(res1)) {
25433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa5Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25435 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25437 if (!SWIG_IsOK(res2)) {
25438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa5Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25440 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25441 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25442 if (!SWIG_IsOK(res3)) {
25443 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa5Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25445 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25446 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25447 if (!SWIG_IsOK(res4)) {
25448 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa5Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25450 arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25451 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25452 if (!SWIG_IsOK(res5)) {
25453 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa5Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
25455 arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25456 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 | 0 );
25457 if (!SWIG_IsOK(res6)) {
25458 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa5Quads" "', argument " "6"" of type '" "Hex::Quad *""'");
25460 arg6 = reinterpret_cast< Hex::Quad * >(argp6);
25461 result = (Hex::Hexa *)(arg1)->addHexa5Quads(arg2,arg3,arg4,arg5,arg6);
25462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
25469 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470 PyObject *resultobj = 0;
25471 Hex::Document *arg1 = (Hex::Document *) 0 ;
25483 PyObject * obj0 = 0 ;
25484 PyObject * obj1 = 0 ;
25485 PyObject * obj2 = 0 ;
25486 PyObject * obj3 = 0 ;
25487 Hex::Vector *result = 0 ;
25489 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25494 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25495 ecode2 = SWIG_AsVal_double(obj1, &val2);
25496 if (!SWIG_IsOK(ecode2)) {
25497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25499 arg2 = static_cast< double >(val2);
25500 ecode3 = SWIG_AsVal_double(obj2, &val3);
25501 if (!SWIG_IsOK(ecode3)) {
25502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
25504 arg3 = static_cast< double >(val3);
25505 ecode4 = SWIG_AsVal_double(obj3, &val4);
25506 if (!SWIG_IsOK(ecode4)) {
25507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVector" "', argument " "4"" of type '" "double""'");
25509 arg4 = static_cast< double >(val4);
25510 result = (Hex::Vector *)(arg1)->addVector(arg2,arg3,arg4);
25511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
25518 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 PyObject *resultobj = 0;
25520 Hex::Document *arg1 = (Hex::Document *) 0 ;
25529 PyObject * obj0 = 0 ;
25530 PyObject * obj1 = 0 ;
25531 PyObject * obj2 = 0 ;
25532 Hex::Vector *result = 0 ;
25534 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
25535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25539 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25540 ecode2 = SWIG_AsVal_double(obj1, &val2);
25541 if (!SWIG_IsOK(ecode2)) {
25542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25544 arg2 = static_cast< double >(val2);
25545 ecode3 = SWIG_AsVal_double(obj2, &val3);
25546 if (!SWIG_IsOK(ecode3)) {
25547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
25549 arg3 = static_cast< double >(val3);
25550 result = (Hex::Vector *)(arg1)->addVector(arg2,arg3);
25551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
25558 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *resultobj = 0;
25560 Hex::Document *arg1 = (Hex::Document *) 0 ;
25566 PyObject * obj0 = 0 ;
25567 PyObject * obj1 = 0 ;
25568 Hex::Vector *result = 0 ;
25570 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
25571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25575 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25576 ecode2 = SWIG_AsVal_double(obj1, &val2);
25577 if (!SWIG_IsOK(ecode2)) {
25578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25580 arg2 = static_cast< double >(val2);
25581 result = (Hex::Vector *)(arg1)->addVector(arg2);
25582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
25589 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 Hex::Document *arg1 = (Hex::Document *) 0 ;
25594 PyObject * obj0 = 0 ;
25595 Hex::Vector *result = 0 ;
25597 if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
25598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25602 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25603 result = (Hex::Vector *)(arg1)->addVector();
25604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
25611 SWIGINTERN PyObject *_wrap_Document_addVector(PyObject *self, PyObject *args) {
25613 PyObject *argv[5] = {
25618 if (!PyTuple_Check(args)) SWIG_fail;
25619 argc = args ? PyObject_Length(args) : 0;
25620 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
25621 argv[ii] = PyTuple_GET_ITEM(args,ii);
25626 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25627 _v = SWIG_CheckState(res);
25629 return _wrap_Document_addVector__SWIG_3(self, args);
25635 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25636 _v = SWIG_CheckState(res);
25639 int res = SWIG_AsVal_double(argv[1], NULL);
25640 _v = SWIG_CheckState(res);
25643 return _wrap_Document_addVector__SWIG_2(self, args);
25650 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25651 _v = SWIG_CheckState(res);
25654 int res = SWIG_AsVal_double(argv[1], NULL);
25655 _v = SWIG_CheckState(res);
25659 int res = SWIG_AsVal_double(argv[2], NULL);
25660 _v = SWIG_CheckState(res);
25663 return _wrap_Document_addVector__SWIG_1(self, args);
25671 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25672 _v = SWIG_CheckState(res);
25675 int res = SWIG_AsVal_double(argv[1], NULL);
25676 _v = SWIG_CheckState(res);
25680 int res = SWIG_AsVal_double(argv[2], NULL);
25681 _v = SWIG_CheckState(res);
25685 int res = SWIG_AsVal_double(argv[3], NULL);
25686 _v = SWIG_CheckState(res);
25689 return _wrap_Document_addVector__SWIG_0(self, args);
25697 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addVector'.\n"
25698 " Possible C/C++ prototypes are:\n"
25699 " Hex::Document::addVector(double,double,double)\n"
25700 " Hex::Document::addVector(double,double)\n"
25701 " Hex::Document::addVector(double)\n"
25702 " Hex::Document::addVector()\n");
25707 SWIGINTERN PyObject *_wrap_Document_addVectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708 PyObject *resultobj = 0;
25709 Hex::Document *arg1 = (Hex::Document *) 0 ;
25710 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25711 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25718 PyObject * obj0 = 0 ;
25719 PyObject * obj1 = 0 ;
25720 PyObject * obj2 = 0 ;
25721 Hex::Vector *result = 0 ;
25723 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
25724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25725 if (!SWIG_IsOK(res1)) {
25726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVectorVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25728 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25730 if (!SWIG_IsOK(res2)) {
25731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVectorVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25733 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25734 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
25735 if (!SWIG_IsOK(res3)) {
25736 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addVectorVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25738 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25739 result = (Hex::Vector *)(arg1)->addVectorVertices(arg2,arg3);
25740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
25747 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25748 PyObject *resultobj = 0;
25749 Hex::Document *arg1 = (Hex::Document *) 0 ;
25750 char *arg2 = (char *) 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 PyObject * obj2 = 0 ;
25762 Hex::Law *result = 0 ;
25764 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
25765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25766 if (!SWIG_IsOK(res1)) {
25767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25769 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25770 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25771 if (!SWIG_IsOK(res2)) {
25772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "char const *""'");
25774 arg2 = reinterpret_cast< char * >(buf2);
25775 ecode3 = SWIG_AsVal_int(obj2, &val3);
25776 if (!SWIG_IsOK(ecode3)) {
25777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaw" "', argument " "3"" of type '" "int""'");
25779 arg3 = static_cast< int >(val3);
25780 result = (Hex::Law *)(arg1)->addLaw((char const *)arg2,arg3);
25781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
25782 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25785 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25790 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25791 PyObject *resultobj = 0;
25792 Hex::Document *arg1 = (Hex::Document *) 0 ;
25801 PyObject * obj0 = 0 ;
25802 PyObject * obj1 = 0 ;
25803 PyObject * obj2 = 0 ;
25806 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
25807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
25811 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25812 ecode2 = SWIG_AsVal_double(obj1, &val2);
25813 if (!SWIG_IsOK(ecode2)) {
25814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
25816 arg2 = static_cast< double >(val2);
25817 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25818 if (!SWIG_IsOK(ecode3)) {
25819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaws" "', argument " "3"" of type '" "bool""'");
25821 arg3 = static_cast< bool >(val3);
25822 result = (int)(arg1)->addLaws(arg2,arg3);
25823 resultobj = SWIG_From_int(static_cast< int >(result));
25830 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831 PyObject *resultobj = 0;
25832 Hex::Document *arg1 = (Hex::Document *) 0 ;
25838 PyObject * obj0 = 0 ;
25839 PyObject * obj1 = 0 ;
25842 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
25847 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25848 ecode2 = SWIG_AsVal_double(obj1, &val2);
25849 if (!SWIG_IsOK(ecode2)) {
25850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
25852 arg2 = static_cast< double >(val2);
25853 result = (int)(arg1)->addLaws(arg2);
25854 resultobj = SWIG_From_int(static_cast< int >(result));
25861 SWIGINTERN PyObject *_wrap_Document_addLaws(PyObject *self, PyObject *args) {
25863 PyObject *argv[4] = {
25868 if (!PyTuple_Check(args)) SWIG_fail;
25869 argc = args ? PyObject_Length(args) : 0;
25870 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
25871 argv[ii] = PyTuple_GET_ITEM(args,ii);
25876 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25877 _v = SWIG_CheckState(res);
25880 int res = SWIG_AsVal_double(argv[1], NULL);
25881 _v = SWIG_CheckState(res);
25884 return _wrap_Document_addLaws__SWIG_1(self, args);
25891 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25892 _v = SWIG_CheckState(res);
25895 int res = SWIG_AsVal_double(argv[1], NULL);
25896 _v = SWIG_CheckState(res);
25900 int res = SWIG_AsVal_bool(argv[2], NULL);
25901 _v = SWIG_CheckState(res);
25904 return _wrap_Document_addLaws__SWIG_0(self, args);
25911 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addLaws'.\n"
25912 " Possible C/C++ prototypes are:\n"
25913 " Hex::Document::addLaws(double,bool)\n"
25914 " Hex::Document::addLaws(double)\n");
25919 SWIGINTERN PyObject *_wrap_Document_addHexaGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920 PyObject *resultobj = 0;
25921 Hex::Document *arg1 = (Hex::Document *) 0 ;
25922 cpchar arg2 = (cpchar) 0 ;
25928 PyObject * obj0 = 0 ;
25929 PyObject * obj1 = 0 ;
25930 Hex::Group *result = 0 ;
25932 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25937 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25938 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25939 if (!SWIG_IsOK(res2)) {
25940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaGroup" "', argument " "2"" of type '" "cpchar""'");
25942 arg2 = reinterpret_cast< cpchar >(buf2);
25943 result = (Hex::Group *)(arg1)->addHexaGroup(arg2);
25944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
25945 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25948 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25953 SWIGINTERN PyObject *_wrap_Document_addQuadGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25954 PyObject *resultobj = 0;
25955 Hex::Document *arg1 = (Hex::Document *) 0 ;
25956 cpchar arg2 = (cpchar) 0 ;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 Hex::Group *result = 0 ;
25966 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
25967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
25968 if (!SWIG_IsOK(res1)) {
25969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25971 arg1 = reinterpret_cast< Hex::Document * >(argp1);
25972 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25973 if (!SWIG_IsOK(res2)) {
25974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadGroup" "', argument " "2"" of type '" "cpchar""'");
25976 arg2 = reinterpret_cast< cpchar >(buf2);
25977 result = (Hex::Group *)(arg1)->addQuadGroup(arg2);
25978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
25979 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25982 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25987 SWIGINTERN PyObject *_wrap_Document_addQuadNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *resultobj = 0;
25989 Hex::Document *arg1 = (Hex::Document *) 0 ;
25990 cpchar arg2 = (cpchar) 0 ;
25996 PyObject * obj0 = 0 ;
25997 PyObject * obj1 = 0 ;
25998 Hex::Group *result = 0 ;
26000 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
26001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26002 if (!SWIG_IsOK(res1)) {
26003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26005 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26006 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26007 if (!SWIG_IsOK(res2)) {
26008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26010 arg2 = reinterpret_cast< cpchar >(buf2);
26011 result = (Hex::Group *)(arg1)->addQuadNodeGroup(arg2);
26012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
26013 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26016 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26021 SWIGINTERN PyObject *_wrap_Document_addHexaNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26022 PyObject *resultobj = 0;
26023 Hex::Document *arg1 = (Hex::Document *) 0 ;
26024 cpchar arg2 = (cpchar) 0 ;
26030 PyObject * obj0 = 0 ;
26031 PyObject * obj1 = 0 ;
26032 Hex::Group *result = 0 ;
26034 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
26035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26036 if (!SWIG_IsOK(res1)) {
26037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26039 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26040 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26041 if (!SWIG_IsOK(res2)) {
26042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26044 arg2 = reinterpret_cast< cpchar >(buf2);
26045 result = (Hex::Group *)(arg1)->addHexaNodeGroup(arg2);
26046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
26047 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26050 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26055 SWIGINTERN PyObject *_wrap_Document_addEdgeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 Hex::Document *arg1 = (Hex::Document *) 0 ;
26058 cpchar arg2 = (cpchar) 0 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 Hex::Group *result = 0 ;
26068 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
26069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26073 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26074 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26075 if (!SWIG_IsOK(res2)) {
26076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeGroup" "', argument " "2"" of type '" "cpchar""'");
26078 arg2 = reinterpret_cast< cpchar >(buf2);
26079 result = (Hex::Group *)(arg1)->addEdgeGroup(arg2);
26080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
26081 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26084 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26089 SWIGINTERN PyObject *_wrap_Document_addEdgeNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26090 PyObject *resultobj = 0;
26091 Hex::Document *arg1 = (Hex::Document *) 0 ;
26092 cpchar arg2 = (cpchar) 0 ;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 Hex::Group *result = 0 ;
26102 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26107 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26108 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26109 if (!SWIG_IsOK(res2)) {
26110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26112 arg2 = reinterpret_cast< cpchar >(buf2);
26113 result = (Hex::Group *)(arg1)->addEdgeNodeGroup(arg2);
26114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
26115 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26118 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26123 SWIGINTERN PyObject *_wrap_Document_addVertexNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 Hex::Document *arg1 = (Hex::Document *) 0 ;
26126 cpchar arg2 = (cpchar) 0 ;
26132 PyObject * obj0 = 0 ;
26133 PyObject * obj1 = 0 ;
26134 Hex::Group *result = 0 ;
26136 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) SWIG_fail;
26137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26138 if (!SWIG_IsOK(res1)) {
26139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertexNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26141 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26142 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26143 if (!SWIG_IsOK(res2)) {
26144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVertexNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26146 arg2 = reinterpret_cast< cpchar >(buf2);
26147 result = (Hex::Group *)(arg1)->addVertexNodeGroup(arg2);
26148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
26149 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26152 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26157 SWIGINTERN PyObject *_wrap_Document_makeTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26158 PyObject *resultobj = 0;
26159 Hex::Document *arg1 = (Hex::Document *) 0 ;
26160 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26161 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 PyObject * obj2 = 0 ;
26171 Hex::Elements *result = 0 ;
26173 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
26174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26175 if (!SWIG_IsOK(res1)) {
26176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
26178 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26180 if (!SWIG_IsOK(res2)) {
26181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
26183 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26184 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26185 if (!SWIG_IsOK(res3)) {
26186 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
26188 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26189 result = (Hex::Elements *)(arg1)->makeTranslation(arg2,arg3);
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26197 SWIGINTERN PyObject *_wrap_Document_makeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198 PyObject *resultobj = 0;
26199 Hex::Document *arg1 = (Hex::Document *) 0 ;
26200 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26201 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26211 PyObject * obj0 = 0 ;
26212 PyObject * obj1 = 0 ;
26213 PyObject * obj2 = 0 ;
26214 PyObject * obj3 = 0 ;
26215 Hex::Elements *result = 0 ;
26217 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeScale" "', argument " "1"" of type '" "Hex::Document *""'");
26222 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26224 if (!SWIG_IsOK(res2)) {
26225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeScale" "', argument " "2"" of type '" "Hex::Elements *""'");
26227 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26228 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26229 if (!SWIG_IsOK(res3)) {
26230 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
26232 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26233 ecode4 = SWIG_AsVal_double(obj3, &val4);
26234 if (!SWIG_IsOK(ecode4)) {
26235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeScale" "', argument " "4"" of type '" "double""'");
26237 arg4 = static_cast< double >(val4);
26238 result = (Hex::Elements *)(arg1)->makeScale(arg2,arg3,arg4);
26239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26246 SWIGINTERN PyObject *_wrap_Document_makeRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26247 PyObject *resultobj = 0;
26248 Hex::Document *arg1 = (Hex::Document *) 0 ;
26249 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26250 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26251 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26263 PyObject * obj0 = 0 ;
26264 PyObject * obj1 = 0 ;
26265 PyObject * obj2 = 0 ;
26266 PyObject * obj3 = 0 ;
26267 PyObject * obj4 = 0 ;
26268 Hex::Elements *result = 0 ;
26270 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRotation" "', argument " "1"" of type '" "Hex::Document *""'");
26275 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26277 if (!SWIG_IsOK(res2)) {
26278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
26280 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26281 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26282 if (!SWIG_IsOK(res3)) {
26283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
26285 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26286 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26287 if (!SWIG_IsOK(res4)) {
26288 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
26290 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26291 ecode5 = SWIG_AsVal_double(obj4, &val5);
26292 if (!SWIG_IsOK(ecode5)) {
26293 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRotation" "', argument " "5"" of type '" "double""'");
26295 arg5 = static_cast< double >(val5);
26296 result = (Hex::Elements *)(arg1)->makeRotation(arg2,arg3,arg4,arg5);
26297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26304 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *resultobj = 0;
26306 Hex::Document *arg1 = (Hex::Document *) 0 ;
26307 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26308 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26315 PyObject * obj0 = 0 ;
26316 PyObject * obj1 = 0 ;
26317 PyObject * obj2 = 0 ;
26318 Hex::Elements *result = 0 ;
26320 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
26325 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26327 if (!SWIG_IsOK(res2)) {
26328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
26330 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26331 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26332 if (!SWIG_IsOK(res3)) {
26333 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
26335 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26336 result = (Hex::Elements *)(arg1)->makeSymmetryPoint(arg2,arg3);
26337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26344 SWIGINTERN PyObject *_wrap_Document_makeSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26345 PyObject *resultobj = 0;
26346 Hex::Document *arg1 = (Hex::Document *) 0 ;
26347 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26348 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26349 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26358 PyObject * obj0 = 0 ;
26359 PyObject * obj1 = 0 ;
26360 PyObject * obj2 = 0 ;
26361 PyObject * obj3 = 0 ;
26362 Hex::Elements *result = 0 ;
26364 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
26369 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26371 if (!SWIG_IsOK(res2)) {
26372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
26374 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26375 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26376 if (!SWIG_IsOK(res3)) {
26377 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
26379 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26380 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26381 if (!SWIG_IsOK(res4)) {
26382 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
26384 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26385 result = (Hex::Elements *)(arg1)->makeSymmetryLine(arg2,arg3,arg4);
26386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26393 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26394 PyObject *resultobj = 0;
26395 Hex::Document *arg1 = (Hex::Document *) 0 ;
26396 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26397 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26398 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26407 PyObject * obj0 = 0 ;
26408 PyObject * obj1 = 0 ;
26409 PyObject * obj2 = 0 ;
26410 PyObject * obj3 = 0 ;
26411 Hex::Elements *result = 0 ;
26413 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26415 if (!SWIG_IsOK(res1)) {
26416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
26418 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26420 if (!SWIG_IsOK(res2)) {
26421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
26423 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26424 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26425 if (!SWIG_IsOK(res3)) {
26426 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
26428 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26429 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26430 if (!SWIG_IsOK(res4)) {
26431 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
26433 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26434 result = (Hex::Elements *)(arg1)->makeSymmetryPlane(arg2,arg3,arg4);
26435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26442 SWIGINTERN PyObject *_wrap_Document_performTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26443 PyObject *resultobj = 0;
26444 Hex::Document *arg1 = (Hex::Document *) 0 ;
26445 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26446 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26453 PyObject * obj0 = 0 ;
26454 PyObject * obj1 = 0 ;
26455 PyObject * obj2 = 0 ;
26458 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
26459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26460 if (!SWIG_IsOK(res1)) {
26461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
26463 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26465 if (!SWIG_IsOK(res2)) {
26466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
26468 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26469 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26470 if (!SWIG_IsOK(res3)) {
26471 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
26473 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26474 result = (int)(arg1)->performTranslation(arg2,arg3);
26475 resultobj = SWIG_From_int(static_cast< int >(result));
26482 SWIGINTERN PyObject *_wrap_Document_performScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483 PyObject *resultobj = 0;
26484 Hex::Document *arg1 = (Hex::Document *) 0 ;
26485 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26486 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26496 PyObject * obj0 = 0 ;
26497 PyObject * obj1 = 0 ;
26498 PyObject * obj2 = 0 ;
26499 PyObject * obj3 = 0 ;
26502 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26504 if (!SWIG_IsOK(res1)) {
26505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performScale" "', argument " "1"" of type '" "Hex::Document *""'");
26507 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26509 if (!SWIG_IsOK(res2)) {
26510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performScale" "', argument " "2"" of type '" "Hex::Elements *""'");
26512 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26513 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26514 if (!SWIG_IsOK(res3)) {
26515 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
26517 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26518 ecode4 = SWIG_AsVal_double(obj3, &val4);
26519 if (!SWIG_IsOK(ecode4)) {
26520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_performScale" "', argument " "4"" of type '" "double""'");
26522 arg4 = static_cast< double >(val4);
26523 result = (int)(arg1)->performScale(arg2,arg3,arg4);
26524 resultobj = SWIG_From_int(static_cast< int >(result));
26531 SWIGINTERN PyObject *_wrap_Document_performRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26532 PyObject *resultobj = 0;
26533 Hex::Document *arg1 = (Hex::Document *) 0 ;
26534 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26535 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26536 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26548 PyObject * obj0 = 0 ;
26549 PyObject * obj1 = 0 ;
26550 PyObject * obj2 = 0 ;
26551 PyObject * obj3 = 0 ;
26552 PyObject * obj4 = 0 ;
26555 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26557 if (!SWIG_IsOK(res1)) {
26558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performRotation" "', argument " "1"" of type '" "Hex::Document *""'");
26560 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26562 if (!SWIG_IsOK(res2)) {
26563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
26565 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26566 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26567 if (!SWIG_IsOK(res3)) {
26568 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
26570 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26571 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26572 if (!SWIG_IsOK(res4)) {
26573 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
26575 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26576 ecode5 = SWIG_AsVal_double(obj4, &val5);
26577 if (!SWIG_IsOK(ecode5)) {
26578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_performRotation" "', argument " "5"" of type '" "double""'");
26580 arg5 = static_cast< double >(val5);
26581 result = (int)(arg1)->performRotation(arg2,arg3,arg4,arg5);
26582 resultobj = SWIG_From_int(static_cast< int >(result));
26589 SWIGINTERN PyObject *_wrap_Document_performSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26590 PyObject *resultobj = 0;
26591 Hex::Document *arg1 = (Hex::Document *) 0 ;
26592 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26593 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26600 PyObject * obj0 = 0 ;
26601 PyObject * obj1 = 0 ;
26602 PyObject * obj2 = 0 ;
26605 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
26606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26607 if (!SWIG_IsOK(res1)) {
26608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
26610 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26612 if (!SWIG_IsOK(res2)) {
26613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
26615 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26616 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26617 if (!SWIG_IsOK(res3)) {
26618 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
26620 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26621 result = (int)(arg1)->performSymmetryPoint(arg2,arg3);
26622 resultobj = SWIG_From_int(static_cast< int >(result));
26629 SWIGINTERN PyObject *_wrap_Document_performSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26630 PyObject *resultobj = 0;
26631 Hex::Document *arg1 = (Hex::Document *) 0 ;
26632 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26633 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26634 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26643 PyObject * obj0 = 0 ;
26644 PyObject * obj1 = 0 ;
26645 PyObject * obj2 = 0 ;
26646 PyObject * obj3 = 0 ;
26649 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26651 if (!SWIG_IsOK(res1)) {
26652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
26654 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26656 if (!SWIG_IsOK(res2)) {
26657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
26659 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26660 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26661 if (!SWIG_IsOK(res3)) {
26662 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
26664 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26665 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26666 if (!SWIG_IsOK(res4)) {
26667 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
26669 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26670 result = (int)(arg1)->performSymmetryLine(arg2,arg3,arg4);
26671 resultobj = SWIG_From_int(static_cast< int >(result));
26678 SWIGINTERN PyObject *_wrap_Document_performSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 PyObject *resultobj = 0;
26680 Hex::Document *arg1 = (Hex::Document *) 0 ;
26681 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26682 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26683 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26692 PyObject * obj0 = 0 ;
26693 PyObject * obj1 = 0 ;
26694 PyObject * obj2 = 0 ;
26695 PyObject * obj3 = 0 ;
26698 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26700 if (!SWIG_IsOK(res1)) {
26701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
26703 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
26705 if (!SWIG_IsOK(res2)) {
26706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
26708 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26709 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26710 if (!SWIG_IsOK(res3)) {
26711 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
26713 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26714 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
26715 if (!SWIG_IsOK(res4)) {
26716 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
26718 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26719 result = (int)(arg1)->performSymmetryPlane(arg2,arg3,arg4);
26720 resultobj = SWIG_From_int(static_cast< int >(result));
26727 SWIGINTERN PyObject *_wrap_Document_disconnectQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26728 PyObject *resultobj = 0;
26729 Hex::Document *arg1 = (Hex::Document *) 0 ;
26730 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26731 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
26738 PyObject * obj0 = 0 ;
26739 PyObject * obj1 = 0 ;
26740 PyObject * obj2 = 0 ;
26741 Hex::Elements *result = 0 ;
26743 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
26744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26745 if (!SWIG_IsOK(res1)) {
26746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectQuad" "', argument " "1"" of type '" "Hex::Document *""'");
26748 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
26750 if (!SWIG_IsOK(res2)) {
26751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectQuad" "', argument " "2"" of type '" "Hex::Hexa *""'");
26753 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26754 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
26755 if (!SWIG_IsOK(res3)) {
26756 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
26758 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
26759 result = (Hex::Elements *)(arg1)->disconnectQuad(arg2,arg3);
26760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26767 SWIGINTERN PyObject *_wrap_Document_disconnectEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26768 PyObject *resultobj = 0;
26769 Hex::Document *arg1 = (Hex::Document *) 0 ;
26770 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26771 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 PyObject * obj2 = 0 ;
26781 Hex::Elements *result = 0 ;
26783 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
26784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26785 if (!SWIG_IsOK(res1)) {
26786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdge" "', argument " "1"" of type '" "Hex::Document *""'");
26788 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
26790 if (!SWIG_IsOK(res2)) {
26791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectEdge" "', argument " "2"" of type '" "Hex::Hexa *""'");
26793 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26794 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
26795 if (!SWIG_IsOK(res3)) {
26796 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
26798 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
26799 result = (Hex::Elements *)(arg1)->disconnectEdge(arg2,arg3);
26800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26807 SWIGINTERN PyObject *_wrap_Document_disconnectVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26808 PyObject *resultobj = 0;
26809 Hex::Document *arg1 = (Hex::Document *) 0 ;
26810 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26811 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26818 PyObject * obj0 = 0 ;
26819 PyObject * obj1 = 0 ;
26820 PyObject * obj2 = 0 ;
26821 Hex::Elements *result = 0 ;
26823 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
26824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26825 if (!SWIG_IsOK(res1)) {
26826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectVertex" "', argument " "1"" of type '" "Hex::Document *""'");
26828 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
26830 if (!SWIG_IsOK(res2)) {
26831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectVertex" "', argument " "2"" of type '" "Hex::Hexa *""'");
26833 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26834 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26835 if (!SWIG_IsOK(res3)) {
26836 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
26838 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26839 result = (Hex::Elements *)(arg1)->disconnectVertex(arg2,arg3);
26840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26847 SWIGINTERN PyObject *_wrap_Document_disconnectEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26848 PyObject *resultobj = 0;
26849 Hex::Document *arg1 = (Hex::Document *) 0 ;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856 PyObject * obj2 = 0 ;
26857 Hex::Elements *result = 0 ;
26859 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdges" "', argument " "1"" of type '" "Hex::Document *""'");
26864 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26866 std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
26867 int res = swig::asptr(obj1, &ptr);
26868 if (!SWIG_IsOK(res) || !ptr) {
26869 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
26872 if (SWIG_IsNewObj(res)) delete ptr;
26875 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
26876 int res = swig::asptr(obj2, &ptr);
26877 if (!SWIG_IsOK(res) || !ptr) {
26878 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
26881 if (SWIG_IsNewObj(res)) delete ptr;
26883 result = (Hex::Elements *)(arg1)->disconnectEdges(arg2,arg3);
26884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26891 SWIGINTERN PyObject *_wrap_Document_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892 PyObject *resultobj = 0;
26893 Hex::Document *arg1 = (Hex::Document *) 0 ;
26896 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
26897 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
26898 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
26899 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 PyObject * obj2 = 0 ;
26913 PyObject * obj3 = 0 ;
26914 PyObject * obj4 = 0 ;
26915 PyObject * obj5 = 0 ;
26916 PyObject * obj6 = 0 ;
26917 Hex::Elements *result = 0 ;
26919 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26921 if (!SWIG_IsOK(res1)) {
26922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
26924 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26926 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
26927 int res = swig::asptr(obj1, &ptr);
26928 if (!SWIG_IsOK(res) || !ptr) {
26929 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
26932 if (SWIG_IsNewObj(res)) delete ptr;
26935 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
26936 int res = swig::asptr(obj2, &ptr);
26937 if (!SWIG_IsOK(res) || !ptr) {
26938 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
26941 if (SWIG_IsNewObj(res)) delete ptr;
26943 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26944 if (!SWIG_IsOK(res4)) {
26945 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
26947 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
26948 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26949 if (!SWIG_IsOK(res5)) {
26950 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_replace" "', argument " "5"" of type '" "Hex::Vertex *""'");
26952 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
26953 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26954 if (!SWIG_IsOK(res6)) {
26955 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_replace" "', argument " "6"" of type '" "Hex::Vertex *""'");
26957 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
26958 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26959 if (!SWIG_IsOK(res7)) {
26960 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
26962 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
26963 result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
26964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
26971 SWIGINTERN PyObject *_wrap_Document_mergeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972 PyObject *resultobj = 0;
26973 Hex::Document *arg1 = (Hex::Document *) 0 ;
26974 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26975 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26982 PyObject * obj0 = 0 ;
26983 PyObject * obj1 = 0 ;
26984 PyObject * obj2 = 0 ;
26987 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
26988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
26989 if (!SWIG_IsOK(res1)) {
26990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeVertices" "', argument " "1"" of type '" "Hex::Document *""'");
26992 arg1 = reinterpret_cast< Hex::Document * >(argp1);
26993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26994 if (!SWIG_IsOK(res2)) {
26995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
26997 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26998 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
26999 if (!SWIG_IsOK(res3)) {
27000 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
27002 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27003 result = (int)(arg1)->mergeVertices(arg2,arg3);
27004 resultobj = SWIG_From_int(static_cast< int >(result));
27011 SWIGINTERN PyObject *_wrap_Document_mergeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27012 PyObject *resultobj = 0;
27013 Hex::Document *arg1 = (Hex::Document *) 0 ;
27014 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
27015 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
27016 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27017 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 PyObject * obj2 = 0 ;
27031 PyObject * obj3 = 0 ;
27032 PyObject * obj4 = 0 ;
27035 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) 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_mergeEdges" "', argument " "1"" of type '" "Hex::Document *""'");
27040 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
27042 if (!SWIG_IsOK(res2)) {
27043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeEdges" "', argument " "2"" of type '" "Hex::Edge *""'");
27045 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
27046 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
27047 if (!SWIG_IsOK(res3)) {
27048 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeEdges" "', argument " "3"" of type '" "Hex::Edge *""'");
27050 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
27051 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27052 if (!SWIG_IsOK(res4)) {
27053 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeEdges" "', argument " "4"" of type '" "Hex::Vertex *""'");
27055 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27056 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27057 if (!SWIG_IsOK(res5)) {
27058 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeEdges" "', argument " "5"" of type '" "Hex::Vertex *""'");
27060 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27061 result = (int)(arg1)->mergeEdges(arg2,arg3,arg4,arg5);
27062 resultobj = SWIG_From_int(static_cast< int >(result));
27069 SWIGINTERN PyObject *_wrap_Document_mergeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27070 PyObject *resultobj = 0;
27071 Hex::Document *arg1 = (Hex::Document *) 0 ;
27072 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27073 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27074 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27075 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27076 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27077 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27092 PyObject * obj0 = 0 ;
27093 PyObject * obj1 = 0 ;
27094 PyObject * obj2 = 0 ;
27095 PyObject * obj3 = 0 ;
27096 PyObject * obj4 = 0 ;
27097 PyObject * obj5 = 0 ;
27098 PyObject * obj6 = 0 ;
27101 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27103 if (!SWIG_IsOK(res1)) {
27104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27106 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27108 if (!SWIG_IsOK(res2)) {
27109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
27111 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27112 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
27113 if (!SWIG_IsOK(res3)) {
27114 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
27116 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27117 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27118 if (!SWIG_IsOK(res4)) {
27119 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
27121 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27122 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27123 if (!SWIG_IsOK(res5)) {
27124 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
27126 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27127 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27128 if (!SWIG_IsOK(res6)) {
27129 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_mergeQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
27131 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27132 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27133 if (!SWIG_IsOK(res7)) {
27134 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_mergeQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
27136 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27137 result = (int)(arg1)->mergeQuads(arg2,arg3,arg4,arg5,arg6,arg7);
27138 resultobj = SWIG_From_int(static_cast< int >(result));
27145 SWIGINTERN PyObject *_wrap_Document_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27146 PyObject *resultobj = 0;
27147 Hex::Document *arg1 = (Hex::Document *) 0 ;
27150 PyObject * obj0 = 0 ;
27152 if (!PyArg_ParseTuple(args,(char *)"O:Document_clearAssociation",&obj0)) SWIG_fail;
27153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27154 if (!SWIG_IsOK(res1)) {
27155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clearAssociation" "', argument " "1"" of type '" "Hex::Document *""'");
27157 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27158 (arg1)->clearAssociation();
27159 resultobj = SWIG_Py_Void();
27166 SWIGINTERN PyObject *_wrap_Document_associateOpenedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167 PyObject *resultobj = 0;
27168 Hex::Document *arg1 = (Hex::Document *) 0 ;
27170 Hex::NewShapes arg3 ;
27171 Hex::IntVector arg4 ;
27180 PyObject * obj0 = 0 ;
27181 PyObject * obj1 = 0 ;
27182 PyObject * obj2 = 0 ;
27183 PyObject * obj3 = 0 ;
27184 PyObject * obj4 = 0 ;
27185 PyObject * obj5 = 0 ;
27188 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27190 if (!SWIG_IsOK(res1)) {
27191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateOpenedLine" "', argument " "1"" of type '" "Hex::Document *""'");
27193 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27195 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
27196 int res = swig::asptr(obj1, &ptr);
27197 if (!SWIG_IsOK(res) || !ptr) {
27198 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
27201 if (SWIG_IsNewObj(res)) delete ptr;
27204 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
27205 int res = swig::asptr(obj2, &ptr);
27206 if (!SWIG_IsOK(res) || !ptr) {
27207 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
27210 if (SWIG_IsNewObj(res)) delete ptr;
27213 std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
27214 int res = swig::asptr(obj3, &ptr);
27215 if (!SWIG_IsOK(res) || !ptr) {
27216 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
27219 if (SWIG_IsNewObj(res)) delete ptr;
27221 ecode5 = SWIG_AsVal_double(obj4, &val5);
27222 if (!SWIG_IsOK(ecode5)) {
27223 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_associateOpenedLine" "', argument " "5"" of type '" "double""'");
27225 arg5 = static_cast< double >(val5);
27226 ecode6 = SWIG_AsVal_double(obj5, &val6);
27227 if (!SWIG_IsOK(ecode6)) {
27228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateOpenedLine" "', argument " "6"" of type '" "double""'");
27230 arg6 = static_cast< double >(val6);
27231 result = (int)(arg1)->associateOpenedLine(arg2,arg3,arg4,arg5,arg6);
27232 resultobj = SWIG_From_int(static_cast< int >(result));
27239 SWIGINTERN PyObject *_wrap_Document_associateClosedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240 PyObject *resultobj = 0;
27241 Hex::Document *arg1 = (Hex::Document *) 0 ;
27242 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27244 Hex::NewShapes arg4 ;
27245 Hex::IntVector arg5 ;
27256 PyObject * obj0 = 0 ;
27257 PyObject * obj1 = 0 ;
27258 PyObject * obj2 = 0 ;
27259 PyObject * obj3 = 0 ;
27260 PyObject * obj4 = 0 ;
27261 PyObject * obj5 = 0 ;
27262 PyObject * obj6 = 0 ;
27265 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_associateClosedLine" "', argument " "1"" of type '" "Hex::Document *""'");
27270 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27272 if (!SWIG_IsOK(res2)) {
27273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_associateClosedLine" "', argument " "2"" of type '" "Hex::Vertex *""'");
27275 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27277 std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
27278 int res = swig::asptr(obj2, &ptr);
27279 if (!SWIG_IsOK(res) || !ptr) {
27280 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
27283 if (SWIG_IsNewObj(res)) delete ptr;
27286 std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
27287 int res = swig::asptr(obj3, &ptr);
27288 if (!SWIG_IsOK(res) || !ptr) {
27289 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
27292 if (SWIG_IsNewObj(res)) delete ptr;
27295 std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
27296 int res = swig::asptr(obj4, &ptr);
27297 if (!SWIG_IsOK(res) || !ptr) {
27298 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
27301 if (SWIG_IsNewObj(res)) delete ptr;
27303 ecode6 = SWIG_AsVal_double(obj5, &val6);
27304 if (!SWIG_IsOK(ecode6)) {
27305 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateClosedLine" "', argument " "6"" of type '" "double""'");
27307 arg6 = static_cast< double >(val6);
27308 ecode7 = SWIG_AsVal_bool(obj6, &val7);
27309 if (!SWIG_IsOK(ecode7)) {
27310 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_associateClosedLine" "', argument " "7"" of type '" "bool""'");
27312 arg7 = static_cast< bool >(val7);
27313 result = (int)(arg1)->associateClosedLine(arg2,arg3,arg4,arg5,arg6,arg7);
27314 resultobj = SWIG_From_int(static_cast< int >(result));
27321 SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27322 PyObject *resultobj = 0;
27323 Hex::Document *arg1 = (Hex::Document *) 0 ;
27326 PyObject * obj0 = 0 ;
27329 if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
27330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27331 if (!SWIG_IsOK(res1)) {
27332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27334 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27335 result = (int)(arg1)->countHexa();
27336 resultobj = SWIG_From_int(static_cast< int >(result));
27343 SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27344 PyObject *resultobj = 0;
27345 Hex::Document *arg1 = (Hex::Document *) 0 ;
27348 PyObject * obj0 = 0 ;
27351 if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
27352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27353 if (!SWIG_IsOK(res1)) {
27354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27356 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27357 result = (int)(arg1)->countQuad();
27358 resultobj = SWIG_From_int(static_cast< int >(result));
27365 SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27366 PyObject *resultobj = 0;
27367 Hex::Document *arg1 = (Hex::Document *) 0 ;
27370 PyObject * obj0 = 0 ;
27373 if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
27374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27378 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27379 result = (int)(arg1)->countEdge();
27380 resultobj = SWIG_From_int(static_cast< int >(result));
27387 SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 PyObject *resultobj = 0;
27389 Hex::Document *arg1 = (Hex::Document *) 0 ;
27392 PyObject * obj0 = 0 ;
27395 if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
27396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27400 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27401 result = (int)(arg1)->countVertex();
27402 resultobj = SWIG_From_int(static_cast< int >(result));
27409 SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410 PyObject *resultobj = 0;
27411 Hex::Document *arg1 = (Hex::Document *) 0 ;
27414 PyObject * obj0 = 0 ;
27417 if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
27418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27419 if (!SWIG_IsOK(res1)) {
27420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVector" "', argument " "1"" of type '" "Hex::Document *""'");
27422 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27423 result = (int)(arg1)->countVector();
27424 resultobj = SWIG_From_int(static_cast< int >(result));
27431 SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27432 PyObject *resultobj = 0;
27433 Hex::Document *arg1 = (Hex::Document *) 0 ;
27436 PyObject * obj0 = 0 ;
27439 if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
27440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27441 if (!SWIG_IsOK(res1)) {
27442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countGroup" "', argument " "1"" of type '" "Hex::Document *""'");
27444 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27445 result = (int)(arg1)->countGroup();
27446 resultobj = SWIG_From_int(static_cast< int >(result));
27453 SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 Hex::Document *arg1 = (Hex::Document *) 0 ;
27458 PyObject * obj0 = 0 ;
27461 if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countLaw" "', argument " "1"" of type '" "Hex::Document *""'");
27466 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27467 result = (int)(arg1)->countLaw();
27468 resultobj = SWIG_From_int(static_cast< int >(result));
27475 SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *resultobj = 0;
27477 Hex::Document *arg1 = (Hex::Document *) 0 ;
27480 PyObject * obj0 = 0 ;
27483 if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
27484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27485 if (!SWIG_IsOK(res1)) {
27486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
27488 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27489 result = (int)(arg1)->countPropagation();
27490 resultobj = SWIG_From_int(static_cast< int >(result));
27497 SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 Hex::Document *arg1 = (Hex::Document *) 0 ;
27502 PyObject * obj0 = 0 ;
27505 if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
27506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countShape" "', argument " "1"" of type '" "Hex::Document *""'");
27510 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27511 result = (int)(arg1)->countShape();
27512 resultobj = SWIG_From_int(static_cast< int >(result));
27519 SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27520 PyObject *resultobj = 0;
27521 Hex::Document *arg1 = (Hex::Document *) 0 ;
27524 PyObject * obj0 = 0 ;
27527 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
27528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27529 if (!SWIG_IsOK(res1)) {
27530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27532 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27533 result = (int)(arg1)->countUsedHexa();
27534 resultobj = SWIG_From_int(static_cast< int >(result));
27541 SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 Hex::Document *arg1 = (Hex::Document *) 0 ;
27546 PyObject * obj0 = 0 ;
27549 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
27550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27551 if (!SWIG_IsOK(res1)) {
27552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27554 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27555 result = (int)(arg1)->countUsedQuad();
27556 resultobj = SWIG_From_int(static_cast< int >(result));
27563 SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27564 PyObject *resultobj = 0;
27565 Hex::Document *arg1 = (Hex::Document *) 0 ;
27568 PyObject * obj0 = 0 ;
27571 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
27572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27573 if (!SWIG_IsOK(res1)) {
27574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27576 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27577 result = (int)(arg1)->countUsedEdge();
27578 resultobj = SWIG_From_int(static_cast< int >(result));
27585 SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586 PyObject *resultobj = 0;
27587 Hex::Document *arg1 = (Hex::Document *) 0 ;
27590 PyObject * obj0 = 0 ;
27593 if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
27594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27595 if (!SWIG_IsOK(res1)) {
27596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27598 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27599 result = (int)(arg1)->countUsedVertex();
27600 resultobj = SWIG_From_int(static_cast< int >(result));
27607 SWIGINTERN PyObject *_wrap_Document_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 PyObject *resultobj = 0;
27609 Hex::Document *arg1 = (Hex::Document *) 0 ;
27615 PyObject * obj0 = 0 ;
27616 PyObject * obj1 = 0 ;
27617 Hex::Hexa *result = 0 ;
27619 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
27620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27621 if (!SWIG_IsOK(res1)) {
27622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27624 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27625 ecode2 = SWIG_AsVal_int(obj1, &val2);
27626 if (!SWIG_IsOK(ecode2)) {
27627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getHexa" "', argument " "2"" of type '" "int""'");
27629 arg2 = static_cast< int >(val2);
27630 result = (Hex::Hexa *)(arg1)->getHexa(arg2);
27631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
27638 SWIGINTERN PyObject *_wrap_Document_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *resultobj = 0;
27640 Hex::Document *arg1 = (Hex::Document *) 0 ;
27646 PyObject * obj0 = 0 ;
27647 PyObject * obj1 = 0 ;
27648 Hex::Quad *result = 0 ;
27650 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
27651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27652 if (!SWIG_IsOK(res1)) {
27653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27655 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27656 ecode2 = SWIG_AsVal_int(obj1, &val2);
27657 if (!SWIG_IsOK(ecode2)) {
27658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getQuad" "', argument " "2"" of type '" "int""'");
27660 arg2 = static_cast< int >(val2);
27661 result = (Hex::Quad *)(arg1)->getQuad(arg2);
27662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
27669 SWIGINTERN PyObject *_wrap_Document_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27670 PyObject *resultobj = 0;
27671 Hex::Document *arg1 = (Hex::Document *) 0 ;
27677 PyObject * obj0 = 0 ;
27678 PyObject * obj1 = 0 ;
27679 Hex::Edge *result = 0 ;
27681 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
27682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27683 if (!SWIG_IsOK(res1)) {
27684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27686 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27687 ecode2 = SWIG_AsVal_int(obj1, &val2);
27688 if (!SWIG_IsOK(ecode2)) {
27689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getEdge" "', argument " "2"" of type '" "int""'");
27691 arg2 = static_cast< int >(val2);
27692 result = (Hex::Edge *)(arg1)->getEdge(arg2);
27693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
27700 SWIGINTERN PyObject *_wrap_Document_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27701 PyObject *resultobj = 0;
27702 Hex::Document *arg1 = (Hex::Document *) 0 ;
27708 PyObject * obj0 = 0 ;
27709 PyObject * obj1 = 0 ;
27710 Hex::Vertex *result = 0 ;
27712 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
27713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27717 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27718 ecode2 = SWIG_AsVal_int(obj1, &val2);
27719 if (!SWIG_IsOK(ecode2)) {
27720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVertex" "', argument " "2"" of type '" "int""'");
27722 arg2 = static_cast< int >(val2);
27723 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
27724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27731 SWIGINTERN PyObject *_wrap_Document_getUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27732 PyObject *resultobj = 0;
27733 Hex::Document *arg1 = (Hex::Document *) 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 Hex::Hexa *result = 0 ;
27743 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
27744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27748 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27749 ecode2 = SWIG_AsVal_int(obj1, &val2);
27750 if (!SWIG_IsOK(ecode2)) {
27751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedHexa" "', argument " "2"" of type '" "int""'");
27753 arg2 = static_cast< int >(val2);
27754 result = (Hex::Hexa *)(arg1)->getUsedHexa(arg2);
27755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
27762 SWIGINTERN PyObject *_wrap_Document_getUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27763 PyObject *resultobj = 0;
27764 Hex::Document *arg1 = (Hex::Document *) 0 ;
27770 PyObject * obj0 = 0 ;
27771 PyObject * obj1 = 0 ;
27772 Hex::Quad *result = 0 ;
27774 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
27775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27776 if (!SWIG_IsOK(res1)) {
27777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27779 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27780 ecode2 = SWIG_AsVal_int(obj1, &val2);
27781 if (!SWIG_IsOK(ecode2)) {
27782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedQuad" "', argument " "2"" of type '" "int""'");
27784 arg2 = static_cast< int >(val2);
27785 result = (Hex::Quad *)(arg1)->getUsedQuad(arg2);
27786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
27793 SWIGINTERN PyObject *_wrap_Document_getUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27794 PyObject *resultobj = 0;
27795 Hex::Document *arg1 = (Hex::Document *) 0 ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 Hex::Edge *result = 0 ;
27805 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
27806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27807 if (!SWIG_IsOK(res1)) {
27808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27810 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27811 ecode2 = SWIG_AsVal_int(obj1, &val2);
27812 if (!SWIG_IsOK(ecode2)) {
27813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedEdge" "', argument " "2"" of type '" "int""'");
27815 arg2 = static_cast< int >(val2);
27816 result = (Hex::Edge *)(arg1)->getUsedEdge(arg2);
27817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
27824 SWIGINTERN PyObject *_wrap_Document_getUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825 PyObject *resultobj = 0;
27826 Hex::Document *arg1 = (Hex::Document *) 0 ;
27832 PyObject * obj0 = 0 ;
27833 PyObject * obj1 = 0 ;
27834 Hex::Vertex *result = 0 ;
27836 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
27837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27841 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27842 ecode2 = SWIG_AsVal_int(obj1, &val2);
27843 if (!SWIG_IsOK(ecode2)) {
27844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedVertex" "', argument " "2"" of type '" "int""'");
27846 arg2 = static_cast< int >(val2);
27847 result = (Hex::Vertex *)(arg1)->getUsedVertex(arg2);
27848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
27855 SWIGINTERN PyObject *_wrap_Document_getVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27856 PyObject *resultobj = 0;
27857 Hex::Document *arg1 = (Hex::Document *) 0 ;
27863 PyObject * obj0 = 0 ;
27864 PyObject * obj1 = 0 ;
27865 Hex::Vector *result = 0 ;
27867 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
27868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVector" "', argument " "1"" of type '" "Hex::Document *""'");
27872 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27873 ecode2 = SWIG_AsVal_int(obj1, &val2);
27874 if (!SWIG_IsOK(ecode2)) {
27875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVector" "', argument " "2"" of type '" "int""'");
27877 arg2 = static_cast< int >(val2);
27878 result = (Hex::Vector *)(arg1)->getVector(arg2);
27879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 | 0 );
27886 SWIGINTERN PyObject *_wrap_Document_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27887 PyObject *resultobj = 0;
27888 Hex::Document *arg1 = (Hex::Document *) 0 ;
27894 PyObject * obj0 = 0 ;
27895 PyObject * obj1 = 0 ;
27896 Hex::NewShape *result = 0 ;
27898 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
27899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27900 if (!SWIG_IsOK(res1)) {
27901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getShape" "', argument " "1"" of type '" "Hex::Document *""'");
27903 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27904 ecode2 = SWIG_AsVal_int(obj1, &val2);
27905 if (!SWIG_IsOK(ecode2)) {
27906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getShape" "', argument " "2"" of type '" "int""'");
27908 arg2 = static_cast< int >(val2);
27909 result = (Hex::NewShape *)(arg1)->getShape(arg2);
27910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
27917 SWIGINTERN PyObject *_wrap_Document_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918 PyObject *resultobj = 0;
27919 Hex::Document *arg1 = (Hex::Document *) 0 ;
27925 PyObject * obj0 = 0 ;
27926 PyObject * obj1 = 0 ;
27927 Hex::Group *result = 0 ;
27929 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
27930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27931 if (!SWIG_IsOK(res1)) {
27932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getGroup" "', argument " "1"" of type '" "Hex::Document *""'");
27934 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27935 ecode2 = SWIG_AsVal_int(obj1, &val2);
27936 if (!SWIG_IsOK(ecode2)) {
27937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getGroup" "', argument " "2"" of type '" "int""'");
27939 arg2 = static_cast< int >(val2);
27940 result = (Hex::Group *)(arg1)->getGroup(arg2);
27941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
27948 SWIGINTERN PyObject *_wrap_Document_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27949 PyObject *resultobj = 0;
27950 Hex::Document *arg1 = (Hex::Document *) 0 ;
27956 PyObject * obj0 = 0 ;
27957 PyObject * obj1 = 0 ;
27958 Hex::Law *result = 0 ;
27960 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
27961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27962 if (!SWIG_IsOK(res1)) {
27963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLaw" "', argument " "1"" of type '" "Hex::Document *""'");
27965 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27966 ecode2 = SWIG_AsVal_int(obj1, &val2);
27967 if (!SWIG_IsOK(ecode2)) {
27968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getLaw" "', argument " "2"" of type '" "int""'");
27970 arg2 = static_cast< int >(val2);
27971 result = (Hex::Law *)(arg1)->getLaw(arg2);
27972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
27979 SWIGINTERN PyObject *_wrap_Document_getPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27980 PyObject *resultobj = 0;
27981 Hex::Document *arg1 = (Hex::Document *) 0 ;
27987 PyObject * obj0 = 0 ;
27988 PyObject * obj1 = 0 ;
27989 Hex::Propagation *result = 0 ;
27991 if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
27992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
27993 if (!SWIG_IsOK(res1)) {
27994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
27996 arg1 = reinterpret_cast< Hex::Document * >(argp1);
27997 ecode2 = SWIG_AsVal_int(obj1, &val2);
27998 if (!SWIG_IsOK(ecode2)) {
27999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getPropagation" "', argument " "2"" of type '" "int""'");
28001 arg2 = static_cast< int >(val2);
28002 result = (Hex::Propagation *)(arg1)->getPropagation(arg2);
28003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28010 SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28011 PyObject *resultobj = 0;
28012 Hex::Document *arg1 = (Hex::Document *) 0 ;
28015 PyObject * obj0 = 0 ;
28018 if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
28019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28020 if (!SWIG_IsOK(res1)) {
28021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
28023 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28024 result = (cpchar)(arg1)->getFirstExplicitShape();
28025 resultobj = SWIG_FromCharPtr((const char *)result);
28032 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28033 PyObject *resultobj = 0;
28034 Hex::Document *arg1 = (Hex::Document *) 0 ;
28046 PyObject * obj0 = 0 ;
28047 PyObject * obj1 = 0 ;
28048 PyObject * obj2 = 0 ;
28049 PyObject * obj3 = 0 ;
28050 Hex::Vertex *result = 0 ;
28052 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28054 if (!SWIG_IsOK(res1)) {
28055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
28057 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28058 ecode2 = SWIG_AsVal_double(obj1, &val2);
28059 if (!SWIG_IsOK(ecode2)) {
28060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
28062 arg2 = static_cast< double >(val2);
28063 ecode3 = SWIG_AsVal_double(obj2, &val3);
28064 if (!SWIG_IsOK(ecode3)) {
28065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
28067 arg3 = static_cast< double >(val3);
28068 ecode4 = SWIG_AsVal_double(obj3, &val4);
28069 if (!SWIG_IsOK(ecode4)) {
28070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
28072 arg4 = static_cast< double >(val4);
28073 result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
28074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28081 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28082 PyObject *resultobj = 0;
28083 Hex::Document *arg1 = (Hex::Document *) 0 ;
28084 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28085 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 PyObject * obj2 = 0 ;
28095 Hex::Edge *result = 0 ;
28097 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
28098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28099 if (!SWIG_IsOK(res1)) {
28100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
28102 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28104 if (!SWIG_IsOK(res2)) {
28105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
28107 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28108 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28109 if (!SWIG_IsOK(res3)) {
28110 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
28112 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28113 result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
28114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
28121 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28122 PyObject *resultobj = 0;
28123 Hex::Document *arg1 = (Hex::Document *) 0 ;
28124 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28125 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28132 PyObject * obj0 = 0 ;
28133 PyObject * obj1 = 0 ;
28134 PyObject * obj2 = 0 ;
28135 Hex::Quad *result = 0 ;
28137 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
28138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28139 if (!SWIG_IsOK(res1)) {
28140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28142 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28144 if (!SWIG_IsOK(res2)) {
28145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
28147 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28148 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28149 if (!SWIG_IsOK(res3)) {
28150 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
28152 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28153 result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
28154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
28161 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28162 PyObject *resultobj = 0;
28163 Hex::Document *arg1 = (Hex::Document *) 0 ;
28164 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28165 Hex::Edge *arg3 = (Hex::Edge *) 0 ;
28172 PyObject * obj0 = 0 ;
28173 PyObject * obj1 = 0 ;
28174 PyObject * obj2 = 0 ;
28175 Hex::Quad *result = 0 ;
28177 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
28178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28179 if (!SWIG_IsOK(res1)) {
28180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28182 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28184 if (!SWIG_IsOK(res2)) {
28185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
28187 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28188 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28189 if (!SWIG_IsOK(res3)) {
28190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
28192 arg3 = reinterpret_cast< Hex::Edge * >(argp3);
28193 result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
28194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
28201 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
28203 PyObject *argv[4] = {
28208 if (!PyTuple_Check(args)) SWIG_fail;
28209 argc = args ? PyObject_Length(args) : 0;
28210 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
28211 argv[ii] = PyTuple_GET_ITEM(args,ii);
28216 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28217 _v = SWIG_CheckState(res);
28220 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
28221 _v = SWIG_CheckState(res);
28224 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
28225 _v = SWIG_CheckState(res);
28227 return _wrap_Document_findQuad__SWIG_0(self, args);
28235 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28236 _v = SWIG_CheckState(res);
28239 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
28240 _v = SWIG_CheckState(res);
28243 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
28244 _v = SWIG_CheckState(res);
28246 return _wrap_Document_findQuad__SWIG_1(self, args);
28253 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_findQuad'.\n"
28254 " Possible C/C++ prototypes are:\n"
28255 " Hex::Document::findQuad(Hex::Vertex *,Hex::Vertex *)\n"
28256 " Hex::Document::findQuad(Hex::Edge *,Hex::Edge *)\n");
28261 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262 PyObject *resultobj = 0;
28263 Hex::Document *arg1 = (Hex::Document *) 0 ;
28264 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28265 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 PyObject * obj2 = 0 ;
28275 Hex::Hexa *result = 0 ;
28277 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
28278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28279 if (!SWIG_IsOK(res1)) {
28280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28282 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28284 if (!SWIG_IsOK(res2)) {
28285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
28287 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28288 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28289 if (!SWIG_IsOK(res3)) {
28290 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
28292 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28293 result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
28294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
28301 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28302 PyObject *resultobj = 0;
28303 Hex::Document *arg1 = (Hex::Document *) 0 ;
28304 cpchar arg2 = (cpchar) 0 ;
28310 PyObject * obj0 = 0 ;
28311 PyObject * obj1 = 0 ;
28312 Hex::Group *result = 0 ;
28314 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
28315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28316 if (!SWIG_IsOK(res1)) {
28317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28319 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28320 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28321 if (!SWIG_IsOK(res2)) {
28322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
28324 arg2 = reinterpret_cast< cpchar >(buf2);
28325 result = (Hex::Group *)(arg1)->findGroup(arg2);
28326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
28327 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28330 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28335 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28336 PyObject *resultobj = 0;
28337 Hex::Document *arg1 = (Hex::Document *) 0 ;
28338 cpchar arg2 = (cpchar) 0 ;
28344 PyObject * obj0 = 0 ;
28345 PyObject * obj1 = 0 ;
28346 Hex::Law *result = 0 ;
28348 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&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_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28353 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28354 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28355 if (!SWIG_IsOK(res2)) {
28356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
28358 arg2 = reinterpret_cast< cpchar >(buf2);
28359 result = (Hex::Law *)(arg1)->findLaw(arg2);
28360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
28361 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28364 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28369 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 PyObject *resultobj = 0;
28371 Hex::Document *arg1 = (Hex::Document *) 0 ;
28372 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 Hex::Propagation *result = 0 ;
28381 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
28382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28383 if (!SWIG_IsOK(res1)) {
28384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
28386 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
28388 if (!SWIG_IsOK(res2)) {
28389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
28391 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28392 result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
28393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 | 0 );
28400 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 PyObject *resultobj = 0;
28402 Hex::Document *arg1 = (Hex::Document *) 0 ;
28403 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
28408 PyObject * obj0 = 0 ;
28409 PyObject * obj1 = 0 ;
28412 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
28413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28417 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
28419 if (!SWIG_IsOK(res2)) {
28420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
28422 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
28423 result = (int)(arg1)->removeHexa(arg2);
28424 resultobj = SWIG_From_int(static_cast< int >(result));
28431 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28432 PyObject *resultobj = 0;
28433 Hex::Document *arg1 = (Hex::Document *) 0 ;
28434 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28439 PyObject * obj0 = 0 ;
28440 PyObject * obj1 = 0 ;
28443 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
28444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28445 if (!SWIG_IsOK(res1)) {
28446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28448 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
28450 if (!SWIG_IsOK(res2)) {
28451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
28453 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28454 result = (int)(arg1)->removeQuad(arg2);
28455 resultobj = SWIG_From_int(static_cast< int >(result));
28462 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463 PyObject *resultobj = 0;
28464 Hex::Document *arg1 = (Hex::Document *) 0 ;
28465 Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28474 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
28475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28476 if (!SWIG_IsOK(res1)) {
28477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28479 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
28481 if (!SWIG_IsOK(res2)) {
28482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
28484 arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
28485 result = (int)(arg1)->removeConnectedHexa(arg2);
28486 resultobj = SWIG_From_int(static_cast< int >(result));
28493 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28494 PyObject *resultobj = 0;
28495 Hex::Document *arg1 = (Hex::Document *) 0 ;
28496 Hex::Elements *arg2 = (Hex::Elements *) 0 ;
28501 PyObject * obj0 = 0 ;
28502 PyObject * obj1 = 0 ;
28505 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
28506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
28510 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 | 0 );
28512 if (!SWIG_IsOK(res2)) {
28513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
28515 arg2 = reinterpret_cast< Hex::Elements * >(argp2);
28516 result = (int)(arg1)->removeElements(arg2);
28517 resultobj = SWIG_From_int(static_cast< int >(result));
28524 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28525 PyObject *resultobj = 0;
28526 Hex::Document *arg1 = (Hex::Document *) 0 ;
28527 Hex::Group *arg2 = (Hex::Group *) 0 ;
28532 PyObject * obj0 = 0 ;
28533 PyObject * obj1 = 0 ;
28536 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
28537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28538 if (!SWIG_IsOK(res1)) {
28539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28541 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 | 0 );
28543 if (!SWIG_IsOK(res2)) {
28544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
28546 arg2 = reinterpret_cast< Hex::Group * >(argp2);
28547 result = (int)(arg1)->removeGroup(arg2);
28548 resultobj = SWIG_From_int(static_cast< int >(result));
28555 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556 PyObject *resultobj = 0;
28557 Hex::Document *arg1 = (Hex::Document *) 0 ;
28558 Hex::Law *arg2 = (Hex::Law *) 0 ;
28563 PyObject * obj0 = 0 ;
28564 PyObject * obj1 = 0 ;
28567 if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
28568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28569 if (!SWIG_IsOK(res1)) {
28570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28572 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
28574 if (!SWIG_IsOK(res2)) {
28575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28577 arg2 = reinterpret_cast< Hex::Law * >(argp2);
28578 result = (int)(arg1)->removeLaw(arg2);
28579 resultobj = SWIG_From_int(static_cast< int >(result));
28586 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 Hex::Document *arg1 = (Hex::Document *) 0 ;
28600 PyObject * obj0 = 0 ;
28601 PyObject * obj1 = 0 ;
28602 PyObject * obj2 = 0 ;
28603 PyObject * obj3 = 0 ;
28604 Hex::Elements *result = 0 ;
28606 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28608 if (!SWIG_IsOK(res1)) {
28609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
28611 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28612 ecode2 = SWIG_AsVal_int(obj1, &val2);
28613 if (!SWIG_IsOK(ecode2)) {
28614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
28616 arg2 = static_cast< int >(val2);
28617 ecode3 = SWIG_AsVal_int(obj2, &val3);
28618 if (!SWIG_IsOK(ecode3)) {
28619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
28621 arg3 = static_cast< int >(val3);
28622 ecode4 = SWIG_AsVal_int(obj3, &val4);
28623 if (!SWIG_IsOK(ecode4)) {
28624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
28626 arg4 = static_cast< int >(val4);
28627 result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
28628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28635 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28636 PyObject *resultobj = 0;
28637 Hex::Document *arg1 = (Hex::Document *) 0 ;
28638 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28639 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28640 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28641 Hex::Vector *arg5 = (Hex::Vector *) 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 PyObject * obj2 = 0 ;
28673 PyObject * obj3 = 0 ;
28674 PyObject * obj4 = 0 ;
28675 PyObject * obj5 = 0 ;
28676 PyObject * obj6 = 0 ;
28677 PyObject * obj7 = 0 ;
28678 PyObject * obj8 = 0 ;
28679 PyObject * obj9 = 0 ;
28680 PyObject * obj10 = 0 ;
28681 Hex::Elements *result = 0 ;
28683 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
28684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28685 if (!SWIG_IsOK(res1)) {
28686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
28688 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28690 if (!SWIG_IsOK(res2)) {
28691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
28693 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28694 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28695 if (!SWIG_IsOK(res3)) {
28696 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28698 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28699 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28700 if (!SWIG_IsOK(res4)) {
28701 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28703 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28704 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28705 if (!SWIG_IsOK(res5)) {
28706 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
28708 arg5 = reinterpret_cast< Hex::Vector * >(argp5);
28709 ecode6 = SWIG_AsVal_double(obj5, &val6);
28710 if (!SWIG_IsOK(ecode6)) {
28711 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
28713 arg6 = static_cast< double >(val6);
28714 ecode7 = SWIG_AsVal_double(obj6, &val7);
28715 if (!SWIG_IsOK(ecode7)) {
28716 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
28718 arg7 = static_cast< double >(val7);
28719 ecode8 = SWIG_AsVal_double(obj7, &val8);
28720 if (!SWIG_IsOK(ecode8)) {
28721 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
28723 arg8 = static_cast< double >(val8);
28724 ecode9 = SWIG_AsVal_int(obj8, &val9);
28725 if (!SWIG_IsOK(ecode9)) {
28726 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
28728 arg9 = static_cast< int >(val9);
28729 ecode10 = SWIG_AsVal_int(obj9, &val10);
28730 if (!SWIG_IsOK(ecode10)) {
28731 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
28733 arg10 = static_cast< int >(val10);
28734 ecode11 = SWIG_AsVal_int(obj10, &val11);
28735 if (!SWIG_IsOK(ecode11)) {
28736 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
28738 arg11 = static_cast< int >(val11);
28739 result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
28740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28747 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 Hex::Document *arg1 = (Hex::Document *) 0 ;
28750 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28751 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28752 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28753 Hex::Vector *arg5 = (Hex::Vector *) 0 ;
28754 Hex::RealVector arg6 ;
28755 Hex::RealVector arg7 ;
28756 Hex::RealVector arg8 ;
28767 PyObject * obj0 = 0 ;
28768 PyObject * obj1 = 0 ;
28769 PyObject * obj2 = 0 ;
28770 PyObject * obj3 = 0 ;
28771 PyObject * obj4 = 0 ;
28772 PyObject * obj5 = 0 ;
28773 PyObject * obj6 = 0 ;
28774 PyObject * obj7 = 0 ;
28775 Hex::Elements *result = 0 ;
28777 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28779 if (!SWIG_IsOK(res1)) {
28780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
28782 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28784 if (!SWIG_IsOK(res2)) {
28785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
28787 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28788 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28789 if (!SWIG_IsOK(res3)) {
28790 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
28792 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28793 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28794 if (!SWIG_IsOK(res4)) {
28795 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
28797 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28798 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28799 if (!SWIG_IsOK(res5)) {
28800 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
28802 arg5 = reinterpret_cast< Hex::Vector * >(argp5);
28804 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28805 int res = swig::asptr(obj5, &ptr);
28806 if (!SWIG_IsOK(res) || !ptr) {
28807 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
28810 if (SWIG_IsNewObj(res)) delete ptr;
28813 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28814 int res = swig::asptr(obj6, &ptr);
28815 if (!SWIG_IsOK(res) || !ptr) {
28816 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
28819 if (SWIG_IsNewObj(res)) delete ptr;
28822 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28823 int res = swig::asptr(obj7, &ptr);
28824 if (!SWIG_IsOK(res) || !ptr) {
28825 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
28828 if (SWIG_IsNewObj(res)) delete ptr;
28830 result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
28831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28838 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28839 PyObject *resultobj = 0;
28840 Hex::Document *arg1 = (Hex::Document *) 0 ;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 PyObject * obj2 = 0 ;
28855 PyObject * obj3 = 0 ;
28856 Hex::Elements *result = 0 ;
28858 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
28863 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28864 ecode2 = SWIG_AsVal_int(obj1, &val2);
28865 if (!SWIG_IsOK(ecode2)) {
28866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
28868 arg2 = static_cast< int >(val2);
28869 ecode3 = SWIG_AsVal_int(obj2, &val3);
28870 if (!SWIG_IsOK(ecode3)) {
28871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
28873 arg3 = static_cast< int >(val3);
28874 ecode4 = SWIG_AsVal_int(obj3, &val4);
28875 if (!SWIG_IsOK(ecode4)) {
28876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
28878 arg4 = static_cast< int >(val4);
28879 result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
28880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28887 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28888 PyObject *resultobj = 0;
28889 Hex::Document *arg1 = (Hex::Document *) 0 ;
28890 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28891 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28892 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28922 PyObject * obj0 = 0 ;
28923 PyObject * obj1 = 0 ;
28924 PyObject * obj2 = 0 ;
28925 PyObject * obj3 = 0 ;
28926 PyObject * obj4 = 0 ;
28927 PyObject * obj5 = 0 ;
28928 PyObject * obj6 = 0 ;
28929 PyObject * obj7 = 0 ;
28930 PyObject * obj8 = 0 ;
28931 PyObject * obj9 = 0 ;
28932 PyObject * obj10 = 0 ;
28933 Hex::Elements *result = 0 ;
28935 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
28936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
28940 arg1 = reinterpret_cast< Hex::Document * >(argp1);
28941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
28942 if (!SWIG_IsOK(res2)) {
28943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
28945 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28946 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28947 if (!SWIG_IsOK(res3)) {
28948 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28950 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28951 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
28952 if (!SWIG_IsOK(res4)) {
28953 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28955 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28956 ecode5 = SWIG_AsVal_double(obj4, &val5);
28957 if (!SWIG_IsOK(ecode5)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
28960 arg5 = static_cast< double >(val5);
28961 ecode6 = SWIG_AsVal_double(obj5, &val6);
28962 if (!SWIG_IsOK(ecode6)) {
28963 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
28965 arg6 = static_cast< double >(val6);
28966 ecode7 = SWIG_AsVal_double(obj6, &val7);
28967 if (!SWIG_IsOK(ecode7)) {
28968 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
28970 arg7 = static_cast< double >(val7);
28971 ecode8 = SWIG_AsVal_double(obj7, &val8);
28972 if (!SWIG_IsOK(ecode8)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
28975 arg8 = static_cast< double >(val8);
28976 ecode9 = SWIG_AsVal_int(obj8, &val9);
28977 if (!SWIG_IsOK(ecode9)) {
28978 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
28980 arg9 = static_cast< int >(val9);
28981 ecode10 = SWIG_AsVal_int(obj9, &val10);
28982 if (!SWIG_IsOK(ecode10)) {
28983 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
28985 arg10 = static_cast< int >(val10);
28986 ecode11 = SWIG_AsVal_int(obj10, &val11);
28987 if (!SWIG_IsOK(ecode11)) {
28988 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
28990 arg11 = static_cast< int >(val11);
28991 result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
28992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
28999 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29000 PyObject *resultobj = 0;
29001 Hex::Document *arg1 = (Hex::Document *) 0 ;
29002 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29003 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29004 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29005 Hex::RealVector arg5 ;
29006 Hex::RealVector arg6 ;
29007 Hex::RealVector arg7 ;
29016 PyObject * obj0 = 0 ;
29017 PyObject * obj1 = 0 ;
29018 PyObject * obj2 = 0 ;
29019 PyObject * obj3 = 0 ;
29020 PyObject * obj4 = 0 ;
29021 PyObject * obj5 = 0 ;
29022 PyObject * obj6 = 0 ;
29023 Hex::Elements *result = 0 ;
29025 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29027 if (!SWIG_IsOK(res1)) {
29028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
29030 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29032 if (!SWIG_IsOK(res2)) {
29033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
29035 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29036 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29037 if (!SWIG_IsOK(res3)) {
29038 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
29040 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29041 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29042 if (!SWIG_IsOK(res4)) {
29043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
29045 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29047 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29048 int res = swig::asptr(obj4, &ptr);
29049 if (!SWIG_IsOK(res) || !ptr) {
29050 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
29053 if (SWIG_IsNewObj(res)) delete ptr;
29056 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29057 int res = swig::asptr(obj5, &ptr);
29058 if (!SWIG_IsOK(res) || !ptr) {
29059 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
29062 if (SWIG_IsNewObj(res)) delete ptr;
29065 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29066 int res = swig::asptr(obj6, &ptr);
29067 if (!SWIG_IsOK(res) || !ptr) {
29068 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
29071 if (SWIG_IsNewObj(res)) delete ptr;
29073 result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
29074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29081 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29082 PyObject *resultobj = 0;
29083 Hex::Document *arg1 = (Hex::Document *) 0 ;
29095 PyObject * obj0 = 0 ;
29096 PyObject * obj1 = 0 ;
29097 PyObject * obj2 = 0 ;
29098 PyObject * obj3 = 0 ;
29099 Hex::Elements *result = 0 ;
29101 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29103 if (!SWIG_IsOK(res1)) {
29104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
29106 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29107 ecode2 = SWIG_AsVal_int(obj1, &val2);
29108 if (!SWIG_IsOK(ecode2)) {
29109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
29111 arg2 = static_cast< int >(val2);
29112 ecode3 = SWIG_AsVal_int(obj2, &val3);
29113 if (!SWIG_IsOK(ecode3)) {
29114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
29116 arg3 = static_cast< int >(val3);
29117 ecode4 = SWIG_AsVal_int(obj3, &val4);
29118 if (!SWIG_IsOK(ecode4)) {
29119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
29121 arg4 = static_cast< int >(val4);
29122 result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
29123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29130 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 PyObject *resultobj = 0;
29132 Hex::Document *arg1 = (Hex::Document *) 0 ;
29133 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29134 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29135 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29165 PyObject * obj0 = 0 ;
29166 PyObject * obj1 = 0 ;
29167 PyObject * obj2 = 0 ;
29168 PyObject * obj3 = 0 ;
29169 PyObject * obj4 = 0 ;
29170 PyObject * obj5 = 0 ;
29171 PyObject * obj6 = 0 ;
29172 PyObject * obj7 = 0 ;
29173 PyObject * obj8 = 0 ;
29174 PyObject * obj9 = 0 ;
29175 PyObject * obj10 = 0 ;
29176 Hex::Elements *result = 0 ;
29178 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
29179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29180 if (!SWIG_IsOK(res1)) {
29181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
29183 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29185 if (!SWIG_IsOK(res2)) {
29186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29188 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29189 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29190 if (!SWIG_IsOK(res3)) {
29191 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29193 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29194 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29195 if (!SWIG_IsOK(res4)) {
29196 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29198 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29199 ecode5 = SWIG_AsVal_double(obj4, &val5);
29200 if (!SWIG_IsOK(ecode5)) {
29201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
29203 arg5 = static_cast< double >(val5);
29204 ecode6 = SWIG_AsVal_double(obj5, &val6);
29205 if (!SWIG_IsOK(ecode6)) {
29206 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
29208 arg6 = static_cast< double >(val6);
29209 ecode7 = SWIG_AsVal_double(obj6, &val7);
29210 if (!SWIG_IsOK(ecode7)) {
29211 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
29213 arg7 = static_cast< double >(val7);
29214 ecode8 = SWIG_AsVal_double(obj7, &val8);
29215 if (!SWIG_IsOK(ecode8)) {
29216 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
29218 arg8 = static_cast< double >(val8);
29219 ecode9 = SWIG_AsVal_int(obj8, &val9);
29220 if (!SWIG_IsOK(ecode9)) {
29221 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
29223 arg9 = static_cast< int >(val9);
29224 ecode10 = SWIG_AsVal_int(obj9, &val10);
29225 if (!SWIG_IsOK(ecode10)) {
29226 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
29228 arg10 = static_cast< int >(val10);
29229 ecode11 = SWIG_AsVal_int(obj10, &val11);
29230 if (!SWIG_IsOK(ecode11)) {
29231 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
29233 arg11 = static_cast< int >(val11);
29234 result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
29235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29242 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 Hex::Document *arg1 = (Hex::Document *) 0 ;
29245 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29246 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29247 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29248 Hex::RealVector arg5 ;
29249 Hex::RealVector arg6 ;
29250 Hex::RealVector arg7 ;
29259 PyObject * obj0 = 0 ;
29260 PyObject * obj1 = 0 ;
29261 PyObject * obj2 = 0 ;
29262 PyObject * obj3 = 0 ;
29263 PyObject * obj4 = 0 ;
29264 PyObject * obj5 = 0 ;
29265 PyObject * obj6 = 0 ;
29266 Hex::Elements *result = 0 ;
29268 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29270 if (!SWIG_IsOK(res1)) {
29271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
29273 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29275 if (!SWIG_IsOK(res2)) {
29276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
29278 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29279 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29280 if (!SWIG_IsOK(res3)) {
29281 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
29283 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29284 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29285 if (!SWIG_IsOK(res4)) {
29286 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
29288 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29290 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29291 int res = swig::asptr(obj4, &ptr);
29292 if (!SWIG_IsOK(res) || !ptr) {
29293 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
29296 if (SWIG_IsNewObj(res)) delete ptr;
29299 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29300 int res = swig::asptr(obj5, &ptr);
29301 if (!SWIG_IsOK(res) || !ptr) {
29302 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
29305 if (SWIG_IsNewObj(res)) delete ptr;
29308 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29309 int res = swig::asptr(obj6, &ptr);
29310 if (!SWIG_IsOK(res) || !ptr) {
29311 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
29314 if (SWIG_IsNewObj(res)) delete ptr;
29316 result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
29317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29324 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325 PyObject *resultobj = 0;
29326 Hex::Document *arg1 = (Hex::Document *) 0 ;
29335 PyObject * obj0 = 0 ;
29336 PyObject * obj1 = 0 ;
29337 PyObject * obj2 = 0 ;
29338 Hex::Elements *result = 0 ;
29340 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
29341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
29345 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29346 ecode2 = SWIG_AsVal_int(obj1, &val2);
29347 if (!SWIG_IsOK(ecode2)) {
29348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
29350 arg2 = static_cast< int >(val2);
29351 ecode3 = SWIG_AsVal_int(obj2, &val3);
29352 if (!SWIG_IsOK(ecode3)) {
29353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
29355 arg3 = static_cast< int >(val3);
29356 result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
29357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29364 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365 PyObject *resultobj = 0;
29366 Hex::Document *arg1 = (Hex::Document *) 0 ;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 Hex::Elements *result = 0 ;
29376 if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
29377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29378 if (!SWIG_IsOK(res1)) {
29379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
29381 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29382 ecode2 = SWIG_AsVal_int(obj1, &val2);
29383 if (!SWIG_IsOK(ecode2)) {
29384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
29386 arg2 = static_cast< int >(val2);
29387 result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
29388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29395 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
29397 PyObject *argv[4] = {
29402 if (!PyTuple_Check(args)) SWIG_fail;
29403 argc = args ? PyObject_Length(args) : 0;
29404 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
29405 argv[ii] = PyTuple_GET_ITEM(args,ii);
29410 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29411 _v = SWIG_CheckState(res);
29414 int res = SWIG_AsVal_int(argv[1], NULL);
29415 _v = SWIG_CheckState(res);
29418 return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
29425 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29426 _v = SWIG_CheckState(res);
29429 int res = SWIG_AsVal_int(argv[1], NULL);
29430 _v = SWIG_CheckState(res);
29434 int res = SWIG_AsVal_int(argv[2], NULL);
29435 _v = SWIG_CheckState(res);
29438 return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
29445 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSphericalTop'.\n"
29446 " Possible C/C++ prototypes are:\n"
29447 " Hex::Document::makeSphericalTop(int,int)\n"
29448 " Hex::Document::makeSphericalTop(int)\n");
29453 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454 PyObject *resultobj = 0;
29455 Hex::Document *arg1 = (Hex::Document *) 0 ;
29456 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29457 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29458 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29476 PyObject * obj0 = 0 ;
29477 PyObject * obj1 = 0 ;
29478 PyObject * obj2 = 0 ;
29479 PyObject * obj3 = 0 ;
29480 PyObject * obj4 = 0 ;
29481 PyObject * obj5 = 0 ;
29482 PyObject * obj6 = 0 ;
29483 Hex::Elements *result = 0 ;
29485 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29487 if (!SWIG_IsOK(res1)) {
29488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
29490 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29492 if (!SWIG_IsOK(res2)) {
29493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29495 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29496 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29497 if (!SWIG_IsOK(res3)) {
29498 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29500 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29501 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29502 if (!SWIG_IsOK(res4)) {
29503 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29505 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29506 ecode5 = SWIG_AsVal_double(obj4, &val5);
29507 if (!SWIG_IsOK(ecode5)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
29510 arg5 = static_cast< double >(val5);
29511 ecode6 = SWIG_AsVal_int(obj5, &val6);
29512 if (!SWIG_IsOK(ecode6)) {
29513 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
29515 arg6 = static_cast< int >(val6);
29516 ecode7 = SWIG_AsVal_int(obj6, &val7);
29517 if (!SWIG_IsOK(ecode7)) {
29518 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
29520 arg7 = static_cast< int >(val7);
29521 result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
29522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29529 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 Hex::Document *arg1 = (Hex::Document *) 0 ;
29532 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29533 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29534 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 PyObject * obj2 = 0 ;
29552 PyObject * obj3 = 0 ;
29553 PyObject * obj4 = 0 ;
29554 PyObject * obj5 = 0 ;
29555 Hex::Elements *result = 0 ;
29557 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29559 if (!SWIG_IsOK(res1)) {
29560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
29562 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29563 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29564 if (!SWIG_IsOK(res2)) {
29565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29567 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29568 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29569 if (!SWIG_IsOK(res3)) {
29570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29572 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29573 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29574 if (!SWIG_IsOK(res4)) {
29575 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29577 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29578 ecode5 = SWIG_AsVal_double(obj4, &val5);
29579 if (!SWIG_IsOK(ecode5)) {
29580 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
29582 arg5 = static_cast< double >(val5);
29583 ecode6 = SWIG_AsVal_int(obj5, &val6);
29584 if (!SWIG_IsOK(ecode6)) {
29585 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
29587 arg6 = static_cast< int >(val6);
29588 result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
29589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29596 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
29598 PyObject *argv[8] = {
29603 if (!PyTuple_Check(args)) SWIG_fail;
29604 argc = args ? PyObject_Length(args) : 0;
29605 for (ii = 0; (ii < 7) && (ii < argc); ii++) {
29606 argv[ii] = PyTuple_GET_ITEM(args,ii);
29611 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29612 _v = SWIG_CheckState(res);
29615 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29616 _v = SWIG_CheckState(res);
29619 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29620 _v = SWIG_CheckState(res);
29623 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29624 _v = SWIG_CheckState(res);
29627 int res = SWIG_AsVal_double(argv[4], NULL);
29628 _v = SWIG_CheckState(res);
29632 int res = SWIG_AsVal_int(argv[5], NULL);
29633 _v = SWIG_CheckState(res);
29636 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
29647 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29648 _v = SWIG_CheckState(res);
29651 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29652 _v = SWIG_CheckState(res);
29655 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29656 _v = SWIG_CheckState(res);
29659 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29660 _v = SWIG_CheckState(res);
29663 int res = SWIG_AsVal_double(argv[4], NULL);
29664 _v = SWIG_CheckState(res);
29668 int res = SWIG_AsVal_int(argv[5], NULL);
29669 _v = SWIG_CheckState(res);
29673 int res = SWIG_AsVal_int(argv[6], NULL);
29674 _v = SWIG_CheckState(res);
29677 return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
29688 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSphericalUni'.\n"
29689 " Possible C/C++ prototypes are:\n"
29690 " Hex::Document::makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n"
29691 " Hex::Document::makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
29696 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29697 PyObject *resultobj = 0;
29698 Hex::Document *arg1 = (Hex::Document *) 0 ;
29699 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29700 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29701 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29702 Hex::RealVector arg5 ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 PyObject * obj2 = 0 ;
29717 PyObject * obj3 = 0 ;
29718 PyObject * obj4 = 0 ;
29719 PyObject * obj5 = 0 ;
29720 Hex::Elements *result = 0 ;
29722 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29724 if (!SWIG_IsOK(res1)) {
29725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
29727 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29729 if (!SWIG_IsOK(res2)) {
29730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
29732 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29733 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29734 if (!SWIG_IsOK(res3)) {
29735 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
29737 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29738 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29739 if (!SWIG_IsOK(res4)) {
29740 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
29742 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29744 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29745 int res = swig::asptr(obj4, &ptr);
29746 if (!SWIG_IsOK(res) || !ptr) {
29747 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
29750 if (SWIG_IsNewObj(res)) delete ptr;
29752 ecode6 = SWIG_AsVal_int(obj5, &val6);
29753 if (!SWIG_IsOK(ecode6)) {
29754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
29756 arg6 = static_cast< int >(val6);
29757 result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
29758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29765 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29766 PyObject *resultobj = 0;
29767 Hex::Document *arg1 = (Hex::Document *) 0 ;
29768 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29769 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29770 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29771 Hex::RealVector arg5 ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 PyObject * obj2 = 0 ;
29783 PyObject * obj3 = 0 ;
29784 PyObject * obj4 = 0 ;
29785 Hex::Elements *result = 0 ;
29787 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
29792 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
29794 if (!SWIG_IsOK(res2)) {
29795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
29797 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29798 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29799 if (!SWIG_IsOK(res3)) {
29800 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
29802 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29803 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
29804 if (!SWIG_IsOK(res4)) {
29805 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
29807 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29809 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29810 int res = swig::asptr(obj4, &ptr);
29811 if (!SWIG_IsOK(res) || !ptr) {
29812 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
29815 if (SWIG_IsNewObj(res)) delete ptr;
29817 result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
29818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29825 SWIGINTERN PyObject *_wrap_Document_makeSpherical(PyObject *self, PyObject *args) {
29827 PyObject *argv[7] = {
29832 if (!PyTuple_Check(args)) SWIG_fail;
29833 argc = args ? PyObject_Length(args) : 0;
29834 for (ii = 0; (ii < 6) && (ii < argc); ii++) {
29835 argv[ii] = PyTuple_GET_ITEM(args,ii);
29840 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29841 _v = SWIG_CheckState(res);
29844 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29845 _v = SWIG_CheckState(res);
29848 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29849 _v = SWIG_CheckState(res);
29852 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29853 _v = SWIG_CheckState(res);
29855 int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
29856 _v = SWIG_CheckState(res);
29858 return _wrap_Document_makeSpherical__SWIG_1(self, args);
29868 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29869 _v = SWIG_CheckState(res);
29872 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29873 _v = SWIG_CheckState(res);
29876 int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29877 _v = SWIG_CheckState(res);
29880 int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29881 _v = SWIG_CheckState(res);
29883 int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
29884 _v = SWIG_CheckState(res);
29887 int res = SWIG_AsVal_int(argv[5], NULL);
29888 _v = SWIG_CheckState(res);
29891 return _wrap_Document_makeSpherical__SWIG_0(self, args);
29901 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSpherical'.\n"
29902 " Possible C/C++ prototypes are:\n"
29903 " Hex::Document::makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n"
29904 " Hex::Document::makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
29909 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910 PyObject *resultobj = 0;
29911 Hex::Document *arg1 = (Hex::Document *) 0 ;
29923 PyObject * obj0 = 0 ;
29924 PyObject * obj1 = 0 ;
29925 PyObject * obj2 = 0 ;
29926 PyObject * obj3 = 0 ;
29927 Hex::Elements *result = 0 ;
29929 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
29934 arg1 = reinterpret_cast< Hex::Document * >(argp1);
29935 ecode2 = SWIG_AsVal_int(obj1, &val2);
29936 if (!SWIG_IsOK(ecode2)) {
29937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
29939 arg2 = static_cast< int >(val2);
29940 ecode3 = SWIG_AsVal_int(obj2, &val3);
29941 if (!SWIG_IsOK(ecode3)) {
29942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
29944 arg3 = static_cast< int >(val3);
29945 ecode4 = SWIG_AsVal_int(obj3, &val4);
29946 if (!SWIG_IsOK(ecode4)) {
29947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
29949 arg4 = static_cast< int >(val4);
29950 result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
29951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
29958 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29959 PyObject *resultobj = 0;
29960 Hex::Document *arg1 = (Hex::Document *) 0 ;
29961 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29962 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29963 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29967 Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
29993 PyObject * obj0 = 0 ;
29994 PyObject * obj1 = 0 ;
29995 PyObject * obj2 = 0 ;
29996 PyObject * obj3 = 0 ;
29997 PyObject * obj4 = 0 ;
29998 PyObject * obj5 = 0 ;
29999 PyObject * obj6 = 0 ;
30000 PyObject * obj7 = 0 ;
30001 PyObject * obj8 = 0 ;
30002 PyObject * obj9 = 0 ;
30003 PyObject * obj10 = 0 ;
30004 Hex::Elements *result = 0 ;
30006 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
30007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30008 if (!SWIG_IsOK(res1)) {
30009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
30011 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30013 if (!SWIG_IsOK(res2)) {
30014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
30016 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30018 if (!SWIG_IsOK(res3)) {
30019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30021 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30022 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30023 if (!SWIG_IsOK(res4)) {
30024 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30026 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30027 ecode5 = SWIG_AsVal_double(obj4, &val5);
30028 if (!SWIG_IsOK(ecode5)) {
30029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
30031 arg5 = static_cast< double >(val5);
30032 ecode6 = SWIG_AsVal_double(obj5, &val6);
30033 if (!SWIG_IsOK(ecode6)) {
30034 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
30036 arg6 = static_cast< double >(val6);
30037 ecode7 = SWIG_AsVal_double(obj6, &val7);
30038 if (!SWIG_IsOK(ecode7)) {
30039 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
30041 arg7 = static_cast< double >(val7);
30042 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30043 if (!SWIG_IsOK(res8)) {
30044 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
30046 arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
30047 ecode9 = SWIG_AsVal_int(obj8, &val9);
30048 if (!SWIG_IsOK(ecode9)) {
30049 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
30051 arg9 = static_cast< int >(val9);
30052 ecode10 = SWIG_AsVal_int(obj9, &val10);
30053 if (!SWIG_IsOK(ecode10)) {
30054 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
30056 arg10 = static_cast< int >(val10);
30057 ecode11 = SWIG_AsVal_int(obj10, &val11);
30058 if (!SWIG_IsOK(ecode11)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
30061 arg11 = static_cast< int >(val11);
30062 result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
30063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30070 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 Hex::Document *arg1 = (Hex::Document *) 0 ;
30073 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30074 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30075 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30076 Hex::RealVector arg5 ;
30077 Hex::RealVector arg6 ;
30078 Hex::RealVector arg7 ;
30087 PyObject * obj0 = 0 ;
30088 PyObject * obj1 = 0 ;
30089 PyObject * obj2 = 0 ;
30090 PyObject * obj3 = 0 ;
30091 PyObject * obj4 = 0 ;
30092 PyObject * obj5 = 0 ;
30093 PyObject * obj6 = 0 ;
30094 Hex::Elements *result = 0 ;
30096 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30098 if (!SWIG_IsOK(res1)) {
30099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
30101 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30103 if (!SWIG_IsOK(res2)) {
30104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
30106 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30107 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30108 if (!SWIG_IsOK(res3)) {
30109 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
30111 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30112 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30113 if (!SWIG_IsOK(res4)) {
30114 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
30116 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30118 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30119 int res = swig::asptr(obj4, &ptr);
30120 if (!SWIG_IsOK(res) || !ptr) {
30121 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
30124 if (SWIG_IsNewObj(res)) delete ptr;
30127 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30128 int res = swig::asptr(obj5, &ptr);
30129 if (!SWIG_IsOK(res) || !ptr) {
30130 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
30133 if (SWIG_IsNewObj(res)) delete ptr;
30136 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30137 int res = swig::asptr(obj6, &ptr);
30138 if (!SWIG_IsOK(res) || !ptr) {
30139 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
30142 if (SWIG_IsNewObj(res)) delete ptr;
30144 result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
30145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30152 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153 PyObject *resultobj = 0;
30154 Hex::Document *arg1 = (Hex::Document *) 0 ;
30166 PyObject * obj0 = 0 ;
30167 PyObject * obj1 = 0 ;
30168 PyObject * obj2 = 0 ;
30169 PyObject * obj3 = 0 ;
30170 Hex::Elements *result = 0 ;
30172 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30174 if (!SWIG_IsOK(res1)) {
30175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
30177 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30178 ecode2 = SWIG_AsVal_int(obj1, &val2);
30179 if (!SWIG_IsOK(ecode2)) {
30180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
30182 arg2 = static_cast< int >(val2);
30183 ecode3 = SWIG_AsVal_int(obj2, &val3);
30184 if (!SWIG_IsOK(ecode3)) {
30185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
30187 arg3 = static_cast< int >(val3);
30188 ecode4 = SWIG_AsVal_int(obj3, &val4);
30189 if (!SWIG_IsOK(ecode4)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
30192 arg4 = static_cast< int >(val4);
30193 result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
30194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30201 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30202 PyObject *resultobj = 0;
30203 Hex::Document *arg1 = (Hex::Document *) 0 ;
30204 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30205 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30206 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30211 Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
30239 PyObject * obj0 = 0 ;
30240 PyObject * obj1 = 0 ;
30241 PyObject * obj2 = 0 ;
30242 PyObject * obj3 = 0 ;
30243 PyObject * obj4 = 0 ;
30244 PyObject * obj5 = 0 ;
30245 PyObject * obj6 = 0 ;
30246 PyObject * obj7 = 0 ;
30247 PyObject * obj8 = 0 ;
30248 PyObject * obj9 = 0 ;
30249 PyObject * obj10 = 0 ;
30250 PyObject * obj11 = 0 ;
30251 Hex::Elements *result = 0 ;
30253 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
30254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30255 if (!SWIG_IsOK(res1)) {
30256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
30258 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30260 if (!SWIG_IsOK(res2)) {
30261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
30263 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30264 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30265 if (!SWIG_IsOK(res3)) {
30266 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30268 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30269 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30270 if (!SWIG_IsOK(res4)) {
30271 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30273 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30274 ecode5 = SWIG_AsVal_double(obj4, &val5);
30275 if (!SWIG_IsOK(ecode5)) {
30276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
30278 arg5 = static_cast< double >(val5);
30279 ecode6 = SWIG_AsVal_double(obj5, &val6);
30280 if (!SWIG_IsOK(ecode6)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
30283 arg6 = static_cast< double >(val6);
30284 ecode7 = SWIG_AsVal_double(obj6, &val7);
30285 if (!SWIG_IsOK(ecode7)) {
30286 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
30288 arg7 = static_cast< double >(val7);
30289 ecode8 = SWIG_AsVal_double(obj7, &val8);
30290 if (!SWIG_IsOK(ecode8)) {
30291 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
30293 arg8 = static_cast< double >(val8);
30294 res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30295 if (!SWIG_IsOK(res9)) {
30296 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
30298 arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
30299 ecode10 = SWIG_AsVal_int(obj9, &val10);
30300 if (!SWIG_IsOK(ecode10)) {
30301 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
30303 arg10 = static_cast< int >(val10);
30304 ecode11 = SWIG_AsVal_int(obj10, &val11);
30305 if (!SWIG_IsOK(ecode11)) {
30306 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
30308 arg11 = static_cast< int >(val11);
30309 ecode12 = SWIG_AsVal_int(obj11, &val12);
30310 if (!SWIG_IsOK(ecode12)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
30313 arg12 = static_cast< int >(val12);
30314 result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
30315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30322 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323 PyObject *resultobj = 0;
30324 Hex::Document *arg1 = (Hex::Document *) 0 ;
30325 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30326 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30327 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30328 Hex::RealVector arg5 ;
30329 Hex::RealVector arg6 ;
30330 Hex::RealVector arg7 ;
30339 PyObject * obj0 = 0 ;
30340 PyObject * obj1 = 0 ;
30341 PyObject * obj2 = 0 ;
30342 PyObject * obj3 = 0 ;
30343 PyObject * obj4 = 0 ;
30344 PyObject * obj5 = 0 ;
30345 PyObject * obj6 = 0 ;
30346 Hex::Elements *result = 0 ;
30348 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30350 if (!SWIG_IsOK(res1)) {
30351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
30353 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30355 if (!SWIG_IsOK(res2)) {
30356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
30358 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30359 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30360 if (!SWIG_IsOK(res3)) {
30361 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
30363 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30364 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30365 if (!SWIG_IsOK(res4)) {
30366 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
30368 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30370 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30371 int res = swig::asptr(obj4, &ptr);
30372 if (!SWIG_IsOK(res) || !ptr) {
30373 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
30376 if (SWIG_IsNewObj(res)) delete ptr;
30379 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30380 int res = swig::asptr(obj5, &ptr);
30381 if (!SWIG_IsOK(res) || !ptr) {
30382 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
30385 if (SWIG_IsNewObj(res)) delete ptr;
30388 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30389 int res = swig::asptr(obj6, &ptr);
30390 if (!SWIG_IsOK(res) || !ptr) {
30391 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
30394 if (SWIG_IsNewObj(res)) delete ptr;
30396 result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
30397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30404 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30405 PyObject *resultobj = 0;
30406 Hex::Document *arg1 = (Hex::Document *) 0 ;
30407 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30408 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30411 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
30412 Hex::Vector *arg7 = (Hex::Vector *) 0 ;
30433 PyObject * obj0 = 0 ;
30434 PyObject * obj1 = 0 ;
30435 PyObject * obj2 = 0 ;
30436 PyObject * obj3 = 0 ;
30437 PyObject * obj4 = 0 ;
30438 PyObject * obj5 = 0 ;
30439 PyObject * obj6 = 0 ;
30440 PyObject * obj7 = 0 ;
30441 PyObject * obj8 = 0 ;
30442 Hex::BiCylinder *result = 0 ;
30444 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
30445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
30449 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30451 if (!SWIG_IsOK(res2)) {
30452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
30454 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30455 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30456 if (!SWIG_IsOK(res3)) {
30457 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
30459 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30460 ecode4 = SWIG_AsVal_double(obj3, &val4);
30461 if (!SWIG_IsOK(ecode4)) {
30462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
30464 arg4 = static_cast< double >(val4);
30465 ecode5 = SWIG_AsVal_double(obj4, &val5);
30466 if (!SWIG_IsOK(ecode5)) {
30467 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
30469 arg5 = static_cast< double >(val5);
30470 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30471 if (!SWIG_IsOK(res6)) {
30472 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
30474 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
30475 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30476 if (!SWIG_IsOK(res7)) {
30477 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
30479 arg7 = reinterpret_cast< Hex::Vector * >(argp7);
30480 ecode8 = SWIG_AsVal_double(obj7, &val8);
30481 if (!SWIG_IsOK(ecode8)) {
30482 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
30484 arg8 = static_cast< double >(val8);
30485 ecode9 = SWIG_AsVal_double(obj8, &val9);
30486 if (!SWIG_IsOK(ecode9)) {
30487 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
30489 arg9 = static_cast< double >(val9);
30490 result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
30491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30498 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30499 PyObject *resultobj = 0;
30500 Hex::Document *arg1 = (Hex::Document *) 0 ;
30501 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30502 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30506 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
30507 Hex::Vector *arg8 = (Hex::Vector *) 0 ;
30533 PyObject * obj0 = 0 ;
30534 PyObject * obj1 = 0 ;
30535 PyObject * obj2 = 0 ;
30536 PyObject * obj3 = 0 ;
30537 PyObject * obj4 = 0 ;
30538 PyObject * obj5 = 0 ;
30539 PyObject * obj6 = 0 ;
30540 PyObject * obj7 = 0 ;
30541 PyObject * obj8 = 0 ;
30542 PyObject * obj9 = 0 ;
30543 PyObject * obj10 = 0 ;
30544 Hex::BiCylinder *result = 0 ;
30546 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
30547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
30551 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30553 if (!SWIG_IsOK(res2)) {
30554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
30556 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30557 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30558 if (!SWIG_IsOK(res3)) {
30559 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
30561 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30562 ecode4 = SWIG_AsVal_double(obj3, &val4);
30563 if (!SWIG_IsOK(ecode4)) {
30564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
30566 arg4 = static_cast< double >(val4);
30567 ecode5 = SWIG_AsVal_double(obj4, &val5);
30568 if (!SWIG_IsOK(ecode5)) {
30569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
30571 arg5 = static_cast< double >(val5);
30572 ecode6 = SWIG_AsVal_double(obj5, &val6);
30573 if (!SWIG_IsOK(ecode6)) {
30574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
30576 arg6 = static_cast< double >(val6);
30577 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30578 if (!SWIG_IsOK(res7)) {
30579 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
30581 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
30582 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30583 if (!SWIG_IsOK(res8)) {
30584 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
30586 arg8 = reinterpret_cast< Hex::Vector * >(argp8);
30587 ecode9 = SWIG_AsVal_double(obj8, &val9);
30588 if (!SWIG_IsOK(ecode9)) {
30589 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
30591 arg9 = static_cast< double >(val9);
30592 ecode10 = SWIG_AsVal_double(obj9, &val10);
30593 if (!SWIG_IsOK(ecode10)) {
30594 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
30596 arg10 = static_cast< double >(val10);
30597 ecode11 = SWIG_AsVal_double(obj10, &val11);
30598 if (!SWIG_IsOK(ecode11)) {
30599 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
30601 arg11 = static_cast< double >(val11);
30602 result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
30603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
30610 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30611 PyObject *resultobj = 0;
30612 Hex::Document *arg1 = (Hex::Document *) 0 ;
30613 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 PyObject * obj2 = 0 ;
30624 Hex::Elements *result = 0 ;
30626 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
30627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30628 if (!SWIG_IsOK(res1)) {
30629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
30631 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
30633 if (!SWIG_IsOK(res2)) {
30634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
30636 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30637 ecode3 = SWIG_AsVal_int(obj2, &val3);
30638 if (!SWIG_IsOK(ecode3)) {
30639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
30641 arg3 = static_cast< int >(val3);
30642 result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
30643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30650 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30651 PyObject *resultobj = 0;
30652 Hex::Document *arg1 = (Hex::Document *) 0 ;
30653 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30654 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30667 PyObject * obj0 = 0 ;
30668 PyObject * obj1 = 0 ;
30669 PyObject * obj2 = 0 ;
30670 PyObject * obj3 = 0 ;
30671 PyObject * obj4 = 0 ;
30672 Hex::Elements *result = 0 ;
30674 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30676 if (!SWIG_IsOK(res1)) {
30677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
30679 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
30681 if (!SWIG_IsOK(res2)) {
30682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
30684 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30685 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30686 if (!SWIG_IsOK(res3)) {
30687 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30689 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30690 ecode4 = SWIG_AsVal_double(obj3, &val4);
30691 if (!SWIG_IsOK(ecode4)) {
30692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
30694 arg4 = static_cast< double >(val4);
30695 ecode5 = SWIG_AsVal_int(obj4, &val5);
30696 if (!SWIG_IsOK(ecode5)) {
30697 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
30699 arg5 = static_cast< int >(val5);
30700 result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
30701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30708 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30709 PyObject *resultobj = 0;
30710 Hex::Document *arg1 = (Hex::Document *) 0 ;
30711 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30712 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30713 Hex::RealVector arg4 ;
30720 PyObject * obj0 = 0 ;
30721 PyObject * obj1 = 0 ;
30722 PyObject * obj2 = 0 ;
30723 PyObject * obj3 = 0 ;
30724 Hex::Elements *result = 0 ;
30726 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
30731 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
30733 if (!SWIG_IsOK(res2)) {
30734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
30736 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30737 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30738 if (!SWIG_IsOK(res3)) {
30739 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
30741 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30743 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30744 int res = swig::asptr(obj3, &ptr);
30745 if (!SWIG_IsOK(res) || !ptr) {
30746 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
30749 if (SWIG_IsNewObj(res)) delete ptr;
30751 result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
30752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30759 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30760 PyObject *resultobj = 0;
30761 Hex::Document *arg1 = (Hex::Document *) 0 ;
30768 PyObject * obj0 = 0 ;
30769 PyObject * obj1 = 0 ;
30770 PyObject * obj2 = 0 ;
30771 Hex::Elements *result = 0 ;
30773 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
30774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30775 if (!SWIG_IsOK(res1)) {
30776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
30778 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30780 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30781 int res = swig::asptr(obj1, &ptr);
30782 if (!SWIG_IsOK(res) || !ptr) {
30783 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
30786 if (SWIG_IsNewObj(res)) delete ptr;
30788 ecode3 = SWIG_AsVal_int(obj2, &val3);
30789 if (!SWIG_IsOK(ecode3)) {
30790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
30792 arg3 = static_cast< int >(val3);
30793 result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
30794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30801 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30802 PyObject *resultobj = 0;
30803 Hex::Document *arg1 = (Hex::Document *) 0 ;
30805 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30816 PyObject * obj0 = 0 ;
30817 PyObject * obj1 = 0 ;
30818 PyObject * obj2 = 0 ;
30819 PyObject * obj3 = 0 ;
30820 PyObject * obj4 = 0 ;
30821 Hex::Elements *result = 0 ;
30823 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30825 if (!SWIG_IsOK(res1)) {
30826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
30828 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30830 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30831 int res = swig::asptr(obj1, &ptr);
30832 if (!SWIG_IsOK(res) || !ptr) {
30833 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
30836 if (SWIG_IsNewObj(res)) delete ptr;
30838 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30839 if (!SWIG_IsOK(res3)) {
30840 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30842 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30843 ecode4 = SWIG_AsVal_double(obj3, &val4);
30844 if (!SWIG_IsOK(ecode4)) {
30845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
30847 arg4 = static_cast< double >(val4);
30848 ecode5 = SWIG_AsVal_int(obj4, &val5);
30849 if (!SWIG_IsOK(ecode5)) {
30850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
30852 arg5 = static_cast< int >(val5);
30853 result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
30854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30861 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30862 PyObject *resultobj = 0;
30863 Hex::Document *arg1 = (Hex::Document *) 0 ;
30865 Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30866 Hex::RealVector arg4 ;
30871 PyObject * obj0 = 0 ;
30872 PyObject * obj1 = 0 ;
30873 PyObject * obj2 = 0 ;
30874 PyObject * obj3 = 0 ;
30875 Hex::Elements *result = 0 ;
30877 if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30879 if (!SWIG_IsOK(res1)) {
30880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
30882 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30884 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30885 int res = swig::asptr(obj1, &ptr);
30886 if (!SWIG_IsOK(res) || !ptr) {
30887 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
30890 if (SWIG_IsNewObj(res)) delete ptr;
30892 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30893 if (!SWIG_IsOK(res3)) {
30894 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
30896 arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30898 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30899 int res = swig::asptr(obj3, &ptr);
30900 if (!SWIG_IsOK(res) || !ptr) {
30901 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
30904 if (SWIG_IsNewObj(res)) delete ptr;
30906 result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
30907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30914 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30915 PyObject *resultobj = 0;
30916 Hex::Document *arg1 = (Hex::Document *) 0 ;
30917 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30918 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
30919 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30934 PyObject * obj0 = 0 ;
30935 PyObject * obj1 = 0 ;
30936 PyObject * obj2 = 0 ;
30937 PyObject * obj3 = 0 ;
30938 PyObject * obj4 = 0 ;
30939 PyObject * obj5 = 0 ;
30940 Hex::Elements *result = 0 ;
30942 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
30944 if (!SWIG_IsOK(res1)) {
30945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
30947 arg1 = reinterpret_cast< Hex::Document * >(argp1);
30948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
30949 if (!SWIG_IsOK(res2)) {
30950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
30952 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30953 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
30954 if (!SWIG_IsOK(res3)) {
30955 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
30957 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
30958 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
30959 if (!SWIG_IsOK(res4)) {
30960 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30962 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30963 ecode5 = SWIG_AsVal_double(obj4, &val5);
30964 if (!SWIG_IsOK(ecode5)) {
30965 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
30967 arg5 = static_cast< double >(val5);
30968 ecode6 = SWIG_AsVal_int(obj5, &val6);
30969 if (!SWIG_IsOK(ecode6)) {
30970 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
30972 arg6 = static_cast< int >(val6);
30973 result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
30974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
30981 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982 PyObject *resultobj = 0;
30983 Hex::Document *arg1 = (Hex::Document *) 0 ;
30984 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30985 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
30986 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30987 Hex::RealVector arg5 ;
30996 PyObject * obj0 = 0 ;
30997 PyObject * obj1 = 0 ;
30998 PyObject * obj2 = 0 ;
30999 PyObject * obj3 = 0 ;
31000 PyObject * obj4 = 0 ;
31001 Hex::Elements *result = 0 ;
31003 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
31008 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31010 if (!SWIG_IsOK(res2)) {
31011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
31013 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31014 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31015 if (!SWIG_IsOK(res3)) {
31016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
31018 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31019 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
31020 if (!SWIG_IsOK(res4)) {
31021 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
31023 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31025 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
31026 int res = swig::asptr(obj4, &ptr);
31027 if (!SWIG_IsOK(res) || !ptr) {
31028 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
31031 if (SWIG_IsNewObj(res)) delete ptr;
31033 result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
31034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31041 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 Hex::Document *arg1 = (Hex::Document *) 0 ;
31045 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
31046 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 PyObject * obj4 = 0 ;
31064 PyObject * obj5 = 0 ;
31065 Hex::Elements *result = 0 ;
31067 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
31072 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31074 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31075 int res = swig::asptr(obj1, &ptr);
31076 if (!SWIG_IsOK(res) || !ptr) {
31077 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
31080 if (SWIG_IsNewObj(res)) delete ptr;
31082 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31083 if (!SWIG_IsOK(res3)) {
31084 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
31086 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31087 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
31088 if (!SWIG_IsOK(res4)) {
31089 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
31091 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31092 ecode5 = SWIG_AsVal_double(obj4, &val5);
31093 if (!SWIG_IsOK(ecode5)) {
31094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
31096 arg5 = static_cast< double >(val5);
31097 ecode6 = SWIG_AsVal_int(obj5, &val6);
31098 if (!SWIG_IsOK(ecode6)) {
31099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
31101 arg6 = static_cast< int >(val6);
31102 result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
31103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31110 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31111 PyObject *resultobj = 0;
31112 Hex::Document *arg1 = (Hex::Document *) 0 ;
31114 Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
31115 Hex::Vector *arg4 = (Hex::Vector *) 0 ;
31116 Hex::RealVector arg5 ;
31123 PyObject * obj0 = 0 ;
31124 PyObject * obj1 = 0 ;
31125 PyObject * obj2 = 0 ;
31126 PyObject * obj3 = 0 ;
31127 PyObject * obj4 = 0 ;
31128 Hex::Elements *result = 0 ;
31130 if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31132 if (!SWIG_IsOK(res1)) {
31133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31135 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31137 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31138 int res = swig::asptr(obj1, &ptr);
31139 if (!SWIG_IsOK(res) || !ptr) {
31140 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
31143 if (SWIG_IsNewObj(res)) delete ptr;
31145 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31146 if (!SWIG_IsOK(res3)) {
31147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
31149 arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31150 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 | 0 );
31151 if (!SWIG_IsOK(res4)) {
31152 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
31154 arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31156 std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
31157 int res = swig::asptr(obj4, &ptr);
31158 if (!SWIG_IsOK(res) || !ptr) {
31159 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
31162 if (SWIG_IsNewObj(res)) delete ptr;
31164 result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
31165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31172 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31173 PyObject *resultobj = 0;
31174 Hex::Document *arg1 = (Hex::Document *) 0 ;
31175 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31176 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31177 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31178 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31179 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31180 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31198 PyObject * obj0 = 0 ;
31199 PyObject * obj1 = 0 ;
31200 PyObject * obj2 = 0 ;
31201 PyObject * obj3 = 0 ;
31202 PyObject * obj4 = 0 ;
31203 PyObject * obj5 = 0 ;
31204 PyObject * obj6 = 0 ;
31205 PyObject * obj7 = 0 ;
31206 Hex::Elements *result = 0 ;
31208 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31210 if (!SWIG_IsOK(res1)) {
31211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
31213 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31214 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31215 if (!SWIG_IsOK(res2)) {
31216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
31218 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31219 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31220 if (!SWIG_IsOK(res3)) {
31221 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
31223 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31224 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31225 if (!SWIG_IsOK(res4)) {
31226 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
31228 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31229 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31230 if (!SWIG_IsOK(res5)) {
31231 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
31233 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31234 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31235 if (!SWIG_IsOK(res6)) {
31236 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
31238 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31239 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31240 if (!SWIG_IsOK(res7)) {
31241 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
31243 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31244 ecode8 = SWIG_AsVal_int(obj7, &val8);
31245 if (!SWIG_IsOK(ecode8)) {
31246 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
31248 arg8 = static_cast< int >(val8);
31249 result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
31250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31257 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31258 PyObject *resultobj = 0;
31259 Hex::Document *arg1 = (Hex::Document *) 0 ;
31261 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31262 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31263 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31264 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31265 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 PyObject * obj2 = 0 ;
31284 PyObject * obj3 = 0 ;
31285 PyObject * obj4 = 0 ;
31286 PyObject * obj5 = 0 ;
31287 PyObject * obj6 = 0 ;
31288 PyObject * obj7 = 0 ;
31289 Hex::Elements *result = 0 ;
31291 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
31296 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31298 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31299 int res = swig::asptr(obj1, &ptr);
31300 if (!SWIG_IsOK(res) || !ptr) {
31301 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
31304 if (SWIG_IsNewObj(res)) delete ptr;
31306 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31307 if (!SWIG_IsOK(res3)) {
31308 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
31310 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31311 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31312 if (!SWIG_IsOK(res4)) {
31313 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
31315 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31316 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31317 if (!SWIG_IsOK(res5)) {
31318 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
31320 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31321 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31322 if (!SWIG_IsOK(res6)) {
31323 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
31325 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31326 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31327 if (!SWIG_IsOK(res7)) {
31328 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
31330 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31331 ecode8 = SWIG_AsVal_int(obj7, &val8);
31332 if (!SWIG_IsOK(ecode8)) {
31333 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
31335 arg8 = static_cast< int >(val8);
31336 result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
31337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31344 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31345 PyObject *resultobj = 0;
31346 Hex::Document *arg1 = (Hex::Document *) 0 ;
31347 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31348 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31349 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31350 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31351 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31352 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31353 Hex::RealVector *arg8 = 0 ;
31370 PyObject * obj0 = 0 ;
31371 PyObject * obj1 = 0 ;
31372 PyObject * obj2 = 0 ;
31373 PyObject * obj3 = 0 ;
31374 PyObject * obj4 = 0 ;
31375 PyObject * obj5 = 0 ;
31376 PyObject * obj6 = 0 ;
31377 PyObject * obj7 = 0 ;
31378 Hex::Elements *result = 0 ;
31380 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31382 if (!SWIG_IsOK(res1)) {
31383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
31385 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31387 if (!SWIG_IsOK(res2)) {
31388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
31390 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31391 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31392 if (!SWIG_IsOK(res3)) {
31393 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
31395 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31396 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31397 if (!SWIG_IsOK(res4)) {
31398 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
31400 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31401 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31402 if (!SWIG_IsOK(res5)) {
31403 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
31405 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31406 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31407 if (!SWIG_IsOK(res6)) {
31408 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
31410 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31411 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31412 if (!SWIG_IsOK(res7)) {
31413 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
31415 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31416 res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
31417 if (!SWIG_IsOK(res8)) {
31418 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
31421 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
31423 arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
31424 result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
31425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31432 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433 PyObject *resultobj = 0;
31434 Hex::Document *arg1 = (Hex::Document *) 0 ;
31436 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31437 Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31438 Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31439 Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31440 Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31441 Hex::RealVector *arg8 = 0 ;
31456 PyObject * obj0 = 0 ;
31457 PyObject * obj1 = 0 ;
31458 PyObject * obj2 = 0 ;
31459 PyObject * obj3 = 0 ;
31460 PyObject * obj4 = 0 ;
31461 PyObject * obj5 = 0 ;
31462 PyObject * obj6 = 0 ;
31463 PyObject * obj7 = 0 ;
31464 Hex::Elements *result = 0 ;
31466 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31468 if (!SWIG_IsOK(res1)) {
31469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31471 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31473 std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31474 int res = swig::asptr(obj1, &ptr);
31475 if (!SWIG_IsOK(res) || !ptr) {
31476 SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
31479 if (SWIG_IsNewObj(res)) delete ptr;
31481 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31482 if (!SWIG_IsOK(res3)) {
31483 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
31485 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31486 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31487 if (!SWIG_IsOK(res4)) {
31488 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
31490 arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31491 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31492 if (!SWIG_IsOK(res5)) {
31493 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
31495 arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31496 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31497 if (!SWIG_IsOK(res6)) {
31498 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
31500 arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31501 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31502 if (!SWIG_IsOK(res7)) {
31503 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
31505 arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31506 res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
31507 if (!SWIG_IsOK(res8)) {
31508 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
31511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
31513 arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
31514 result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
31515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31522 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31523 PyObject *resultobj = 0;
31524 Hex::Document *arg1 = (Hex::Document *) 0 ;
31525 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
31533 PyObject * obj0 = 0 ;
31534 PyObject * obj1 = 0 ;
31535 PyObject * obj2 = 0 ;
31536 Hex::Elements *result = 0 ;
31538 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
31539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
31543 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
31545 if (!SWIG_IsOK(res2)) {
31546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
31548 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
31549 ecode3 = SWIG_AsVal_int(obj2, &val3);
31550 if (!SWIG_IsOK(ecode3)) {
31551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
31553 arg3 = static_cast< int >(val3);
31554 result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
31555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31562 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31563 PyObject *resultobj = 0;
31564 Hex::Document *arg1 = (Hex::Document *) 0 ;
31565 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
31566 Hex::RealVector *arg3 = 0 ;
31573 PyObject * obj0 = 0 ;
31574 PyObject * obj1 = 0 ;
31575 PyObject * obj2 = 0 ;
31576 Hex::Elements *result = 0 ;
31578 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
31579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31580 if (!SWIG_IsOK(res1)) {
31581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
31583 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
31585 if (!SWIG_IsOK(res2)) {
31586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
31588 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
31589 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
31590 if (!SWIG_IsOK(res3)) {
31591 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
31594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
31596 arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
31597 result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
31598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
31605 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 Hex::Document *arg1 = (Hex::Document *) 0 ;
31608 cpchar arg2 = (cpchar) 0 ;
31609 Hex::EnumGroup arg3 ;
31617 PyObject * obj0 = 0 ;
31618 PyObject * obj1 = 0 ;
31619 PyObject * obj2 = 0 ;
31620 Hex::Group *result = 0 ;
31622 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
31623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31624 if (!SWIG_IsOK(res1)) {
31625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
31627 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31628 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31629 if (!SWIG_IsOK(res2)) {
31630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
31632 arg2 = reinterpret_cast< cpchar >(buf2);
31633 ecode3 = SWIG_AsVal_int(obj2, &val3);
31634 if (!SWIG_IsOK(ecode3)) {
31635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
31637 arg3 = static_cast< Hex::EnumGroup >(val3);
31638 result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
31639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 | 0 );
31640 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31643 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31648 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31649 PyObject *resultobj = 0;
31650 Hex::Document *arg1 = (Hex::Document *) 0 ;
31653 PyObject * obj0 = 0 ;
31656 if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
31657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
31661 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31662 result = (bool)(arg1)->isSaved();
31663 resultobj = SWIG_From_bool(static_cast< bool >(result));
31670 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31671 PyObject *resultobj = 0;
31672 Hex::Document *arg1 = (Hex::Document *) 0 ;
31673 pfile arg2 = (pfile) 0 ;
31678 PyObject * obj0 = 0 ;
31679 PyObject * obj1 = 0 ;
31682 if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
31683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31684 if (!SWIG_IsOK(res1)) {
31685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
31687 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 | 0 );
31689 if (!SWIG_IsOK(res2)) {
31690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
31692 arg2 = reinterpret_cast< pfile >(argp2);
31693 result = (int)(arg1)->appendXml(arg2);
31694 resultobj = SWIG_From_int(static_cast< int >(result));
31701 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 PyObject *resultobj = 0;
31703 Hex::Document *arg1 = (Hex::Document *) 0 ;
31706 PyObject * obj0 = 0 ;
31709 if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
31710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31711 if (!SWIG_IsOK(res1)) {
31712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
31714 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31715 result = (cpchar)(arg1)->getXml();
31716 resultobj = SWIG_FromCharPtr((const char *)result);
31723 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31724 PyObject *resultobj = 0;
31725 Hex::Document *arg1 = (Hex::Document *) 0 ;
31728 PyObject * obj0 = 0 ;
31731 if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
31732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
31736 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31737 result = (int)(arg1)->getLevel();
31738 resultobj = SWIG_From_int(static_cast< int >(result));
31745 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31746 PyObject *resultobj = 0;
31747 Hex::Document *arg1 = (Hex::Document *) 0 ;
31753 PyObject * obj0 = 0 ;
31754 PyObject * obj1 = 0 ;
31755 Hex::Vertex *result = 0 ;
31757 if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
31758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
31762 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31763 ecode2 = SWIG_AsVal_int(obj1, &val2);
31764 if (!SWIG_IsOK(ecode2)) {
31765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
31767 arg2 = static_cast< int >(val2);
31768 result = (Hex::Vertex *)(arg1)->findVertex(arg2);
31769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
31776 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
31778 PyObject *argv[5] = {
31783 if (!PyTuple_Check(args)) SWIG_fail;
31784 argc = args ? PyObject_Length(args) : 0;
31785 for (ii = 0; (ii < 4) && (ii < argc); ii++) {
31786 argv[ii] = PyTuple_GET_ITEM(args,ii);
31791 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31792 _v = SWIG_CheckState(res);
31795 int res = SWIG_AsVal_int(argv[1], NULL);
31796 _v = SWIG_CheckState(res);
31799 return _wrap_Document_findVertex__SWIG_1(self, args);
31806 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31807 _v = SWIG_CheckState(res);
31810 int res = SWIG_AsVal_double(argv[1], NULL);
31811 _v = SWIG_CheckState(res);
31815 int res = SWIG_AsVal_double(argv[2], NULL);
31816 _v = SWIG_CheckState(res);
31820 int res = SWIG_AsVal_double(argv[3], NULL);
31821 _v = SWIG_CheckState(res);
31824 return _wrap_Document_findVertex__SWIG_0(self, args);
31832 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_findVertex'.\n"
31833 " Possible C/C++ prototypes are:\n"
31834 " Hex::Document::findVertex(double,double,double)\n"
31835 " Hex::Document::findVertex(int)\n");
31840 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31841 PyObject *resultobj = 0;
31842 Hex::Document *arg1 = (Hex::Document *) 0 ;
31843 Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31844 Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31851 PyObject * obj0 = 0 ;
31852 PyObject * obj1 = 0 ;
31853 PyObject * obj2 = 0 ;
31856 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
31857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31858 if (!SWIG_IsOK(res1)) {
31859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31861 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31863 if (!SWIG_IsOK(res2)) {
31864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
31866 arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31867 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 | 0 );
31868 if (!SWIG_IsOK(res3)) {
31869 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
31871 arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31872 result = (int)(arg1)->closeQuads(arg2,arg3);
31873 resultobj = SWIG_From_int(static_cast< int >(result));
31880 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 Hex::Document *arg1 = (Hex::Document *) 0 ;
31883 Hex::Law *arg2 = (Hex::Law *) 0 ;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 Hex::Law *result = 0 ;
31892 if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
31893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31894 if (!SWIG_IsOK(res1)) {
31895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
31897 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
31899 if (!SWIG_IsOK(res2)) {
31900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
31902 arg2 = reinterpret_cast< Hex::Law * >(argp2);
31903 result = (Hex::Law *)(arg1)->addLaw(arg2);
31904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
31911 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
31913 PyObject *argv[4] = {
31918 if (!PyTuple_Check(args)) SWIG_fail;
31919 argc = args ? PyObject_Length(args) : 0;
31920 for (ii = 0; (ii < 3) && (ii < argc); ii++) {
31921 argv[ii] = PyTuple_GET_ITEM(args,ii);
31926 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31927 _v = SWIG_CheckState(res);
31930 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
31931 _v = SWIG_CheckState(res);
31933 return _wrap_Document_addLaw__SWIG_1(self, args);
31940 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31941 _v = SWIG_CheckState(res);
31943 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
31944 _v = SWIG_CheckState(res);
31947 int res = SWIG_AsVal_int(argv[2], NULL);
31948 _v = SWIG_CheckState(res);
31951 return _wrap_Document_addLaw__SWIG_0(self, args);
31958 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addLaw'.\n"
31959 " Possible C/C++ prototypes are:\n"
31960 " Hex::Document::addLaw(char const *,int)\n"
31961 " Hex::Document::addLaw(Hex::Law *)\n");
31966 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 Hex::Document *arg1 = (Hex::Document *) 0 ;
31971 PyObject * obj0 = 0 ;
31974 if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
31975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
31979 arg1 = reinterpret_cast< Hex::Document * >(argp1);
31980 result = (int)(arg1)->checkAssociations();
31981 resultobj = SWIG_From_int(static_cast< int >(result));
31988 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31989 PyObject *resultobj = 0;
31990 Hex::Document *arg1 = (Hex::Document *) 0 ;
31992 char *arg3 = (char *) 0 ;
32000 PyObject * obj0 = 0 ;
32001 PyObject * obj1 = 0 ;
32002 PyObject * obj2 = 0 ;
32003 Hex::NewShape *result = 0 ;
32005 if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
32006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
32007 if (!SWIG_IsOK(res1)) {
32008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
32010 arg1 = reinterpret_cast< Hex::Document * >(argp1);
32011 ecode2 = SWIG_AsVal_long(obj1, &val2);
32012 if (!SWIG_IsOK(ecode2)) {
32013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
32015 arg2 = static_cast< long >(val2);
32016 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
32017 if (!SWIG_IsOK(res3)) {
32018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
32020 arg3 = reinterpret_cast< char * >(buf3);
32021 result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
32022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 | 0 );
32023 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32026 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32031 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32032 PyObject *resultobj = 0;
32033 Hex::Document *arg1 = (Hex::Document *) 0 ;
32036 PyObject * obj0 = 0 ;
32038 if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
32039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
32043 arg1 = reinterpret_cast< Hex::Document * >(argp1);
32045 resultobj = SWIG_Py_Void();
32052 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32054 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32055 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
32056 return SWIG_Py_Void();
32059 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060 PyObject *resultobj = 0;
32061 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32064 PyObject * obj0 = 0 ;
32065 Hex::Edges *result = 0 ;
32067 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
32068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
32072 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32073 result = (Hex::Edges *) &(arg1)->getEdges();
32074 resultobj = swig::from(static_cast< std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > >(*result));
32081 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082 PyObject *resultobj = 0;
32083 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32086 PyObject * obj0 = 0 ;
32087 Hex::Law *result = 0 ;
32089 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
32090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32094 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32095 result = (Hex::Law *)(arg1)->getLaw();
32096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 | 0 );
32103 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32104 PyObject *resultobj = 0;
32105 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32108 PyObject * obj0 = 0 ;
32111 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
32112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32113 if (!SWIG_IsOK(res1)) {
32114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
32116 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32117 result = (bool)(arg1)->getWay();
32118 resultobj = SWIG_From_bool(static_cast< bool >(result));
32125 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126 PyObject *resultobj = 0;
32127 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32133 PyObject * obj0 = 0 ;
32134 PyObject * obj1 = 0 ;
32136 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
32137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32138 if (!SWIG_IsOK(res1)) {
32139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
32141 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32142 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32143 if (!SWIG_IsOK(ecode2)) {
32144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
32146 arg2 = static_cast< bool >(val2);
32147 (arg1)->setWay(arg2);
32148 resultobj = SWIG_Py_Void();
32155 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156 PyObject *resultobj = 0;
32157 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32158 Hex::Law *arg2 = (Hex::Law *) 0 ;
32163 PyObject * obj0 = 0 ;
32164 PyObject * obj1 = 0 ;
32167 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
32168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32172 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 | 0 );
32174 if (!SWIG_IsOK(res2)) {
32175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
32177 arg2 = reinterpret_cast< Hex::Law * >(argp2);
32178 result = (int)(arg1)->setLaw(arg2);
32179 resultobj = SWIG_From_int(static_cast< int >(result));
32186 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 PyObject *resultobj = 0;
32188 Hex::Document *arg1 = (Hex::Document *) 0 ;
32191 PyObject * obj0 = 0 ;
32192 Hex::Propagation *result = 0 ;
32194 if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
32195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
32196 if (!SWIG_IsOK(res1)) {
32197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
32199 arg1 = reinterpret_cast< Hex::Document * >(argp1);
32200 result = (Hex::Propagation *)new Hex::Propagation(arg1);
32201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW | 0 );
32208 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32211 Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
32216 PyObject * obj0 = 0 ;
32217 PyObject * obj1 = 0 ;
32219 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
32220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32221 if (!SWIG_IsOK(res1)) {
32222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
32224 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 | 0 );
32226 if (!SWIG_IsOK(res2)) {
32227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
32229 arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
32230 (arg1)->saveXml(arg2);
32231 resultobj = SWIG_Py_Void();
32238 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32239 PyObject *resultobj = 0;
32240 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32241 Hex::Edge *arg2 = (Hex::Edge *) 0 ;
32246 PyObject * obj0 = 0 ;
32247 PyObject * obj1 = 0 ;
32249 if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
32250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32251 if (!SWIG_IsOK(res1)) {
32252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
32254 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 | 0 );
32256 if (!SWIG_IsOK(res2)) {
32257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
32259 arg2 = reinterpret_cast< Hex::Edge * >(argp2);
32260 (arg1)->addEdge(arg2);
32261 resultobj = SWIG_Py_Void();
32268 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32269 PyObject *resultobj = 0;
32270 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32273 PyObject * obj0 = 0 ;
32275 if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
32276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32280 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32282 resultobj = SWIG_Py_Void();
32289 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32290 PyObject *resultobj = 0;
32291 Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32294 PyObject * obj0 = 0 ;
32296 if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
32297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN | 0 );
32298 if (!SWIG_IsOK(res1)) {
32299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
32301 arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32303 resultobj = SWIG_Py_Void();
32310 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32312 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32313 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
32314 return SWIG_Py_Void();
32317 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318 PyObject *resultobj = 0;
32319 Hex::Hex *result = 0 ;
32321 if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
32322 result = (Hex::Hex *)Hex::hex_instance();
32323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 | 0 );
32330 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 Hex::Hex *result = 0 ;
32334 if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
32335 result = (Hex::Hex *)Hex::Hex::getInstance();
32336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 | 0 );
32343 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344 PyObject *resultobj = 0;
32345 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32348 PyObject * obj0 = 0 ;
32351 if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
32352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32356 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32357 result = (int)(arg1)->countDocument();
32358 resultobj = SWIG_From_int(static_cast< int >(result));
32365 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366 PyObject *resultobj = 0;
32367 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32373 PyObject * obj0 = 0 ;
32374 PyObject * obj1 = 0 ;
32375 Hex::Document *result = 0 ;
32377 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
32378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32379 if (!SWIG_IsOK(res1)) {
32380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32382 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32383 ecode2 = SWIG_AsVal_int(obj1, &val2);
32384 if (!SWIG_IsOK(ecode2)) {
32385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
32387 arg2 = static_cast< int >(val2);
32388 result = (Hex::Document *)(arg1)->getDocument(arg2);
32389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32396 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32397 PyObject *resultobj = 0;
32398 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32399 Hex::Document *arg2 = (Hex::Document *) 0 ;
32404 PyObject * obj0 = 0 ;
32405 PyObject * obj1 = 0 ;
32407 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
32408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32412 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 | 0 );
32414 if (!SWIG_IsOK(res2)) {
32415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
32417 arg2 = reinterpret_cast< Hex::Document * >(argp2);
32418 (arg1)->removeDocument(arg2);
32419 resultobj = SWIG_Py_Void();
32426 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32427 PyObject *resultobj = 0;
32428 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32429 cpchar arg2 = (cpchar) 0 ;
32435 PyObject * obj0 = 0 ;
32436 PyObject * obj1 = 0 ;
32437 Hex::Document *result = 0 ;
32439 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
32440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32441 if (!SWIG_IsOK(res1)) {
32442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32444 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32445 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32446 if (!SWIG_IsOK(res2)) {
32447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
32449 arg2 = reinterpret_cast< cpchar >(buf2);
32450 result = (Hex::Document *)(arg1)->addDocument(arg2);
32451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32452 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32455 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32460 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32461 PyObject *resultobj = 0;
32462 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32465 PyObject * obj0 = 0 ;
32466 Hex::Document *result = 0 ;
32468 if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
32469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32470 if (!SWIG_IsOK(res1)) {
32471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32473 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32474 result = (Hex::Document *)(arg1)->addDocument();
32475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32482 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
32484 PyObject *argv[3] = {
32489 if (!PyTuple_Check(args)) SWIG_fail;
32490 argc = args ? PyObject_Length(args) : 0;
32491 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
32492 argv[ii] = PyTuple_GET_ITEM(args,ii);
32497 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32498 _v = SWIG_CheckState(res);
32500 return _wrap_Hex_addDocument__SWIG_1(self, args);
32506 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32507 _v = SWIG_CheckState(res);
32509 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
32510 _v = SWIG_CheckState(res);
32512 return _wrap_Hex_addDocument__SWIG_0(self, args);
32518 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hex_addDocument'.\n"
32519 " Possible C/C++ prototypes are:\n"
32520 " Hex::Hex::addDocument(cpchar)\n"
32521 " Hex::Hex::addDocument()\n");
32526 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32527 PyObject *resultobj = 0;
32528 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32529 cpchar arg2 = (cpchar) 0 ;
32535 PyObject * obj0 = 0 ;
32536 PyObject * obj1 = 0 ;
32537 Hex::Document *result = 0 ;
32539 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
32540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32544 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32545 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32546 if (!SWIG_IsOK(res2)) {
32547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
32549 arg2 = reinterpret_cast< cpchar >(buf2);
32550 result = (Hex::Document *)(arg1)->loadDocument(arg2);
32551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32552 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32555 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32560 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32561 PyObject *resultobj = 0;
32562 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32563 cpchar arg2 = (cpchar) 0 ;
32569 PyObject * obj0 = 0 ;
32570 PyObject * obj1 = 0 ;
32571 Hex::Document *result = 0 ;
32573 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
32574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32578 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32579 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32580 if (!SWIG_IsOK(res2)) {
32581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
32583 arg2 = reinterpret_cast< cpchar >(buf2);
32584 result = (Hex::Document *)(arg1)->findDocument(arg2);
32585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32586 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32589 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32594 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32595 PyObject *resultobj = 0;
32596 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32597 std::string *arg2 = 0 ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 Hex::Document *result = 0 ;
32606 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
32607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32608 if (!SWIG_IsOK(res1)) {
32609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32611 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string, 0 | 0);
32613 if (!SWIG_IsOK(res2)) {
32614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
32617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
32619 arg2 = reinterpret_cast< std::string * >(argp2);
32620 result = (Hex::Document *)(arg1)->findDocument((std::string const &)*arg2);
32621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 | 0 );
32628 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
32630 PyObject *argv[3] = {
32635 if (!PyTuple_Check(args)) SWIG_fail;
32636 argc = args ? PyObject_Length(args) : 0;
32637 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
32638 argv[ii] = PyTuple_GET_ITEM(args,ii);
32643 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32644 _v = SWIG_CheckState(res);
32646 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
32647 _v = SWIG_CheckState(res);
32649 return _wrap_Hex_findDocument__SWIG_1(self, args);
32656 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32657 _v = SWIG_CheckState(res);
32659 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
32660 _v = SWIG_CheckState(res);
32662 return _wrap_Hex_findDocument__SWIG_0(self, args);
32668 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hex_findDocument'.\n"
32669 " Possible C/C++ prototypes are:\n"
32670 " Hex::Hex::findDocument(cpchar)\n"
32671 " Hex::Hex::findDocument(string const &)\n");
32676 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *resultobj = 0;
32678 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32681 PyObject * obj0 = 0 ;
32683 if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
32684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
32688 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32690 resultobj = SWIG_Py_Void();
32697 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32698 PyObject *resultobj = 0;
32699 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32702 PyObject * obj0 = 0 ;
32705 if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
32706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32707 if (!SWIG_IsOK(res1)) {
32708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
32710 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32711 result = (int)(arg1)->sizeofMessage();
32712 resultobj = SWIG_From_int(static_cast< int >(result));
32719 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720 PyObject *resultobj = 0;
32721 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32727 PyObject * obj0 = 0 ;
32728 PyObject * obj1 = 0 ;
32731 if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
32732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
32733 if (!SWIG_IsOK(res1)) {
32734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
32736 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32737 ecode2 = SWIG_AsVal_int(obj1, &val2);
32738 if (!SWIG_IsOK(ecode2)) {
32739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
32741 arg2 = static_cast< int >(val2);
32742 result = (cpchar)(arg1)->getMessageLine(arg2);
32743 resultobj = SWIG_FromCharPtr((const char *)result);
32750 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 Hex::Hex *result = 0 ;
32754 if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
32755 result = (Hex::Hex *)new Hex::Hex();
32756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW | 0 );
32763 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764 PyObject *resultobj = 0;
32765 Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32768 PyObject * obj0 = 0 ;
32770 if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
32771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN | 0 );
32772 if (!SWIG_IsOK(res1)) {
32773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
32775 arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32777 resultobj = SWIG_Py_Void();
32784 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32786 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32787 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
32788 return SWIG_Py_Void();
32791 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792 PyObject *resultobj = 0;
32794 if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
32796 resultobj = SWIG_Py_Void();
32803 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804 PyObject *resultobj = 0;
32805 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32811 PyObject * obj0 = 0 ;
32812 PyObject * obj1 = 0 ;
32813 Hex::Hexa *result = 0 ;
32815 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
32816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32817 if (!SWIG_IsOK(res1)) {
32818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
32820 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32821 ecode2 = SWIG_AsVal_int(obj1, &val2);
32822 if (!SWIG_IsOK(ecode2)) {
32823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
32825 arg2 = static_cast< int >(val2);
32826 result = (Hex::Hexa *)(arg1)->getHexa(arg2);
32827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
32834 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32835 PyObject *resultobj = 0;
32836 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 Hex::Quad *result = 0 ;
32846 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
32847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
32851 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32852 ecode2 = SWIG_AsVal_int(obj1, &val2);
32853 if (!SWIG_IsOK(ecode2)) {
32854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
32856 arg2 = static_cast< int >(val2);
32857 result = (Hex::Quad *)(arg1)->getQuad(arg2);
32858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
32865 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32866 PyObject *resultobj = 0;
32867 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32873 PyObject * obj0 = 0 ;
32874 PyObject * obj1 = 0 ;
32875 Hex::Edge *result = 0 ;
32877 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
32878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32879 if (!SWIG_IsOK(res1)) {
32880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
32882 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32883 ecode2 = SWIG_AsVal_int(obj1, &val2);
32884 if (!SWIG_IsOK(ecode2)) {
32885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
32887 arg2 = static_cast< int >(val2);
32888 result = (Hex::Edge *)(arg1)->getEdge(arg2);
32889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
32896 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32897 PyObject *resultobj = 0;
32898 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32904 PyObject * obj0 = 0 ;
32905 PyObject * obj1 = 0 ;
32906 Hex::Vertex *result = 0 ;
32908 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
32909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32910 if (!SWIG_IsOK(res1)) {
32911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
32913 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32914 ecode2 = SWIG_AsVal_int(obj1, &val2);
32915 if (!SWIG_IsOK(ecode2)) {
32916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
32918 arg2 = static_cast< int >(val2);
32919 result = (Hex::Vertex *)(arg1)->getVertex(arg2);
32920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
32927 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32928 PyObject *resultobj = 0;
32929 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32941 PyObject * obj0 = 0 ;
32942 PyObject * obj1 = 0 ;
32943 PyObject * obj2 = 0 ;
32944 PyObject * obj3 = 0 ;
32945 Hex::Hexa *result = 0 ;
32947 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32949 if (!SWIG_IsOK(res1)) {
32950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
32952 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32953 ecode2 = SWIG_AsVal_int(obj1, &val2);
32954 if (!SWIG_IsOK(ecode2)) {
32955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
32957 arg2 = static_cast< int >(val2);
32958 ecode3 = SWIG_AsVal_int(obj2, &val3);
32959 if (!SWIG_IsOK(ecode3)) {
32960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
32962 arg3 = static_cast< int >(val3);
32963 ecode4 = SWIG_AsVal_int(obj3, &val4);
32964 if (!SWIG_IsOK(ecode4)) {
32965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
32967 arg4 = static_cast< int >(val4);
32968 result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
32969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
32976 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32977 PyObject *resultobj = 0;
32978 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32990 PyObject * obj0 = 0 ;
32991 PyObject * obj1 = 0 ;
32992 PyObject * obj2 = 0 ;
32993 PyObject * obj3 = 0 ;
32994 Hex::Quad *result = 0 ;
32996 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
32998 if (!SWIG_IsOK(res1)) {
32999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
33001 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33002 ecode2 = SWIG_AsVal_int(obj1, &val2);
33003 if (!SWIG_IsOK(ecode2)) {
33004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
33006 arg2 = static_cast< int >(val2);
33007 ecode3 = SWIG_AsVal_int(obj2, &val3);
33008 if (!SWIG_IsOK(ecode3)) {
33009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
33011 arg3 = static_cast< int >(val3);
33012 ecode4 = SWIG_AsVal_int(obj3, &val4);
33013 if (!SWIG_IsOK(ecode4)) {
33014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
33016 arg4 = static_cast< int >(val4);
33017 result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
33018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33025 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33026 PyObject *resultobj = 0;
33027 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 PyObject * obj2 = 0 ;
33042 PyObject * obj3 = 0 ;
33043 Hex::Quad *result = 0 ;
33045 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
33050 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33051 ecode2 = SWIG_AsVal_int(obj1, &val2);
33052 if (!SWIG_IsOK(ecode2)) {
33053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
33055 arg2 = static_cast< int >(val2);
33056 ecode3 = SWIG_AsVal_int(obj2, &val3);
33057 if (!SWIG_IsOK(ecode3)) {
33058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
33060 arg3 = static_cast< int >(val3);
33061 ecode4 = SWIG_AsVal_int(obj3, &val4);
33062 if (!SWIG_IsOK(ecode4)) {
33063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
33065 arg4 = static_cast< int >(val4);
33066 result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
33067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33074 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33075 PyObject *resultobj = 0;
33076 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33088 PyObject * obj0 = 0 ;
33089 PyObject * obj1 = 0 ;
33090 PyObject * obj2 = 0 ;
33091 PyObject * obj3 = 0 ;
33092 Hex::Quad *result = 0 ;
33094 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33096 if (!SWIG_IsOK(res1)) {
33097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
33099 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33100 ecode2 = SWIG_AsVal_int(obj1, &val2);
33101 if (!SWIG_IsOK(ecode2)) {
33102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
33104 arg2 = static_cast< int >(val2);
33105 ecode3 = SWIG_AsVal_int(obj2, &val3);
33106 if (!SWIG_IsOK(ecode3)) {
33107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
33109 arg3 = static_cast< int >(val3);
33110 ecode4 = SWIG_AsVal_int(obj3, &val4);
33111 if (!SWIG_IsOK(ecode4)) {
33112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
33114 arg4 = static_cast< int >(val4);
33115 result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
33116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33123 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33124 PyObject *resultobj = 0;
33125 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33137 PyObject * obj0 = 0 ;
33138 PyObject * obj1 = 0 ;
33139 PyObject * obj2 = 0 ;
33140 PyObject * obj3 = 0 ;
33141 Hex::Edge *result = 0 ;
33143 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
33148 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33149 ecode2 = SWIG_AsVal_int(obj1, &val2);
33150 if (!SWIG_IsOK(ecode2)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
33153 arg2 = static_cast< int >(val2);
33154 ecode3 = SWIG_AsVal_int(obj2, &val3);
33155 if (!SWIG_IsOK(ecode3)) {
33156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
33158 arg3 = static_cast< int >(val3);
33159 ecode4 = SWIG_AsVal_int(obj3, &val4);
33160 if (!SWIG_IsOK(ecode4)) {
33161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
33163 arg4 = static_cast< int >(val4);
33164 result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
33165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
33172 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33173 PyObject *resultobj = 0;
33174 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33186 PyObject * obj0 = 0 ;
33187 PyObject * obj1 = 0 ;
33188 PyObject * obj2 = 0 ;
33189 PyObject * obj3 = 0 ;
33190 Hex::Edge *result = 0 ;
33192 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33194 if (!SWIG_IsOK(res1)) {
33195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
33197 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33198 ecode2 = SWIG_AsVal_int(obj1, &val2);
33199 if (!SWIG_IsOK(ecode2)) {
33200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
33202 arg2 = static_cast< int >(val2);
33203 ecode3 = SWIG_AsVal_int(obj2, &val3);
33204 if (!SWIG_IsOK(ecode3)) {
33205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
33207 arg3 = static_cast< int >(val3);
33208 ecode4 = SWIG_AsVal_int(obj3, &val4);
33209 if (!SWIG_IsOK(ecode4)) {
33210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
33212 arg4 = static_cast< int >(val4);
33213 result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
33214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
33221 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222 PyObject *resultobj = 0;
33223 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 PyObject * obj2 = 0 ;
33238 PyObject * obj3 = 0 ;
33239 Hex::Edge *result = 0 ;
33241 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
33246 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33247 ecode2 = SWIG_AsVal_int(obj1, &val2);
33248 if (!SWIG_IsOK(ecode2)) {
33249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
33251 arg2 = static_cast< int >(val2);
33252 ecode3 = SWIG_AsVal_int(obj2, &val3);
33253 if (!SWIG_IsOK(ecode3)) {
33254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
33256 arg3 = static_cast< int >(val3);
33257 ecode4 = SWIG_AsVal_int(obj3, &val4);
33258 if (!SWIG_IsOK(ecode4)) {
33259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
33261 arg4 = static_cast< int >(val4);
33262 result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
33263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
33270 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33271 PyObject *resultobj = 0;
33272 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33284 PyObject * obj0 = 0 ;
33285 PyObject * obj1 = 0 ;
33286 PyObject * obj2 = 0 ;
33287 PyObject * obj3 = 0 ;
33288 Hex::Vertex *result = 0 ;
33290 if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33292 if (!SWIG_IsOK(res1)) {
33293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
33295 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33296 ecode2 = SWIG_AsVal_int(obj1, &val2);
33297 if (!SWIG_IsOK(ecode2)) {
33298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
33300 arg2 = static_cast< int >(val2);
33301 ecode3 = SWIG_AsVal_int(obj2, &val3);
33302 if (!SWIG_IsOK(ecode3)) {
33303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
33305 arg3 = static_cast< int >(val3);
33306 ecode4 = SWIG_AsVal_int(obj3, &val4);
33307 if (!SWIG_IsOK(ecode4)) {
33308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
33310 arg4 = static_cast< int >(val4);
33311 result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
33312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
33319 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33320 PyObject *resultobj = 0;
33321 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33324 PyObject * obj0 = 0 ;
33327 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
33328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33329 if (!SWIG_IsOK(res1)) {
33330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
33332 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33333 result = (int)(arg1)->countHexa();
33334 resultobj = SWIG_From_int(static_cast< int >(result));
33341 SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33342 PyObject *resultobj = 0;
33343 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33346 PyObject * obj0 = 0 ;
33349 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
33350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33351 if (!SWIG_IsOK(res1)) {
33352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
33354 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33355 result = (int)(arg1)->countQuad();
33356 resultobj = SWIG_From_int(static_cast< int >(result));
33363 SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33364 PyObject *resultobj = 0;
33365 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33368 PyObject * obj0 = 0 ;
33371 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
33372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33373 if (!SWIG_IsOK(res1)) {
33374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
33376 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33377 result = (int)(arg1)->countEdge();
33378 resultobj = SWIG_From_int(static_cast< int >(result));
33385 SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33386 PyObject *resultobj = 0;
33387 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33390 PyObject * obj0 = 0 ;
33393 if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
33394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33395 if (!SWIG_IsOK(res1)) {
33396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33398 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33399 result = (int)(arg1)->countVertex();
33400 resultobj = SWIG_From_int(static_cast< int >(result));
33407 SWIGINTERN PyObject *_wrap_Elements_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33408 PyObject *resultobj = 0;
33409 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33410 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
33415 PyObject * obj0 = 0 ;
33416 PyObject * obj1 = 0 ;
33417 Hex::Vertex *result = 0 ;
33419 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
33420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33424 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
33426 if (!SWIG_IsOK(res2)) {
33427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
33429 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
33430 result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
33431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
33438 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *resultobj = 0;
33440 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33441 Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33450 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33455 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
33457 if (!SWIG_IsOK(res2)) {
33458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
33460 arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
33461 result = (int)(arg1)->findVertex(arg2);
33462 resultobj = SWIG_From_int(static_cast< int >(result));
33469 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33470 PyObject *resultobj = 0;
33471 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33474 PyObject * obj0 = 0 ;
33476 if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
33477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33478 if (!SWIG_IsOK(res1)) {
33479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
33481 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33482 (arg1)->clearAssociation();
33483 resultobj = SWIG_Py_Void();
33490 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33491 PyObject *resultobj = 0;
33492 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33493 cpchar arg2 = (cpchar) 0 ;
33499 PyObject * obj0 = 0 ;
33500 PyObject * obj1 = 0 ;
33503 if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
33504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
33508 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33509 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33510 if (!SWIG_IsOK(res2)) {
33511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
33513 arg2 = reinterpret_cast< cpchar >(buf2);
33514 result = (int)(arg1)->saveVtk(arg2);
33515 resultobj = SWIG_From_int(static_cast< int >(result));
33516 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33519 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33524 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33525 PyObject *resultobj = 0;
33526 Hex::Document *arg1 = (Hex::Document *) 0 ;
33529 PyObject * obj0 = 0 ;
33530 Hex::Elements *result = 0 ;
33532 if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
33537 arg1 = reinterpret_cast< Hex::Document * >(argp1);
33538 result = (Hex::Elements *)new Hex::Elements(arg1);
33539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW | 0 );
33546 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33547 PyObject *resultobj = 0;
33548 Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33551 PyObject * obj0 = 0 ;
33553 if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
33554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN | 0 );
33555 if (!SWIG_IsOK(res1)) {
33556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
33558 arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33560 resultobj = SWIG_Py_Void();
33567 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
33570 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
33571 return SWIG_Py_Void();
33574 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33575 PyObject *resultobj = 0;
33576 Hex::Document *arg1 = (Hex::Document *) 0 ;
33579 PyObject * obj0 = 0 ;
33580 Hex::BiCylinder *result = 0 ;
33582 if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
33583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
33584 if (!SWIG_IsOK(res1)) {
33585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
33587 arg1 = reinterpret_cast< Hex::Document * >(argp1);
33588 result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
33589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW | 0 );
33596 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33597 PyObject *resultobj = 0;
33598 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 PyObject * obj2 = 0 ;
33616 PyObject * obj3 = 0 ;
33617 PyObject * obj4 = 0 ;
33618 Hex::Hexa *result = 0 ;
33620 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33622 if (!SWIG_IsOK(res1)) {
33623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33625 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33626 ecode2 = SWIG_AsVal_int(obj1, &val2);
33627 if (!SWIG_IsOK(ecode2)) {
33628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
33630 arg2 = static_cast< int >(val2);
33631 ecode3 = SWIG_AsVal_int(obj2, &val3);
33632 if (!SWIG_IsOK(ecode3)) {
33633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
33635 arg3 = static_cast< int >(val3);
33636 ecode4 = SWIG_AsVal_int(obj3, &val4);
33637 if (!SWIG_IsOK(ecode4)) {
33638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
33640 arg4 = static_cast< int >(val4);
33641 ecode5 = SWIG_AsVal_int(obj4, &val5);
33642 if (!SWIG_IsOK(ecode5)) {
33643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
33645 arg5 = static_cast< int >(val5);
33646 result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
33647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 | 0 );
33654 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655 PyObject *resultobj = 0;
33656 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33671 PyObject * obj0 = 0 ;
33672 PyObject * obj1 = 0 ;
33673 PyObject * obj2 = 0 ;
33674 PyObject * obj3 = 0 ;
33675 PyObject * obj4 = 0 ;
33676 Hex::Quad *result = 0 ;
33678 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33680 if (!SWIG_IsOK(res1)) {
33681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33683 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33684 ecode2 = SWIG_AsVal_int(obj1, &val2);
33685 if (!SWIG_IsOK(ecode2)) {
33686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
33688 arg2 = static_cast< int >(val2);
33689 ecode3 = SWIG_AsVal_int(obj2, &val3);
33690 if (!SWIG_IsOK(ecode3)) {
33691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
33693 arg3 = static_cast< int >(val3);
33694 ecode4 = SWIG_AsVal_int(obj3, &val4);
33695 if (!SWIG_IsOK(ecode4)) {
33696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
33698 arg4 = static_cast< int >(val4);
33699 ecode5 = SWIG_AsVal_int(obj4, &val5);
33700 if (!SWIG_IsOK(ecode5)) {
33701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
33703 arg5 = static_cast< int >(val5);
33704 result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
33705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33712 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33713 PyObject *resultobj = 0;
33714 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33729 PyObject * obj0 = 0 ;
33730 PyObject * obj1 = 0 ;
33731 PyObject * obj2 = 0 ;
33732 PyObject * obj3 = 0 ;
33733 PyObject * obj4 = 0 ;
33734 Hex::Quad *result = 0 ;
33736 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33738 if (!SWIG_IsOK(res1)) {
33739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33741 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33742 ecode2 = SWIG_AsVal_int(obj1, &val2);
33743 if (!SWIG_IsOK(ecode2)) {
33744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
33746 arg2 = static_cast< int >(val2);
33747 ecode3 = SWIG_AsVal_int(obj2, &val3);
33748 if (!SWIG_IsOK(ecode3)) {
33749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
33751 arg3 = static_cast< int >(val3);
33752 ecode4 = SWIG_AsVal_int(obj3, &val4);
33753 if (!SWIG_IsOK(ecode4)) {
33754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
33756 arg4 = static_cast< int >(val4);
33757 ecode5 = SWIG_AsVal_int(obj4, &val5);
33758 if (!SWIG_IsOK(ecode5)) {
33759 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
33761 arg5 = static_cast< int >(val5);
33762 result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
33763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33770 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33771 PyObject *resultobj = 0;
33772 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 PyObject * obj2 = 0 ;
33790 PyObject * obj3 = 0 ;
33791 PyObject * obj4 = 0 ;
33792 Hex::Quad *result = 0 ;
33794 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33796 if (!SWIG_IsOK(res1)) {
33797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33799 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33800 ecode2 = SWIG_AsVal_int(obj1, &val2);
33801 if (!SWIG_IsOK(ecode2)) {
33802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
33804 arg2 = static_cast< int >(val2);
33805 ecode3 = SWIG_AsVal_int(obj2, &val3);
33806 if (!SWIG_IsOK(ecode3)) {
33807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
33809 arg3 = static_cast< int >(val3);
33810 ecode4 = SWIG_AsVal_int(obj3, &val4);
33811 if (!SWIG_IsOK(ecode4)) {
33812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
33814 arg4 = static_cast< int >(val4);
33815 ecode5 = SWIG_AsVal_int(obj4, &val5);
33816 if (!SWIG_IsOK(ecode5)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
33819 arg5 = static_cast< int >(val5);
33820 result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
33821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 | 0 );
33828 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33829 PyObject *resultobj = 0;
33830 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33845 PyObject * obj0 = 0 ;
33846 PyObject * obj1 = 0 ;
33847 PyObject * obj2 = 0 ;
33848 PyObject * obj3 = 0 ;
33849 PyObject * obj4 = 0 ;
33850 Hex::Edge *result = 0 ;
33852 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33857 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33858 ecode2 = SWIG_AsVal_int(obj1, &val2);
33859 if (!SWIG_IsOK(ecode2)) {
33860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
33862 arg2 = static_cast< int >(val2);
33863 ecode3 = SWIG_AsVal_int(obj2, &val3);
33864 if (!SWIG_IsOK(ecode3)) {
33865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
33867 arg3 = static_cast< int >(val3);
33868 ecode4 = SWIG_AsVal_int(obj3, &val4);
33869 if (!SWIG_IsOK(ecode4)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
33872 arg4 = static_cast< int >(val4);
33873 ecode5 = SWIG_AsVal_int(obj4, &val5);
33874 if (!SWIG_IsOK(ecode5)) {
33875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
33877 arg5 = static_cast< int >(val5);
33878 result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
33879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
33886 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33887 PyObject *resultobj = 0;
33888 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33903 PyObject * obj0 = 0 ;
33904 PyObject * obj1 = 0 ;
33905 PyObject * obj2 = 0 ;
33906 PyObject * obj3 = 0 ;
33907 PyObject * obj4 = 0 ;
33908 Hex::Edge *result = 0 ;
33910 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33912 if (!SWIG_IsOK(res1)) {
33913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33915 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33916 ecode2 = SWIG_AsVal_int(obj1, &val2);
33917 if (!SWIG_IsOK(ecode2)) {
33918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
33920 arg2 = static_cast< int >(val2);
33921 ecode3 = SWIG_AsVal_int(obj2, &val3);
33922 if (!SWIG_IsOK(ecode3)) {
33923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
33925 arg3 = static_cast< int >(val3);
33926 ecode4 = SWIG_AsVal_int(obj3, &val4);
33927 if (!SWIG_IsOK(ecode4)) {
33928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
33930 arg4 = static_cast< int >(val4);
33931 ecode5 = SWIG_AsVal_int(obj4, &val5);
33932 if (!SWIG_IsOK(ecode5)) {
33933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
33935 arg5 = static_cast< int >(val5);
33936 result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
33937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
33944 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33945 PyObject *resultobj = 0;
33946 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33961 PyObject * obj0 = 0 ;
33962 PyObject * obj1 = 0 ;
33963 PyObject * obj2 = 0 ;
33964 PyObject * obj3 = 0 ;
33965 PyObject * obj4 = 0 ;
33966 Hex::Edge *result = 0 ;
33968 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
33970 if (!SWIG_IsOK(res1)) {
33971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33973 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33974 ecode2 = SWIG_AsVal_int(obj1, &val2);
33975 if (!SWIG_IsOK(ecode2)) {
33976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
33978 arg2 = static_cast< int >(val2);
33979 ecode3 = SWIG_AsVal_int(obj2, &val3);
33980 if (!SWIG_IsOK(ecode3)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
33983 arg3 = static_cast< int >(val3);
33984 ecode4 = SWIG_AsVal_int(obj3, &val4);
33985 if (!SWIG_IsOK(ecode4)) {
33986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
33988 arg4 = static_cast< int >(val4);
33989 ecode5 = SWIG_AsVal_int(obj4, &val5);
33990 if (!SWIG_IsOK(ecode5)) {
33991 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
33993 arg5 = static_cast< int >(val5);
33994 result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
33995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 | 0 );
34002 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34003 PyObject *resultobj = 0;
34004 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
34019 PyObject * obj0 = 0 ;
34020 PyObject * obj1 = 0 ;
34021 PyObject * obj2 = 0 ;
34022 PyObject * obj3 = 0 ;
34023 PyObject * obj4 = 0 ;
34024 Hex::Vertex *result = 0 ;
34026 if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
34031 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
34032 ecode2 = SWIG_AsVal_int(obj1, &val2);
34033 if (!SWIG_IsOK(ecode2)) {
34034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
34036 arg2 = static_cast< int >(val2);
34037 ecode3 = SWIG_AsVal_int(obj2, &val3);
34038 if (!SWIG_IsOK(ecode3)) {
34039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
34041 arg3 = static_cast< int >(val3);
34042 ecode4 = SWIG_AsVal_int(obj3, &val4);
34043 if (!SWIG_IsOK(ecode4)) {
34044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
34046 arg4 = static_cast< int >(val4);
34047 ecode5 = SWIG_AsVal_int(obj4, &val5);
34048 if (!SWIG_IsOK(ecode5)) {
34049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
34051 arg5 = static_cast< int >(val5);
34052 result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
34053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 | 0 );
34060 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061 PyObject *resultobj = 0;
34062 Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
34065 PyObject * obj0 = 0 ;
34067 if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
34068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN | 0 );
34069 if (!SWIG_IsOK(res1)) {
34070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
34072 arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
34074 resultobj = SWIG_Py_Void();
34081 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34083 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34084 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
34085 return SWIG_Py_Void();
34088 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34089 PyObject *resultobj = 0;
34090 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34093 PyObject * obj0 = 0 ;
34096 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
34097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34098 if (!SWIG_IsOK(res1)) {
34099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34101 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34102 result = (int)(arg1)->countVertex();
34103 resultobj = SWIG_From_int(static_cast< int >(result));
34110 SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111 PyObject *resultobj = 0;
34112 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34115 PyObject * obj0 = 0 ;
34118 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
34119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34120 if (!SWIG_IsOK(res1)) {
34121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34123 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34124 result = (int)(arg1)->countEdge();
34125 resultobj = SWIG_From_int(static_cast< int >(result));
34132 SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34133 PyObject *resultobj = 0;
34134 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34137 PyObject * obj0 = 0 ;
34140 if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
34141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34142 if (!SWIG_IsOK(res1)) {
34143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34145 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34146 result = (int)(arg1)->countFace();
34147 resultobj = SWIG_From_int(static_cast< int >(result));
34154 SWIGINTERN PyObject *_wrap_NewShape_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34155 PyObject *resultobj = 0;
34156 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34166 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
34167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34168 if (!SWIG_IsOK(res1)) {
34169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34171 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34172 ecode2 = SWIG_AsVal_int(obj1, &val2);
34173 if (!SWIG_IsOK(ecode2)) {
34174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
34176 arg2 = static_cast< int >(val2);
34177 result = (int)(arg1)->getVertex(arg2);
34178 resultobj = SWIG_From_int(static_cast< int >(result));
34185 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34186 PyObject *resultobj = 0;
34187 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34193 PyObject * obj0 = 0 ;
34194 PyObject * obj1 = 0 ;
34197 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
34198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34202 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34203 ecode2 = SWIG_AsVal_int(obj1, &val2);
34204 if (!SWIG_IsOK(ecode2)) {
34205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
34207 arg2 = static_cast< int >(val2);
34208 result = (int)(arg1)->getEdge(arg2);
34209 resultobj = SWIG_From_int(static_cast< int >(result));
34216 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34217 PyObject *resultobj = 0;
34218 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34224 PyObject * obj0 = 0 ;
34225 PyObject * obj1 = 0 ;
34228 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
34229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34230 if (!SWIG_IsOK(res1)) {
34231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34233 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34234 ecode2 = SWIG_AsVal_int(obj1, &val2);
34235 if (!SWIG_IsOK(ecode2)) {
34236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
34238 arg2 = static_cast< int >(val2);
34239 result = (int)(arg1)->getFace(arg2);
34240 resultobj = SWIG_From_int(static_cast< int >(result));
34247 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34248 PyObject *resultobj = 0;
34249 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34255 PyObject * obj0 = 0 ;
34256 PyObject * obj1 = 0 ;
34259 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
34260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34264 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34265 ecode2 = SWIG_AsVal_int(obj1, &val2);
34266 if (!SWIG_IsOK(ecode2)) {
34267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
34269 arg2 = static_cast< int >(val2);
34270 result = (cpchar)(arg1)->getNameVertex(arg2);
34271 resultobj = SWIG_FromCharPtr((const char *)result);
34278 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279 PyObject *resultobj = 0;
34280 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34286 PyObject * obj0 = 0 ;
34287 PyObject * obj1 = 0 ;
34290 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
34291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34292 if (!SWIG_IsOK(res1)) {
34293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34295 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34296 ecode2 = SWIG_AsVal_int(obj1, &val2);
34297 if (!SWIG_IsOK(ecode2)) {
34298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
34300 arg2 = static_cast< int >(val2);
34301 result = (cpchar)(arg1)->getNameEdge(arg2);
34302 resultobj = SWIG_FromCharPtr((const char *)result);
34309 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34310 PyObject *resultobj = 0;
34311 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34317 PyObject * obj0 = 0 ;
34318 PyObject * obj1 = 0 ;
34321 if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
34322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
34323 if (!SWIG_IsOK(res1)) {
34324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34326 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34327 ecode2 = SWIG_AsVal_int(obj1, &val2);
34328 if (!SWIG_IsOK(ecode2)) {
34329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
34331 arg2 = static_cast< int >(val2);
34332 result = (cpchar)(arg1)->getNameFace(arg2);
34333 resultobj = SWIG_FromCharPtr((const char *)result);
34340 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34341 PyObject *resultobj = 0;
34342 Hex::Document *arg1 = (Hex::Document *) 0 ;
34343 Hex::EnumShape arg2 ;
34348 PyObject * obj0 = 0 ;
34349 PyObject * obj1 = 0 ;
34350 Hex::NewShape *result = 0 ;
34352 if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
34353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
34354 if (!SWIG_IsOK(res1)) {
34355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
34357 arg1 = reinterpret_cast< Hex::Document * >(argp1);
34358 ecode2 = SWIG_AsVal_int(obj1, &val2);
34359 if (!SWIG_IsOK(ecode2)) {
34360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
34362 arg2 = static_cast< Hex::EnumShape >(val2);
34363 result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
34364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW | 0 );
34371 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34372 PyObject *resultobj = 0;
34373 Hex::Document *arg1 = (Hex::Document *) 0 ;
34376 PyObject * obj0 = 0 ;
34377 Hex::NewShape *result = 0 ;
34379 if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
34380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
34384 arg1 = reinterpret_cast< Hex::Document * >(argp1);
34385 result = (Hex::NewShape *)new Hex::NewShape(arg1);
34386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW | 0 );
34393 SWIGINTERN PyObject *_wrap_new_NewShape(PyObject *self, PyObject *args) {
34395 PyObject *argv[3] = {
34400 if (!PyTuple_Check(args)) SWIG_fail;
34401 argc = args ? PyObject_Length(args) : 0;
34402 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
34403 argv[ii] = PyTuple_GET_ITEM(args,ii);
34408 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
34409 _v = SWIG_CheckState(res);
34411 return _wrap_new_NewShape__SWIG_1(self, args);
34417 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
34418 _v = SWIG_CheckState(res);
34421 int res = SWIG_AsVal_int(argv[1], NULL);
34422 _v = SWIG_CheckState(res);
34425 return _wrap_new_NewShape__SWIG_0(self, args);
34431 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewShape'.\n"
34432 " Possible C/C++ prototypes are:\n"
34433 " Hex::NewShape::NewShape(Hex::Document *,Hex::EnumShape)\n"
34434 " Hex::NewShape::NewShape(Hex::Document *)\n");
34439 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34440 PyObject *resultobj = 0;
34441 Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34444 PyObject * obj0 = 0 ;
34446 if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
34447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN | 0 );
34448 if (!SWIG_IsOK(res1)) {
34449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
34451 arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34453 resultobj = SWIG_Py_Void();
34460 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34463 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
34464 return SWIG_Py_Void();
34467 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34468 PyObject *resultobj = 0;
34469 Hex::Group *arg1 = (Hex::Group *) 0 ;
34470 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
34475 PyObject * obj0 = 0 ;
34476 PyObject * obj1 = 0 ;
34479 if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
34480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34481 if (!SWIG_IsOK(res1)) {
34482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
34484 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
34486 if (!SWIG_IsOK(res2)) {
34487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
34489 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
34490 result = (int)(arg1)->addElement(arg2);
34491 resultobj = SWIG_From_int(static_cast< int >(result));
34498 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499 PyObject *resultobj = 0;
34500 Hex::Group *arg1 = (Hex::Group *) 0 ;
34503 PyObject * obj0 = 0 ;
34506 if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
34507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34508 if (!SWIG_IsOK(res1)) {
34509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
34511 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34512 result = (int)(arg1)->countElement();
34513 resultobj = SWIG_From_int(static_cast< int >(result));
34520 SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34521 PyObject *resultobj = 0;
34522 Hex::Group *arg1 = (Hex::Group *) 0 ;
34525 PyObject * obj0 = 0 ;
34526 Hex::EnumGroup result;
34528 if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
34529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34530 if (!SWIG_IsOK(res1)) {
34531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
34533 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34534 result = (Hex::EnumGroup)(arg1)->getKind();
34535 resultobj = SWIG_From_int(static_cast< int >(result));
34542 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *resultobj = 0;
34544 Hex::Group *arg1 = (Hex::Group *) 0 ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34554 if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
34555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
34559 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34560 ecode2 = SWIG_AsVal_int(obj1, &val2);
34561 if (!SWIG_IsOK(ecode2)) {
34562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
34564 arg2 = static_cast< int >(val2);
34565 result = (int)(arg1)->removeElement(arg2);
34566 resultobj = SWIG_From_int(static_cast< int >(result));
34573 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34574 PyObject *resultobj = 0;
34575 Hex::Group *arg1 = (Hex::Group *) 0 ;
34578 PyObject * obj0 = 0 ;
34580 if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
34581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34582 if (!SWIG_IsOK(res1)) {
34583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
34585 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34586 (arg1)->clearElement();
34587 resultobj = SWIG_Py_Void();
34594 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 Hex::Group *arg1 = (Hex::Group *) 0 ;
34597 Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34606 if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
34607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
34611 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
34613 if (!SWIG_IsOK(res2)) {
34614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
34616 arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
34617 result = (int)(arg1)->removeElement(arg2);
34618 resultobj = SWIG_From_int(static_cast< int >(result));
34625 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
34627 PyObject *argv[3] = {
34632 if (!PyTuple_Check(args)) SWIG_fail;
34633 argc = args ? PyObject_Length(args) : 0;
34634 for (ii = 0; (ii < 2) && (ii < argc); ii++) {
34635 argv[ii] = PyTuple_GET_ITEM(args,ii);
34640 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
34641 _v = SWIG_CheckState(res);
34644 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
34645 _v = SWIG_CheckState(res);
34647 return _wrap_Group_removeElement__SWIG_1(self, args);
34654 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
34655 _v = SWIG_CheckState(res);
34658 int res = SWIG_AsVal_int(argv[1], NULL);
34659 _v = SWIG_CheckState(res);
34662 return _wrap_Group_removeElement__SWIG_0(self, args);
34668 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Group_removeElement'.\n"
34669 " Possible C/C++ prototypes are:\n"
34670 " Hex::Group::removeElement(int)\n"
34671 " Hex::Group::removeElement(Hex::EltBase *)\n");
34676 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34677 PyObject *resultobj = 0;
34678 Hex::Group *arg1 = (Hex::Group *) 0 ;
34684 PyObject * obj0 = 0 ;
34685 PyObject * obj1 = 0 ;
34686 Hex::EltBase *result = 0 ;
34688 if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
34689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
34690 if (!SWIG_IsOK(res1)) {
34691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
34693 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34694 ecode2 = SWIG_AsVal_int(obj1, &val2);
34695 if (!SWIG_IsOK(ecode2)) {
34696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
34698 arg2 = static_cast< int >(val2);
34699 result = (Hex::EltBase *)(arg1)->getElement(arg2);
34700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 | 0 );
34707 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34708 PyObject *resultobj = 0;
34709 Hex::Document *arg1 = (Hex::Document *) 0 ;
34710 cpchar arg2 = (cpchar) 0 ;
34711 Hex::EnumGroup arg3 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 PyObject * obj2 = 0 ;
34722 Hex::Group *result = 0 ;
34724 if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
34729 arg1 = reinterpret_cast< Hex::Document * >(argp1);
34730 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34731 if (!SWIG_IsOK(res2)) {
34732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
34734 arg2 = reinterpret_cast< cpchar >(buf2);
34735 ecode3 = SWIG_AsVal_int(obj2, &val3);
34736 if (!SWIG_IsOK(ecode3)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
34739 arg3 = static_cast< Hex::EnumGroup >(val3);
34740 result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
34741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW | 0 );
34742 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
34745 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
34750 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34751 PyObject *resultobj = 0;
34752 Hex::Group *arg1 = (Hex::Group *) 0 ;
34755 PyObject * obj0 = 0 ;
34757 if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
34758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN | 0 );
34759 if (!SWIG_IsOK(res1)) {
34760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
34762 arg1 = reinterpret_cast< Hex::Group * >(argp1);
34764 resultobj = SWIG_Py_Void();
34771 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34773 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34774 SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
34775 return SWIG_Py_Void();
34778 static PyMethodDef SwigMethods[] = {
34779 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
34780 { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
34781 { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
34782 { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
34783 { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
34784 { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
34785 { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
34786 { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
34787 { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
34788 { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
34789 { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
34790 { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
34791 { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
34792 { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
34793 { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
34794 { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
34795 { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
34796 { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
34797 { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
34798 { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
34799 { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
34800 { (char *)"VectorHexas___bool__", _wrap_VectorHexas___bool__, METH_VARARGS, NULL},
34801 { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
34802 { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
34803 { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
34804 { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
34805 { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
34806 { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
34807 { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
34808 { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
34809 { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
34810 { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
34811 { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
34812 { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
34813 { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
34814 { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
34815 { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
34816 { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
34817 { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
34818 { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
34819 { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
34820 { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
34821 { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
34822 { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
34823 { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
34824 { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
34825 { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
34826 { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
34827 { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
34828 { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
34829 { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
34830 { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
34831 { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
34832 { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
34833 { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
34834 { (char *)"VectorQuads___bool__", _wrap_VectorQuads___bool__, METH_VARARGS, NULL},
34835 { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
34836 { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
34837 { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
34838 { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
34839 { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
34840 { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
34841 { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
34842 { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
34843 { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
34844 { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
34845 { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
34846 { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
34847 { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
34848 { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
34849 { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
34850 { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
34851 { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
34852 { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
34853 { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
34854 { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
34855 { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
34856 { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
34857 { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
34858 { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
34859 { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
34860 { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
34861 { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
34862 { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
34863 { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
34864 { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
34865 { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
34866 { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
34867 { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
34868 { (char *)"VectorEdges___bool__", _wrap_VectorEdges___bool__, METH_VARARGS, NULL},
34869 { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
34870 { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
34871 { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
34872 { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
34873 { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
34874 { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
34875 { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
34876 { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
34877 { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
34878 { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
34879 { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
34880 { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
34881 { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
34882 { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
34883 { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
34884 { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
34885 { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
34886 { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
34887 { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
34888 { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
34889 { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
34890 { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
34891 { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
34892 { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
34893 { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
34894 { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
34895 { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
34896 { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
34897 { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
34898 { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
34899 { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
34900 { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
34901 { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
34902 { (char *)"VectorVertices___bool__", _wrap_VectorVertices___bool__, METH_VARARGS, NULL},
34903 { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
34904 { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
34905 { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
34906 { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
34907 { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
34908 { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
34909 { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
34910 { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
34911 { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
34912 { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
34913 { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
34914 { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
34915 { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
34916 { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
34917 { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
34918 { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
34919 { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
34920 { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
34921 { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
34922 { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
34923 { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
34924 { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
34925 { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
34926 { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
34927 { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
34928 { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
34929 { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
34930 { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
34931 { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
34932 { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
34933 { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
34934 { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
34935 { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
34936 { (char *)"VectorShapes___bool__", _wrap_VectorShapes___bool__, METH_VARARGS, NULL},
34937 { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
34938 { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
34939 { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
34940 { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
34941 { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
34942 { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
34943 { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
34944 { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
34945 { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
34946 { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
34947 { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
34948 { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
34949 { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
34950 { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
34951 { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
34952 { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
34953 { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
34954 { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
34955 { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
34956 { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
34957 { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
34958 { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
34959 { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
34960 { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
34961 { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
34962 { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
34963 { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
34964 { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
34965 { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
34966 { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
34967 { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
34968 { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
34969 { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
34970 { (char *)"VectorReal___bool__", _wrap_VectorReal___bool__, METH_VARARGS, NULL},
34971 { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
34972 { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
34973 { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
34974 { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
34975 { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
34976 { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
34977 { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
34978 { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
34979 { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
34980 { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
34981 { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
34982 { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
34983 { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
34984 { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
34985 { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
34986 { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
34987 { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
34988 { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
34989 { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
34990 { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
34991 { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
34992 { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
34993 { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
34994 { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
34995 { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
34996 { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
34997 { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
34998 { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
34999 { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
35000 { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
35001 { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
35002 { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
35003 { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
35004 { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL},
35005 { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
35006 { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
35007 { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
35008 { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
35009 { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
35010 { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
35011 { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
35012 { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
35013 { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
35014 { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
35015 { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
35016 { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
35017 { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
35018 { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
35019 { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
35020 { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
35021 { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
35022 { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
35023 { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
35024 { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
35025 { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
35026 { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
35027 { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
35028 { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
35029 { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
35030 { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
35031 { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
35032 { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
35033 { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
35034 { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
35035 { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
35036 { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
35037 { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
35038 { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
35039 { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
35040 { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
35041 { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
35042 { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
35043 { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
35044 { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
35045 { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
35046 { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
35047 { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
35048 { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
35049 { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
35050 { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
35051 { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
35052 { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
35053 { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
35054 { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
35055 { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
35056 { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
35057 { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
35058 { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
35059 { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
35060 { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
35061 { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
35062 { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
35063 { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
35064 { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
35065 { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
35066 { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
35067 { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
35068 { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
35069 { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
35070 { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
35071 { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
35072 { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
35073 { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
35074 { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
35075 { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
35076 { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
35077 { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
35078 { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
35079 { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
35080 { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
35081 { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
35082 { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
35083 { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
35084 { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
35085 { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
35086 { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
35087 { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
35088 { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
35089 { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
35090 { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
35091 { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
35092 { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
35093 { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
35094 { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
35095 { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
35096 { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
35097 { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
35098 { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
35099 { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
35100 { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
35101 { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
35102 { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
35103 { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
35104 { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
35105 { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
35106 { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
35107 { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
35108 { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
35109 { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
35110 { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
35111 { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
35112 { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
35113 { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
35114 { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
35115 { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
35116 { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
35117 { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
35118 { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
35119 { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
35120 { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
35121 { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
35122 { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
35123 { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
35124 { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
35125 { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
35126 { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
35127 { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
35128 { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
35129 { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
35130 { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
35131 { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
35132 { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
35133 { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
35134 { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
35135 { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
35136 { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
35137 { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
35138 { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
35139 { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
35140 { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
35141 { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
35142 { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
35143 { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
35144 { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
35145 { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
35146 { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
35147 { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
35148 { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
35149 { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
35150 { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
35151 { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
35152 { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
35153 { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
35154 { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
35155 { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
35156 { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
35157 { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
35158 { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
35159 { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
35160 { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
35161 { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
35162 { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
35163 { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
35164 { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
35165 { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
35166 { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
35167 { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
35168 { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
35169 { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
35170 { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
35171 { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
35172 { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
35173 { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
35174 { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
35175 { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
35176 { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
35177 { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
35178 { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
35179 { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
35180 { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
35181 { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
35182 { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
35183 { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
35184 { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
35185 { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
35186 { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
35187 { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
35188 { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
35189 { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
35190 { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
35191 { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
35192 { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
35193 { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
35194 { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
35195 { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
35196 { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
35197 { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
35198 { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
35199 { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
35200 { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
35201 { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
35202 { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
35203 { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
35204 { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
35205 { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
35206 { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
35207 { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
35208 { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
35209 { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
35210 { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
35211 { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
35212 { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
35213 { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
35214 { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
35215 { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
35216 { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
35217 { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
35218 { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
35219 { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
35220 { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
35221 { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
35222 { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
35223 { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
35224 { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
35225 { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
35226 { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
35227 { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
35228 { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
35229 { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
35230 { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
35231 { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
35232 { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
35233 { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
35234 { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
35235 { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
35236 { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
35237 { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
35238 { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
35239 { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
35240 { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
35241 { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
35242 { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
35243 { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
35244 { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
35245 { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
35246 { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
35247 { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
35248 { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
35249 { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
35250 { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
35251 { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
35252 { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
35253 { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
35254 { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
35255 { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
35256 { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
35257 { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
35258 { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
35259 { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
35260 { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
35261 { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
35262 { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
35263 { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
35264 { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
35265 { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
35266 { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
35267 { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
35268 { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
35269 { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
35270 { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
35271 { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
35272 { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
35273 { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
35274 { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
35275 { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
35276 { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
35277 { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
35278 { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
35279 { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
35280 { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
35281 { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
35282 { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
35283 { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
35284 { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
35285 { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
35286 { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
35287 { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
35288 { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
35289 { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
35290 { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
35291 { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
35292 { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
35293 { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
35294 { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
35295 { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
35296 { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
35297 { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
35298 { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
35299 { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
35300 { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
35301 { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
35302 { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
35303 { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
35304 { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
35305 { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
35306 { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
35307 { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
35308 { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
35309 { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
35310 { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
35311 { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
35312 { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
35313 { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
35314 { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
35315 { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
35316 { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
35317 { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
35318 { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
35319 { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
35320 { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
35321 { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
35322 { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
35323 { (char *)"what", _wrap_what, METH_VARARGS, NULL},
35324 { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
35325 { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
35326 { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
35327 { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
35328 { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
35329 { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
35330 { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
35331 { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
35332 { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
35333 { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
35334 { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
35335 { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
35336 { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
35337 { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
35338 { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
35339 { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
35340 { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
35341 { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
35342 { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
35343 { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
35344 { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
35345 { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
35346 { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
35347 { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
35348 { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
35349 { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
35350 { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
35351 { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
35352 { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
35353 { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
35354 { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
35355 { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
35356 { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
35357 { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
35358 { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
35359 { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
35360 { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
35361 { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
35362 { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
35363 { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
35364 { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
35365 { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
35366 { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
35367 { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
35368 { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
35369 { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
35370 { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
35371 { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
35372 { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
35373 { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
35374 { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
35375 { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
35376 { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
35377 { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
35378 { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
35379 { NULL, NULL, 0, NULL }
35383 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
35385 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35386 return (void *)((Hex::EltBase *) ((Hex::Vector *) x));
35388 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35389 return (void *)((Hex::EltBase *) ((Hex::NewShape *) x));
35391 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35392 return (void *)((Hex::EltBase *) ((Hex::Group *) x));
35394 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35395 return (void *)((Hex::EltBase *) ((Hex::Propagation *) x));
35397 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35398 return (void *)((Hex::EltBase *) ((Hex::Vertex *) x));
35400 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35401 return (void *)((Hex::EltBase *) ((Hex::Hexa *) x));
35403 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35404 return (void *)((Hex::EltBase *) ((Hex::Edge *) x));
35406 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35407 return (void *)((Hex::EltBase *) ((Hex::Quad *) x));
35409 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35410 return (void *)((Hex::EltBase *) ((Hex::Elements *) x));
35412 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35413 return (void *)((Hex::EltBase *) ((Hex::Document *) x));
35415 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35416 return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
35418 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35419 return (void *)((Hex::Elements *) ((Hex::BiCylinder *) x));
35421 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
35422 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
35423 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
35424 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "std::vector< Hex::Edge * >::value_type|Hex::Edge *", 0, 0, (void*)0, 0};
35425 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
35426 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
35427 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
35428 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
35429 static swig_type_info _swigt__p_Hex__Hex__Elements = {"_p_Hex__Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
35430 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
35431 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *|std::vector< Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
35432 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
35433 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "std::vector< Hex::NewShape * >::value_type|Hex::NewShape *", 0, 0, (void*)0, 0};
35434 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
35435 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "std::vector< Hex::Quad * >::value_type|Hex::Quad *", 0, 0, (void*)0, 0};
35436 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
35437 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
35438 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "std::vector< Hex::Vertex * >::value_type|Hex::Vertex *", 0, 0, (void*)0, 0};
35439 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
35440 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};
35441 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
35442 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
35443 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
35444 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
35445 static swig_type_info _swigt__p_double = {"_p_double", "double *|Hex::Real *", 0, 0, (void*)0, 0};
35446 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
35447 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
35448 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
35449 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
35450 static swig_type_info _swigt__p_std__allocatorT_Hex__Edge_p_t = {"_p_std__allocatorT_Hex__Edge_p_t", "std::vector< Hex::Edge * >::allocator_type *|std::allocator< Hex::Edge * > *", 0, 0, (void*)0, 0};
35451 static swig_type_info _swigt__p_std__allocatorT_Hex__Hexa_p_t = {"_p_std__allocatorT_Hex__Hexa_p_t", "std::vector< Hex::Hexa * >::allocator_type *|std::allocator< Hex::Hexa * > *", 0, 0, (void*)0, 0};
35452 static swig_type_info _swigt__p_std__allocatorT_Hex__NewShape_p_t = {"_p_std__allocatorT_Hex__NewShape_p_t", "std::vector< Hex::NewShape * >::allocator_type *|std::allocator< Hex::NewShape * > *", 0, 0, (void*)0, 0};
35453 static swig_type_info _swigt__p_std__allocatorT_Hex__Quad_p_t = {"_p_std__allocatorT_Hex__Quad_p_t", "std::vector< Hex::Quad * >::allocator_type *|std::allocator< Hex::Quad * > *", 0, 0, (void*)0, 0};
35454 static swig_type_info _swigt__p_std__allocatorT_Hex__Vertex_p_t = {"_p_std__allocatorT_Hex__Vertex_p_t", "std::vector< Hex::Vertex * >::allocator_type *|std::allocator< Hex::Vertex * > *", 0, 0, (void*)0, 0};
35455 static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
35456 static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
35457 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
35458 static swig_type_info _swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t = {"_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t", "std::vector< Hex::AssoEdge *,std::allocator< Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
35459 static swig_type_info _swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t = {"_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t", "Hex::EdgeShapes *|std::vector< Hex::EdgeShape *,std::allocator< Hex::EdgeShape * > > *", 0, 0, (void*)0, 0};
35460 static swig_type_info _swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t = {"_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t", "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *|std::vector< Hex::Edge * > *|Hex::Edges *", 0, 0, (void*)0, 0};
35461 static swig_type_info _swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t = {"_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t", "std::vector< Hex::EltBase *,std::allocator< Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
35462 static swig_type_info _swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t = {"_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t", "Hex::FaceShapes *|std::vector< Hex::FaceShape *,std::allocator< Hex::FaceShape * > > *", 0, 0, (void*)0, 0};
35463 static swig_type_info _swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t = {"_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t", "Hex::Hexas *|std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *|std::vector< Hex::Hexa * > *", 0, 0, (void*)0, 0};
35464 static swig_type_info _swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t = {"_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t", "Hex::NewShapes *|std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *|std::vector< Hex::NewShape * > *", 0, 0, (void*)0, 0};
35465 static swig_type_info _swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t = {"_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t", "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *|std::vector< Hex::Quad * > *|Hex::Quads *", 0, 0, (void*)0, 0};
35466 static swig_type_info _swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t = {"_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t", "Hex::Shapes *|std::vector< Hex::Shape *,std::allocator< Hex::Shape * > > *", 0, 0, (void*)0, 0};
35467 static swig_type_info _swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t = {"_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t", "Hex::SubShapes *|std::vector< Hex::SubShape *,std::allocator< Hex::SubShape * > > *", 0, 0, (void*)0, 0};
35468 static swig_type_info _swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t = {"_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t", "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *|std::vector< Hex::Vertex * > *|Hex::Vertices *", 0, 0, (void*)0, 0};
35469 static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|Hex::RealVector *|std::vector< double > *", 0, 0, (void*)0, 0};
35470 static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|Hex::IntVector *|std::vector< int > *", 0, 0, (void*)0, 0};
35471 static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "Hex::TabText *|std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
35472 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
35473 static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
35474 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
35476 static swig_type_info *swig_type_initial[] = {
35478 &_swigt__p_Hex__BiCylinder,
35479 &_swigt__p_Hex__Document,
35480 &_swigt__p_Hex__Edge,
35481 &_swigt__p_Hex__Elements,
35482 &_swigt__p_Hex__EltBase,
35483 &_swigt__p_Hex__Group,
35484 &_swigt__p_Hex__Hex,
35485 &_swigt__p_Hex__Hex__Elements,
35486 &_swigt__p_Hex__Hex__EltBase,
35487 &_swigt__p_Hex__Hexa,
35488 &_swigt__p_Hex__Law,
35489 &_swigt__p_Hex__NewShape,
35490 &_swigt__p_Hex__Propagation,
35491 &_swigt__p_Hex__Quad,
35492 &_swigt__p_Hex__Shape,
35493 &_swigt__p_Hex__Vector,
35494 &_swigt__p_Hex__Vertex,
35495 &_swigt__p_Hex__XmlWriter,
35496 &_swigt__p_a_Hex__DIM3__double,
35497 &_swigt__p_allocator_type,
35499 &_swigt__p_const_reference,
35500 &_swigt__p_difference_type,
35503 &_swigt__p_p_PyObject,
35504 &_swigt__p_reference,
35505 &_swigt__p_size_type,
35506 &_swigt__p_std__allocatorT_Hex__Edge_p_t,
35507 &_swigt__p_std__allocatorT_Hex__Hexa_p_t,
35508 &_swigt__p_std__allocatorT_Hex__NewShape_p_t,
35509 &_swigt__p_std__allocatorT_Hex__Quad_p_t,
35510 &_swigt__p_std__allocatorT_Hex__Vertex_p_t,
35511 &_swigt__p_std__allocatorT_double_t,
35512 &_swigt__p_std__allocatorT_int_t,
35513 &_swigt__p_std__invalid_argument,
35514 &_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
35515 &_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
35516 &_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
35517 &_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
35518 &_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
35519 &_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
35520 &_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
35521 &_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
35522 &_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
35523 &_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
35524 &_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
35525 &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
35526 &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
35527 &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
35529 &_swigt__p_swig__SwigPyIterator,
35530 &_swigt__p_value_type,
35533 static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
35534 static swig_cast_info _swigc__p_Hex__BiCylinder[] = { {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
35535 static swig_cast_info _swigc__p_Hex__Document[] = { {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
35536 static swig_cast_info _swigc__p_Hex__Edge[] = { {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
35537 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}};
35538 static swig_cast_info _swigc__p_Hex__EltBase[] = { {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Elements, _p_Hex__ElementsTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
35539 static swig_cast_info _swigc__p_Hex__Group[] = { {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
35540 static swig_cast_info _swigc__p_Hex__Hex[] = { {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
35541 static swig_cast_info _swigc__p_Hex__Hex__Elements[] = { {&_swigt__p_Hex__Hex__Elements, 0, 0, 0},{0, 0, 0, 0}};
35542 static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = { {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0},{0, 0, 0, 0}};
35543 static swig_cast_info _swigc__p_Hex__Hexa[] = { {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
35544 static swig_cast_info _swigc__p_Hex__Law[] = { {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
35545 static swig_cast_info _swigc__p_Hex__NewShape[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0},{0, 0, 0, 0}};
35546 static swig_cast_info _swigc__p_Hex__Propagation[] = { {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
35547 static swig_cast_info _swigc__p_Hex__Quad[] = { {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
35548 static swig_cast_info _swigc__p_Hex__Shape[] = { {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
35549 static swig_cast_info _swigc__p_Hex__Vector[] = { {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
35550 static swig_cast_info _swigc__p_Hex__Vertex[] = { {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
35551 static swig_cast_info _swigc__p_Hex__XmlWriter[] = { {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
35552 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = { {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
35553 static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
35554 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
35555 static swig_cast_info _swigc__p_const_reference[] = { {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
35556 static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
35557 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
35558 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
35559 static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
35560 static swig_cast_info _swigc__p_reference[] = { {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
35561 static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
35562 static swig_cast_info _swigc__p_std__allocatorT_Hex__Edge_p_t[] = { {&_swigt__p_std__allocatorT_Hex__Edge_p_t, 0, 0, 0},{0, 0, 0, 0}};
35563 static swig_cast_info _swigc__p_std__allocatorT_Hex__Hexa_p_t[] = { {&_swigt__p_std__allocatorT_Hex__Hexa_p_t, 0, 0, 0},{0, 0, 0, 0}};
35564 static swig_cast_info _swigc__p_std__allocatorT_Hex__NewShape_p_t[] = { {&_swigt__p_std__allocatorT_Hex__NewShape_p_t, 0, 0, 0},{0, 0, 0, 0}};
35565 static swig_cast_info _swigc__p_std__allocatorT_Hex__Quad_p_t[] = { {&_swigt__p_std__allocatorT_Hex__Quad_p_t, 0, 0, 0},{0, 0, 0, 0}};
35566 static swig_cast_info _swigc__p_std__allocatorT_Hex__Vertex_p_t[] = { {&_swigt__p_std__allocatorT_Hex__Vertex_p_t, 0, 0, 0},{0, 0, 0, 0}};
35567 static swig_cast_info _swigc__p_std__allocatorT_double_t[] = { {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
35568 static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
35569 static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
35570 static swig_cast_info _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35571 static swig_cast_info _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35572 static swig_cast_info _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35573 static swig_cast_info _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35574 static swig_cast_info _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35575 static swig_cast_info _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35576 static swig_cast_info _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35577 static swig_cast_info _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35578 static swig_cast_info _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35579 static swig_cast_info _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35580 static swig_cast_info _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t[] = { {&_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35581 static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
35582 static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
35583 static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
35584 static swig_cast_info _swigc__p_string[] = { {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
35585 static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
35586 static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
35588 static swig_cast_info *swig_cast_initial[] = {
35590 _swigc__p_Hex__BiCylinder,
35591 _swigc__p_Hex__Document,
35592 _swigc__p_Hex__Edge,
35593 _swigc__p_Hex__Elements,
35594 _swigc__p_Hex__EltBase,
35595 _swigc__p_Hex__Group,
35596 _swigc__p_Hex__Hex,
35597 _swigc__p_Hex__Hex__Elements,
35598 _swigc__p_Hex__Hex__EltBase,
35599 _swigc__p_Hex__Hexa,
35600 _swigc__p_Hex__Law,
35601 _swigc__p_Hex__NewShape,
35602 _swigc__p_Hex__Propagation,
35603 _swigc__p_Hex__Quad,
35604 _swigc__p_Hex__Shape,
35605 _swigc__p_Hex__Vector,
35606 _swigc__p_Hex__Vertex,
35607 _swigc__p_Hex__XmlWriter,
35608 _swigc__p_a_Hex__DIM3__double,
35609 _swigc__p_allocator_type,
35611 _swigc__p_const_reference,
35612 _swigc__p_difference_type,
35615 _swigc__p_p_PyObject,
35616 _swigc__p_reference,
35617 _swigc__p_size_type,
35618 _swigc__p_std__allocatorT_Hex__Edge_p_t,
35619 _swigc__p_std__allocatorT_Hex__Hexa_p_t,
35620 _swigc__p_std__allocatorT_Hex__NewShape_p_t,
35621 _swigc__p_std__allocatorT_Hex__Quad_p_t,
35622 _swigc__p_std__allocatorT_Hex__Vertex_p_t,
35623 _swigc__p_std__allocatorT_double_t,
35624 _swigc__p_std__allocatorT_int_t,
35625 _swigc__p_std__invalid_argument,
35626 _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
35627 _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
35628 _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
35629 _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
35630 _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
35631 _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
35632 _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
35633 _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
35634 _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
35635 _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
35636 _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
35637 _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
35638 _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
35639 _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
35641 _swigc__p_swig__SwigPyIterator,
35642 _swigc__p_value_type,
35646 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
35648 static swig_const_info swig_const_table[] = {
35649 {0, 0, 0, 0.0, 0, 0}};
35654 /* -----------------------------------------------------------------------------
35655 * Type initialization:
35656 * This problem is tough by the requirement that no dynamic
35657 * memory is used. Also, since swig_type_info structures store pointers to
35658 * swig_cast_info structures and swig_cast_info structures store pointers back
35659 * to swig_type_info structures, we need some lookup code at initialization.
35660 * The idea is that swig generates all the structures that are needed.
35661 * The runtime then collects these partially filled structures.
35662 * The SWIG_InitializeModule function takes these initial arrays out of
35663 * swig_module, and does all the lookup, filling in the swig_module.types
35664 * array with the correct data and linking the correct swig_cast_info
35665 * structures together.
35667 * The generated swig_type_info structures are assigned statically to an initial
35668 * array. We just loop through that array, and handle each type individually.
35669 * First we lookup if this type has been already loaded, and if so, use the
35670 * loaded structure instead of the generated one. Then we have to fill in the
35671 * cast linked list. The cast data is initially stored in something like a
35672 * two-dimensional array. Each row corresponds to a type (there are the same
35673 * number of rows as there are in the swig_type_initial array). Each entry in
35674 * a column is one of the swig_cast_info structures for that type.
35675 * The cast_initial array is actually an array of arrays, because each row has
35676 * a variable number of columns. So to actually build the cast linked list,
35677 * we find the array of casts associated with the type, and loop through it
35678 * adding the casts to the list. The one last trick we need to do is making
35679 * sure the type pointer in the swig_cast_info struct is correct.
35681 * First off, we lookup the cast->type name to see if it is already loaded.
35682 * There are three cases to handle:
35683 * 1) If the cast->type has already been loaded AND the type we are adding
35684 * casting info to has not been loaded (it is in this module), THEN we
35685 * replace the cast->type pointer with the type pointer that has already
35687 * 2) If BOTH types (the one we are adding casting info to, and the
35688 * cast->type) are loaded, THEN the cast info has already been loaded by
35689 * the previous module so we just ignore it.
35690 * 3) Finally, if cast->type has not already been loaded, then we add that
35691 * swig_cast_info to the linked list (because the cast->type) pointer will
35693 * ----------------------------------------------------------------------------- */
35703 #define SWIGRUNTIME_DEBUG
35708 SWIG_InitializeModule(void *clientdata) {
35710 swig_module_info *module_head, *iter;
35713 /* check to see if the circular list has been setup, if not, set it up */
35714 if (swig_module.next==0) {
35715 /* Initialize the swig_module */
35716 swig_module.type_initial = swig_type_initial;
35717 swig_module.cast_initial = swig_cast_initial;
35718 swig_module.next = &swig_module;
35724 /* Try and load any already created modules */
35725 module_head = SWIG_GetModule(clientdata);
35726 if (!module_head) {
35727 /* This is the first module loaded for this interpreter */
35728 /* so set the swig module into the interpreter */
35729 SWIG_SetModule(clientdata, &swig_module);
35731 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
35734 if (iter==&swig_module) {
35735 /* Our module is already in the list, so there's nothing more to do. */
35739 } while (iter!= module_head);
35741 /* otherwise we must add our module into the list */
35742 swig_module.next = module_head->next;
35743 module_head->next = &swig_module;
35746 /* When multiple interpreters are used, a module could have already been initialized in
35747 a different interpreter, but not yet have a pointer in this interpreter.
35748 In this case, we do not want to continue adding types... everything should be
35750 if (init == 0) return;
35752 /* Now work on filling in swig_module.types */
35753 #ifdef SWIGRUNTIME_DEBUG
35754 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
35756 for (i = 0; i < swig_module.size; ++i) {
35757 swig_type_info *type = 0;
35758 swig_type_info *ret;
35759 swig_cast_info *cast;
35761 #ifdef SWIGRUNTIME_DEBUG
35762 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
35765 /* if there is another module already loaded */
35766 if (swig_module.next != &swig_module) {
35767 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
35770 /* Overwrite clientdata field */
35771 #ifdef SWIGRUNTIME_DEBUG
35772 printf("SWIG_InitializeModule: found type %s\n", type->name);
35774 if (swig_module.type_initial[i]->clientdata) {
35775 type->clientdata = swig_module.type_initial[i]->clientdata;
35776 #ifdef SWIGRUNTIME_DEBUG
35777 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
35781 type = swig_module.type_initial[i];
35784 /* Insert casting types */
35785 cast = swig_module.cast_initial[i];
35786 while (cast->type) {
35787 /* Don't need to add information already in the list */
35789 #ifdef SWIGRUNTIME_DEBUG
35790 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
35792 if (swig_module.next != &swig_module) {
35793 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
35794 #ifdef SWIGRUNTIME_DEBUG
35795 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
35799 if (type == swig_module.type_initial[i]) {
35800 #ifdef SWIGRUNTIME_DEBUG
35801 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
35806 /* Check for casting already in the list */
35807 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
35808 #ifdef SWIGRUNTIME_DEBUG
35809 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
35811 if (!ocast) ret = 0;
35816 #ifdef SWIGRUNTIME_DEBUG
35817 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
35820 type->cast->prev = cast;
35821 cast->next = type->cast;
35827 /* Set entry in modules->types array equal to the type */
35828 swig_module.types[i] = type;
35830 swig_module.types[i] = 0;
35832 #ifdef SWIGRUNTIME_DEBUG
35833 printf("**** SWIG_InitializeModule: Cast List ******\n");
35834 for (i = 0; i < swig_module.size; ++i) {
35836 swig_cast_info *cast = swig_module.cast_initial[i];
35837 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
35838 while (cast->type) {
35839 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
35843 printf("---- Total casts: %d\n",j);
35845 printf("**** SWIG_InitializeModule: Cast List ******\n");
35849 /* This function will propagate the clientdata field of type to
35850 * any new swig_type_info structures that have been added into the list
35851 * of equivalent types. It is like calling
35852 * SWIG_TypeClientData(type, clientdata) a second time.
35855 SWIG_PropagateClientData(void) {
35857 swig_cast_info *equiv;
35858 static int init_run = 0;
35860 if (init_run) return;
35863 for (i = 0; i < swig_module.size; i++) {
35864 if (swig_module.types[i]->clientdata) {
35865 equiv = swig_module.types[i]->cast;
35867 if (!equiv->converter) {
35868 if (equiv->type && !equiv->type->clientdata)
35869 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
35871 equiv = equiv->next;
35891 /* Python-specific SWIG API */
35892 #define SWIG_newvarlink() SWIG_Python_newvarlink()
35893 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
35894 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
35896 /* -----------------------------------------------------------------------------
35897 * global variable support code.
35898 * ----------------------------------------------------------------------------- */
35900 typedef struct swig_globalvar {
35901 char *name; /* Name of global variable */
35902 PyObject *(*get_attr)(void); /* Return the current value */
35903 int (*set_attr)(PyObject *); /* Set the value */
35904 struct swig_globalvar *next;
35907 typedef struct swig_varlinkobject {
35909 swig_globalvar *vars;
35910 } swig_varlinkobject;
35912 SWIGINTERN PyObject *
35913 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
35914 #if PY_VERSION_HEX >= 0x03000000
35915 return PyUnicode_InternFromString("<Swig global variables>");
35917 return PyString_FromString("<Swig global variables>");
35921 SWIGINTERN PyObject *
35922 swig_varlink_str(swig_varlinkobject *v) {
35923 #if PY_VERSION_HEX >= 0x03000000
35924 PyObject *str = PyUnicode_InternFromString("(");
35927 swig_globalvar *var;
35928 for (var = v->vars; var; var=var->next) {
35929 tail = PyUnicode_FromString(var->name);
35930 joined = PyUnicode_Concat(str, tail);
35935 tail = PyUnicode_InternFromString(", ");
35936 joined = PyUnicode_Concat(str, tail);
35942 tail = PyUnicode_InternFromString(")");
35943 joined = PyUnicode_Concat(str, tail);
35948 PyObject *str = PyString_FromString("(");
35949 swig_globalvar *var;
35950 for (var = v->vars; var; var=var->next) {
35951 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
35952 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
35954 PyString_ConcatAndDel(&str,PyString_FromString(")"));
35960 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
35962 PyObject *str = swig_varlink_str(v);
35963 fprintf(fp,"Swig global variables ");
35964 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
35965 SWIG_Python_str_DelForPy3(tmp);
35971 swig_varlink_dealloc(swig_varlinkobject *v) {
35972 swig_globalvar *var = v->vars;
35974 swig_globalvar *n = var->next;
35981 SWIGINTERN PyObject *
35982 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
35983 PyObject *res = NULL;
35984 swig_globalvar *var = v->vars;
35986 if (strcmp(var->name,n) == 0) {
35987 res = (*var->get_attr)();
35992 if (res == NULL && !PyErr_Occurred()) {
35993 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
35999 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
36001 swig_globalvar *var = v->vars;
36003 if (strcmp(var->name,n) == 0) {
36004 res = (*var->set_attr)(p);
36009 if (res == 1 && !PyErr_Occurred()) {
36010 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
36015 SWIGINTERN PyTypeObject*
36016 swig_varlink_type(void) {
36017 static char varlink__doc__[] = "Swig var link object";
36018 static PyTypeObject varlink_type;
36019 static int type_init = 0;
36021 const PyTypeObject tmp = {
36022 #if PY_VERSION_HEX >= 0x03000000
36023 PyVarObject_HEAD_INIT(NULL, 0)
36025 PyObject_HEAD_INIT(NULL)
36028 (char *)"swigvarlink", /* tp_name */
36029 sizeof(swig_varlinkobject), /* tp_basicsize */
36030 0, /* tp_itemsize */
36031 (destructor) swig_varlink_dealloc, /* tp_dealloc */
36032 (printfunc) swig_varlink_print, /* tp_print */
36033 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
36034 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
36035 0, /* tp_compare */
36036 (reprfunc) swig_varlink_repr, /* tp_repr */
36037 0, /* tp_as_number */
36038 0, /* tp_as_sequence */
36039 0, /* tp_as_mapping */
36042 (reprfunc) swig_varlink_str, /* tp_str */
36043 0, /* tp_getattro */
36044 0, /* tp_setattro */
36045 0, /* tp_as_buffer */
36047 varlink__doc__, /* tp_doc */
36048 0, /* tp_traverse */
36050 0, /* tp_richcompare */
36051 0, /* tp_weaklistoffset */
36052 #if PY_VERSION_HEX >= 0x02020000
36053 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
36055 #if PY_VERSION_HEX >= 0x02030000
36058 #if PY_VERSION_HEX >= 0x02060000
36059 0, /* tp_version_tag */
36061 #if PY_VERSION_HEX >= 0x03040000
36062 0, /* tp_finalize */
36064 #ifdef COUNT_ALLOCS
36067 0, /* tp_maxalloc */
36068 #if PY_VERSION_HEX >= 0x02050000
36074 varlink_type = tmp;
36076 #if PY_VERSION_HEX < 0x02020000
36077 varlink_type.ob_type = &PyType_Type;
36079 if (PyType_Ready(&varlink_type) < 0)
36083 return &varlink_type;
36086 /* Create a variable linking object for use later */
36087 SWIGINTERN PyObject *
36088 SWIG_Python_newvarlink(void) {
36089 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
36093 return ((PyObject*) result);
36097 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
36098 swig_varlinkobject *v = (swig_varlinkobject *) p;
36099 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
36101 size_t size = strlen(name)+1;
36102 gv->name = (char *)malloc(size);
36104 strncpy(gv->name,name,size);
36105 gv->get_attr = get_attr;
36106 gv->set_attr = set_attr;
36107 gv->next = v->vars;
36113 SWIGINTERN PyObject *
36114 SWIG_globals(void) {
36115 static PyObject *_SWIG_globals = 0;
36116 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
36117 return _SWIG_globals;
36120 /* -----------------------------------------------------------------------------
36121 * constants/methods manipulation
36122 * ----------------------------------------------------------------------------- */
36124 /* Install Constants */
36126 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
36129 for (i = 0; constants[i].type; ++i) {
36130 switch(constants[i].type) {
36131 case SWIG_PY_POINTER:
36132 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
36134 case SWIG_PY_BINARY:
36135 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
36142 PyDict_SetItemString(d, constants[i].name, obj);
36148 /* -----------------------------------------------------------------------------*/
36149 /* Fix SwigMethods to carry the callback ptrs when needed */
36150 /* -----------------------------------------------------------------------------*/
36153 SWIG_Python_FixMethods(PyMethodDef *methods,
36154 swig_const_info *const_table,
36155 swig_type_info **types,
36156 swig_type_info **types_initial) {
36158 for (i = 0; methods[i].ml_name; ++i) {
36159 const char *c = methods[i].ml_doc;
36161 c = strstr(c, "swig_ptr: ");
36164 swig_const_info *ci = 0;
36165 const char *name = c + 10;
36166 for (j = 0; const_table[j].type; ++j) {
36167 if (strncmp(const_table[j].name, name,
36168 strlen(const_table[j].name)) == 0) {
36169 ci = &(const_table[j]);
36174 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
36176 size_t shift = (ci->ptype) - types;
36177 swig_type_info *ty = types_initial[shift];
36178 size_t ldoc = (c - methods[i].ml_doc);
36179 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
36180 char *ndoc = (char*)malloc(ldoc + lptr + 10);
36183 strncpy(buff, methods[i].ml_doc, ldoc);
36185 strncpy(buff, "swig_ptr: ", 10);
36187 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
36188 methods[i].ml_doc = ndoc;
36200 /* -----------------------------------------------------------------------------*
36201 * Partial Init method
36202 * -----------------------------------------------------------------------------*/
36209 #if PY_VERSION_HEX >= 0x03000000
36215 PyObject *m, *d, *md;
36216 #if PY_VERSION_HEX >= 0x03000000
36217 static struct PyModuleDef SWIG_module = {
36218 # if PY_VERSION_HEX >= 0x03020000
36219 PyModuleDef_HEAD_INIT,
36222 PyObject_HEAD_INIT(NULL)
36228 (char *) SWIG_name,
36239 #if defined(SWIGPYTHON_BUILTIN)
36240 static SwigPyClientData SwigPyObject_clientdata = {
36241 0, 0, 0, 0, 0, 0, 0
36243 static PyGetSetDef this_getset_def = {
36244 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
36246 static SwigPyGetSet thisown_getset_closure = {
36247 (PyCFunction) SwigPyObject_own,
36248 (PyCFunction) SwigPyObject_own
36250 static PyGetSetDef thisown_getset_def = {
36251 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
36253 PyTypeObject *builtin_pytype;
36254 int builtin_base_count;
36255 swig_type_info *builtin_basetype;
36257 PyGetSetDescrObject *static_getset;
36258 PyTypeObject *metatype;
36259 PyTypeObject *swigpyobject;
36260 SwigPyClientData *cd;
36261 PyObject *public_interface, *public_symbol;
36262 PyObject *this_descr;
36263 PyObject *thisown_descr;
36264 PyObject *self = 0;
36267 (void)builtin_pytype;
36268 (void)builtin_base_count;
36269 (void)builtin_basetype;
36271 (void)static_getset;
36274 /* Metaclass is used to implement static member variables */
36275 metatype = SwigPyObjectType();
36279 /* Fix SwigMethods to carry the callback ptrs when needed */
36280 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
36282 #if PY_VERSION_HEX >= 0x03000000
36283 m = PyModule_Create(&SWIG_module);
36285 m = Py_InitModule((char *) SWIG_name, SwigMethods);
36288 md = d = PyModule_GetDict(m);
36291 SWIG_InitializeModule(0);
36293 #ifdef SWIGPYTHON_BUILTIN
36294 swigpyobject = SwigPyObject_TypeOnce();
36296 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
36297 assert(SwigPyObject_stype);
36298 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
36300 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
36301 SwigPyObject_clientdata.pytype = swigpyobject;
36302 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
36303 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
36304 # if PY_VERSION_HEX >= 0x03000000
36311 /* All objects have a 'this' attribute */
36312 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
36315 /* All objects have a 'thisown' attribute */
36316 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
36317 (void)thisown_descr;
36319 public_interface = PyList_New(0);
36321 (void)public_symbol;
36323 PyDict_SetItemString(md, "__all__", public_interface);
36324 Py_DECREF(public_interface);
36325 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
36326 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
36327 for (i = 0; swig_const_table[i].name != 0; ++i)
36328 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
36331 SWIG_InstallConstants(d,swig_const_table);
36333 SWIG_Python_SetConstant(d, "DumpActif",SWIG_From_bool(static_cast< bool >(true)));
36334 SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
36335 SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
36336 SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
36337 SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
36338 SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
36339 SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
36340 SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
36341 SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
36342 SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
36343 SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
36344 SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
36345 SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
36346 SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
36347 SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
36348 SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
36349 SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
36350 SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
36351 SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
36352 SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
36353 SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
36354 SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
36355 SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
36356 SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
36357 SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
36358 SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
36359 SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
36360 SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
36361 SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
36362 SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
36363 SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
36364 SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
36365 SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
36366 SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
36367 PyDict_SetItemString(md,(char *)"cvar", SWIG_globals());
36368 SWIG_addvarlink(SWIG_globals(),(char *)"ABR_TYPES",Swig_var_ABR_TYPES_get, Swig_var_ABR_TYPES_set);
36369 SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
36370 SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
36371 SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
36372 SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
36373 SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
36374 SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
36375 SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
36376 SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
36377 SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
36378 SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
36379 SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
36380 SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
36381 SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
36382 SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
36383 SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
36384 SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
36385 SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
36386 SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
36387 SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
36388 SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
36389 SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
36390 SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
36391 SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
36392 SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
36393 SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
36394 SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
36395 SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
36396 SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
36397 SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
36398 SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
36399 SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
36400 SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
36401 SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
36402 SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
36403 SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
36404 SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
36405 SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
36406 SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
36407 SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
36408 SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
36409 SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
36410 SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
36411 SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
36412 SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
36413 SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
36414 SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
36415 SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
36416 SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
36417 SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
36418 SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
36419 SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
36420 SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
36421 SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
36422 SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
36423 SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
36424 SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
36425 SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
36426 SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
36427 SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
36428 SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
36429 SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
36430 SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
36431 SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
36432 SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
36433 SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
36434 SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
36435 SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
36436 SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
36437 SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
36438 SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
36439 SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
36440 SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
36441 SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
36442 SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
36443 SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
36444 SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
36445 SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
36446 SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
36447 SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
36448 SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
36449 SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
36450 SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
36451 SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
36452 SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
36453 SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
36454 SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
36455 SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
36456 SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
36457 SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
36458 SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
36459 SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
36460 SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
36461 SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
36462 SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
36463 SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
36464 SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
36465 SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
36466 SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
36467 SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
36468 SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
36469 SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
36470 SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
36471 SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
36472 SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
36473 SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
36474 SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
36475 SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
36476 SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
36477 SWIG_addvarlink(SWIG_globals(),(char *)"Epsil",Swig_var_Epsil_get, Swig_var_Epsil_set);
36478 SWIG_addvarlink(SWIG_globals(),(char *)"UnEpsil",Swig_var_UnEpsil_get, Swig_var_UnEpsil_set);
36479 SWIG_addvarlink(SWIG_globals(),(char *)"Epsil2",Swig_var_Epsil2_get, Swig_var_Epsil2_set);
36480 #if PY_VERSION_HEX >= 0x03000000