/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.31
+ * Version 1.3.40
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
+
#ifdef __cplusplus
-template<class T> class SwigValueWrapper {
- T *tt;
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+ struct SwigMovePointer {
+ T *ptr;
+ SwigMovePointer(T *p) : ptr(p) { }
+ ~SwigMovePointer() { delete ptr; }
+ SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+ } pointer;
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
- SwigValueWrapper() : tt(0) { }
- SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
- SwigValueWrapper(const T& t) : tt(new T(t)) { }
- ~SwigValueWrapper() { delete tt; }
- SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
- operator T&() const { return *tt; }
- T *operator&() { return tt; }
-private:
- SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+ SwigValueWrapper() : pointer(0) { }
+ SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+ operator T&() const { return *pointer.ptr; }
+ T *operator&() { return pointer.ptr; }
};
+
+template <typename T> T SwigValueInit() {
+ return T();
+}
#endif
/* -----------------------------------------------------------------------------
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-# if (__SUNPRO_CC <= 0x560)
-# define SWIGTEMPLATEDISAMBIGUATOR template
-# else
-# define SWIGTEMPLATEDISAMBIGUATOR
-# endif
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+# define SWIGTEMPLATEDISAMBIGUATOR template
# else
-# define SWIGTEMPLATEDISAMBIGUATOR
+# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# define _CRT_SECURE_NO_DEPRECATE
#endif
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
/* Python.h has to appear first */
#include <Python.h>
/* -----------------------------------------------------------------------------
* swigrun.swg
*
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "3"
+#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
- creating a static or dynamic library from the swig runtime code.
- In 99.9% of the cases, swig just needs to declare them as 'static'.
+ creating a static or dynamic library from the SWIG runtime code.
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
- But only do this if is strictly necessary, ie, if you have problems
- with your compiler or so.
+ But only do this if strictly necessary, ie, if you have problems
+ with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
+#define SWIG_CAST_NEW_MEMORY 0x2
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
- The swig conversion methods, as ConvertPtr, return and integer
+ The SWIG conversion methods, as ConvertPtr, return and integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
- In old swig versions, you usually write code as:
+ In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
//fail code
}
- Now you can be more explicit as:
+ Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// fail code
}
- that seems to be the same, but now you can also do
+ which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
- requires also to SWIG_ConvertPtr to return new result values, as
+ also requires SWIG_ConvertPtr to return new result values, such as
int SWIG_ConvertPtr(obj, ptr,...) {
if (<obj is ok>) {
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
- swig errors code.
+ SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
+*/
-
- */
#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
#endif
-
-
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
-typedef void *(*swig_converter_func)(void *);
+typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
-/* Structure to store inforomation on one type */
+/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
- return (l1 - f1) - (l2 - f2);
+ return (int)((l1 - f1) - (l2 - f2));
}
/*
}
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty) \
- if (ty) { \
- swig_cast_info *iter = ty->cast; \
- while (iter) { \
- if (comparison) { \
- if (iter == ty->cast) return iter; \
- /* Move iter to the top of the linked list */ \
- iter->prev->next = iter->next; \
- if (iter->next) \
- iter->next->prev = iter->prev; \
- iter->next = ty->cast; \
- iter->prev = 0; \
- if (ty->cast) ty->cast->prev = iter; \
- ty->cast = iter; \
- return iter; \
- } \
- iter = iter->next; \
- } \
- } \
- return 0
-
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(iter->type->name, c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/*
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
- SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (iter->type == from) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
- return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
+/* Compatibility macros for Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+
+#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
+#define PyInt_Check(x) PyLong_Check(x)
+#define PyInt_AsLong(x) PyLong_AsLong(x)
+#define PyInt_FromLong(x) PyLong_FromLong(x)
+#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
+
+#endif
+
+#ifndef Py_TYPE
+# define Py_TYPE(op) ((op)->ob_type)
+#endif
+
+/* SWIG APIs for compatibility of both Python 2 & 3 */
+
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
+#else
+# define SWIG_Python_str_FromFormat PyString_FromFormat
+#endif
+
+
+/* Warning: This function will allocate a new string in Python 3,
+ * so please call SWIG_Python_str_DelForPy3(x) to free the space.
+ */
+SWIGINTERN char*
+SWIG_Python_str_AsChar(PyObject *str)
+{
+#if PY_VERSION_HEX >= 0x03000000
+ char *cstr;
+ char *newstr;
+ Py_ssize_t len;
+ str = PyUnicode_AsUTF8String(str);
+ PyBytes_AsStringAndSize(str, &cstr, &len);
+ newstr = (char *) malloc(len+1);
+ memcpy(newstr, cstr, len+1);
+ Py_XDECREF(str);
+ return newstr;
+#else
+ return PyString_AsString(str);
+#endif
+}
+
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
+#else
+# define SWIG_Python_str_DelForPy3(x)
+#endif
+
+
+SWIGINTERN PyObject*
+SWIG_Python_str_FromChar(const char *c)
+{
+#if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_FromString(c);
+#else
+ return PyString_FromString(c);
+#endif
+}
/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# define PyObject_GenericGetAttr 0
# endif
#endif
+
/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
# endif
#endif
-
/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
# endif
#endif
-
/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
if (value) {
+ char *tmp;
PyObject *old_str = PyObject_Str(value);
PyErr_Clear();
Py_XINCREF(type);
- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+
+ PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
+ SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
- PyErr_Format(PyExc_RuntimeError, mesg);
+ PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
-
-
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
swig_type_info **ptype;
} swig_const_info;
+
+/* -----------------------------------------------------------------------------
+ * Wrapper of PyInstanceMethod_New() used in Python 3
+ * It is exported to the generated module, used for -fastproxy
+ * ----------------------------------------------------------------------------- */
+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
+{
+#if PY_VERSION_HEX >= 0x03000000
+ return PyInstanceMethod_New(func);
+#else
+ return NULL;
+#endif
+}
+
#ifdef __cplusplus
#if 0
{ /* cc-mode */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
+#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
/* Unpack the argument tuple */
SWIGINTERN int
-SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
- name, (min == max ? "" : "at least "), min);
+ name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
- register int l = PyTuple_GET_SIZE(args);
+ register Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
- name, (min == max ? "" : "at least "), min, l);
+ name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
- name, (min == max ? "" : "at most "), max, l);
+ name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
register int i;
return none;
}
-/* PySwigClientData */
+/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *destroy;
int delargs;
int implicitconv;
-} PySwigClientData;
+} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
- PySwigClientData *data = (PySwigClientData *)ty->clientdata;
+ SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
return data ? data->implicitconv : 0;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
- PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
+ SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
-SWIGRUNTIME PySwigClientData *
-PySwigClientData_New(PyObject* obj)
+SWIGRUNTIME SwigPyClientData *
+SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
- PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
+ SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
}
SWIGRUNTIME void
-PySwigClientData_Del(PySwigClientData* data)
+SwigPyClientData_Del(SwigPyClientData* data)
{
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
}
-/* =============== PySwigObject =====================*/
+/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
swig_type_info *ty;
int own;
PyObject *next;
-} PySwigObject;
+} SwigPyObject;
SWIGRUNTIME PyObject *
-PySwigObject_long(PySwigObject *v)
+SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
-PySwigObject_format(const char* fmt, PySwigObject *v)
+SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
- if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
- PyObject *ofmt = PyString_FromString(fmt);
+ if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
+ PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
+#if PY_VERSION_HEX >= 0x03000000
+ res = PyUnicode_Format(ofmt,args);
+#else
res = PyString_Format(ofmt,args);
+#endif
Py_DECREF(ofmt);
}
Py_DECREF(args);
}
SWIGRUNTIME PyObject *
-PySwigObject_oct(PySwigObject *v)
+SwigPyObject_oct(SwigPyObject *v)
{
- return PySwigObject_format("%o",v);
+ return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
-PySwigObject_hex(PySwigObject *v)
+SwigPyObject_hex(SwigPyObject *v)
{
- return PySwigObject_format("%x",v);
+ return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
-PySwigObject_repr(PySwigObject *v)
+SwigPyObject_repr(SwigPyObject *v)
#else
-PySwigObject_repr(PySwigObject *v, PyObject *args)
+SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#endif
{
const char *name = SWIG_TypePrettyName(v->ty);
- PyObject *hex = PySwigObject_hex(v);
- PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
- Py_DECREF(hex);
+ PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
if (v->next) {
#ifdef METH_NOARGS
- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
+ PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
#else
- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
+ PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
#endif
+#if PY_VERSION_HEX >= 0x03000000
+ PyObject *joined = PyUnicode_Concat(repr, nrep);
+ Py_DecRef(repr);
+ Py_DecRef(nrep);
+ repr = joined;
+#else
PyString_ConcatAndDel(&repr,nrep);
+#endif
}
return repr;
}
SWIGRUNTIME int
-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
+ char *str;
#ifdef METH_NOARGS
- PyObject *repr = PySwigObject_repr(v);
+ PyObject *repr = SwigPyObject_repr(v);
#else
- PyObject *repr = PySwigObject_repr(v, NULL);
+ PyObject *repr = SwigPyObject_repr(v, NULL);
#endif
if (repr) {
- fputs(PyString_AsString(repr), fp);
+ str = SWIG_Python_str_AsChar(repr);
+ fputs(str, fp);
+ SWIG_Python_str_DelForPy3(str);
Py_DECREF(repr);
return 0;
} else {
}
SWIGRUNTIME PyObject *
-PySwigObject_str(PySwigObject *v)
+SwigPyObject_str(SwigPyObject *v)
{
char result[SWIG_BUFFER_SIZE];
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
- PyString_FromString(result) : 0;
+ SWIG_Python_str_FromChar(result) : 0;
}
SWIGRUNTIME int
-PySwigObject_compare(PySwigObject *v, PySwigObject *w)
+SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
+/* Added for Python 3.x, would it also be useful for Python 2.x? */
+SWIGRUNTIME PyObject*
+SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
+{
+ PyObject* res;
+ if( op != Py_EQ && op != Py_NE ) {
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+ }
+ if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
+ res = Py_True;
+ else
+ res = Py_False;
+ Py_INCREF(res);
+ return res;
+}
+
+
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
SWIGRUNTIME PyTypeObject*
-PySwigObject_type(void) {
+SwigPyObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
return type;
}
SWIGRUNTIMEINLINE int
-PySwigObject_Check(PyObject *op) {
- return ((op)->ob_type == PySwigObject_type())
- || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
+SwigPyObject_Check(PyObject *op) {
+ return (Py_TYPE(op) == SwigPyObject_type())
+ || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
}
SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own);
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
SWIGRUNTIME void
-PySwigObject_dealloc(PyObject *v)
+SwigPyObject_dealloc(PyObject *v)
{
- PySwigObject *sobj = (PySwigObject *) v;
+ SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
- if (sobj->own) {
+ if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+ SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
if (data->delargs) {
- /* we need to create a temporal object to carry the destroy operation */
- PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
+ /* we need to create a temporary object to carry the destroy operation */
+ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
res = SWIG_Python_CallFunctor(destroy, tmp);
Py_DECREF(tmp);
} else {
res = ((*meth)(mself, v));
}
Py_XDECREF(res);
- } else {
- const char *name = SWIG_TypePrettyName(ty);
+ }
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
- printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
-#endif
+ else {
+ const char *name = SWIG_TypePrettyName(ty);
+ printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
+#endif
}
Py_XDECREF(next);
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
-PySwigObject_append(PyObject* v, PyObject* next)
+SwigPyObject_append(PyObject* v, PyObject* next)
{
- PySwigObject *sobj = (PySwigObject *) v;
+ SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
PyObject *tmp = 0;
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
next = tmp;
#endif
- if (!PySwigObject_Check(next)) {
+ if (!SwigPyObject_Check(next)) {
return NULL;
}
sobj->next = next;
SWIGRUNTIME PyObject*
#ifdef METH_NOARGS
-PySwigObject_next(PyObject* v)
+SwigPyObject_next(PyObject* v)
#else
-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
- PySwigObject *sobj = (PySwigObject *) v;
+ SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
SWIGINTERN PyObject*
#ifdef METH_NOARGS
-PySwigObject_disown(PyObject *v)
+SwigPyObject_disown(PyObject *v)
#else
-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
- PySwigObject *sobj = (PySwigObject *)v;
+ SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
-PySwigObject_acquire(PyObject *v)
+SwigPyObject_acquire(PyObject *v)
#else
-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
- PySwigObject *sobj = (PySwigObject *)v;
+ SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
-PySwigObject_own(PyObject *v, PyObject *args)
+SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
}
else
{
- PySwigObject *sobj = (PySwigObject *)v;
+ SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
#ifdef METH_NOARGS
if (PyObject_IsTrue(val)) {
- PySwigObject_acquire(v);
+ SwigPyObject_acquire(v);
} else {
- PySwigObject_disown(v);
+ SwigPyObject_disown(v);
}
#else
if (PyObject_IsTrue(val)) {
- PySwigObject_acquire(v,args);
+ SwigPyObject_acquire(v,args);
} else {
- PySwigObject_disown(v,args);
+ SwigPyObject_disown(v,args);
}
#endif
}
#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
+ {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
+ {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
+ {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
+ {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
+ {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
+ {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#else
static PyMethodDef
swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
+ {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
+ {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
+ {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
+ {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
+ {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
+ {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#endif
#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
-PySwigObject_getattr(PySwigObject *sobj,char *name)
+SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
_PySwigObject_type(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
- static PyNumberMethods PySwigObject_as_number = {
+ static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
+ /* nb_divide removed in Python 3 */
+#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
+#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
- (coercion)0, /*nb_coerce*/
- (unaryfunc)PySwigObject_long, /*nb_int*/
- (unaryfunc)PySwigObject_long, /*nb_long*/
+#if PY_VERSION_HEX < 0x03000000
+ 0, /*nb_coerce*/
+#endif
+ (unaryfunc)SwigPyObject_long, /*nb_int*/
+#if PY_VERSION_HEX < 0x03000000
+ (unaryfunc)SwigPyObject_long, /*nb_long*/
+#else
+ 0, /*nb_reserved*/
+#endif
(unaryfunc)0, /*nb_float*/
- (unaryfunc)PySwigObject_oct, /*nb_oct*/
- (unaryfunc)PySwigObject_hex, /*nb_hex*/
-#if PY_VERSION_HEX >= 0x02020000
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
-#elif PY_VERSION_HEX >= 0x02000000
+#if PY_VERSION_HEX < 0x03000000
+ (unaryfunc)SwigPyObject_oct, /*nb_oct*/
+ (unaryfunc)SwigPyObject_hex, /*nb_hex*/
+#endif
+#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
+#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
};
- static PyTypeObject pyswigobject_type;
+ static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp
= {
+ /* PyObject header changed in Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
- (char *)"PySwigObject", /* tp_name */
- sizeof(PySwigObject), /* tp_basicsize */
+#endif
+ (char *)"SwigPyObject", /* tp_name */
+ sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
- (destructor)PySwigObject_dealloc, /* tp_dealloc */
- (printfunc)PySwigObject_print, /* tp_print */
+ (destructor)SwigPyObject_dealloc, /* tp_dealloc */
+ (printfunc)SwigPyObject_print, /* tp_print */
#if PY_VERSION_HEX < 0x02020000
- (getattrfunc)PySwigObject_getattr, /* tp_getattr */
+ (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
#else
(getattrfunc)0, /* tp_getattr */
#endif
(setattrfunc)0, /* tp_setattr */
- (cmpfunc)PySwigObject_compare, /* tp_compare */
- (reprfunc)PySwigObject_repr, /* tp_repr */
- &PySwigObject_as_number, /* tp_as_number */
+#if PY_VERSION_HEX >= 0x03000000
+ 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
+#else
+ (cmpfunc)SwigPyObject_compare, /* tp_compare */
+#endif
+ (reprfunc)SwigPyObject_repr, /* tp_repr */
+ &SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
- (reprfunc)PySwigObject_str, /* tp_str */
+ (reprfunc)SwigPyObject_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
- 0, /* tp_richcompare */
+ (richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0, /* tp_iter */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
- 0, /* tp_is_gc */
+ 0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
- 0, /* tp_subclasses */
+ 0, /* tp_subclasses */
0, /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
- pyswigobject_type = tmp;
- pyswigobject_type.ob_type = &PyType_Type;
+ swigpyobject_type = tmp;
+ /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
+ swigpyobject_type.ob_type = &PyType_Type;
+#endif
type_init = 1;
}
- return &pyswigobject_type;
+ return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own)
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
- PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
+ SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
void *pack;
swig_type_info *ty;
size_t size;
-} PySwigPacked;
+} SwigPyPacked;
SWIGRUNTIME int
-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
char result[SWIG_BUFFER_SIZE];
fputs("<Swig Packed ", fp);
}
SWIGRUNTIME PyObject *
-PySwigPacked_repr(PySwigPacked *v)
+SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
- return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
+ return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
- return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
+ return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
-PySwigPacked_str(PySwigPacked *v)
+SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
- return PyString_FromFormat("%s%s", result, v->ty->name);
+ return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
- return PyString_FromString(v->ty->name);
+ return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
+SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
SWIGRUNTIME PyTypeObject*
-PySwigPacked_type(void) {
+SwigPyPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
return type;
}
SWIGRUNTIMEINLINE int
-PySwigPacked_Check(PyObject *op) {
+SwigPyPacked_Check(PyObject *op) {
return ((op)->ob_type == _PySwigPacked_type())
- || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
+ || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
-PySwigPacked_dealloc(PyObject *v)
+SwigPyPacked_dealloc(PyObject *v)
{
- if (PySwigPacked_Check(v)) {
- PySwigPacked *sobj = (PySwigPacked *) v;
+ if (SwigPyPacked_Check(v)) {
+ SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
SWIGRUNTIME PyTypeObject*
_PySwigPacked_type(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
- static PyTypeObject pyswigpacked_type;
+ static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp
= {
+ /* PyObject header changed in Python 3 */
+#if PY_VERSION_HEX>=0x03000000
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
- (char *)"PySwigPacked", /* tp_name */
- sizeof(PySwigPacked), /* tp_basicsize */
+ 0, /* ob_size */
+#endif
+ (char *)"SwigPyPacked", /* tp_name */
+ sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
- (destructor)PySwigPacked_dealloc, /* tp_dealloc */
- (printfunc)PySwigPacked_print, /* tp_print */
+ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
+ (printfunc)SwigPyPacked_print, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
- (cmpfunc)PySwigPacked_compare, /* tp_compare */
- (reprfunc)PySwigPacked_repr, /* tp_repr */
- 0, /* tp_as_number */
+#if PY_VERSION_HEX>=0x03000000
+ 0, /* tp_reserved in 3.0.1 */
+#else
+ (cmpfunc)SwigPyPacked_compare, /* tp_compare */
+#endif
+ (reprfunc)SwigPyPacked_repr, /* tp_repr */
+ 0, /* tp_as_number */
0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- (reprfunc)PySwigPacked_str, /* tp_str */
+ 0, /* tp_as_mapping */
+ (hashfunc)0, /* tp_hash */
+ (ternaryfunc)0, /* tp_call */
+ (reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
- pyswigpacked_type = tmp;
- pyswigpacked_type.ob_type = &PyType_Type;
+ swigpypacked_type = tmp;
+ /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
+ swigpypacked_type.ob_type = &PyType_Type;
+#endif
type_init = 1;
}
- return &pyswigpacked_type;
+ return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
+SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
- PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
+ SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
}
SWIGRUNTIME swig_type_info *
-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
+SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
- if (PySwigPacked_Check(obj)) {
- PySwigPacked *sobj = (PySwigPacked *)obj;
+ if (SwigPyPacked_Check(obj)) {
+ SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
- return PyString_FromString("this");
+ return SWIG_Python_str_FromChar("this");
}
SWIGRUNTIME PyObject *
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
-SWIGRUNTIME PySwigObject *
+/* TODO: I don't know how to implement the fast getset in Python 3 right now */
+#if PY_VERSION_HEX>=0x03000000
+#define SWIG_PYTHON_SLOW_GETSET_THIS
+#endif
+
+SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
- if (PySwigObject_Check(pyobj)) {
- return (PySwigObject *) pyobj;
+ if (SwigPyObject_Check(pyobj)) {
+ return (SwigPyObject *) pyobj;
} else {
PyObject *obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
return 0;
}
#endif
- if (obj && !PySwigObject_Check(obj)) {
+ if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
- PySwigObject from it */
+ SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
- return (PySwigObject *)obj;
+ return (SwigPyObject *)obj;
}
}
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
- if (own) {
- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+ if (own == SWIG_POINTER_OWN) {
+ SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
if (ptr) *ptr = 0;
return SWIG_OK;
} else {
- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+ SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
+ if (own)
+ *own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
- sobj = (PySwigObject *)sobj->next;
+ sobj = (SwigPyObject *)sobj->next;
} else {
- if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
+ if (ptr) {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
+ assert(own);
+ if (own)
+ *own = *own | SWIG_CAST_NEW_MEMORY;
+ }
+ }
break;
}
}
}
}
if (sobj) {
- if (own) *own = sobj->own;
+ if (own)
+ *own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
} else {
int res = SWIG_ERROR;
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+ SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
impconv = 0;
}
if (impconv) {
- PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
+ SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
- if (desc) {
+ if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
- if (!desc) return SWIG_ERROR;
- }
+ if (!desc)
+ return SWIG_ERROR;
if (ty) {
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
- if (!tc) return SWIG_ERROR;
- *ptr = SWIG_TypeCast(tc,vptr);
+ if (tc) {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+ assert(!newmemory); /* newmemory handling not yet implemented */
+ } else {
+ return SWIG_ERROR;
+ }
} else {
*ptr = vptr;
}
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
- swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
+ swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
* ----------------------------------------------------------------------------- */
/*
- Create a new instance object, whitout calling __init__, and set the
+ Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
+SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
PyObject *inst = 0;
#endif
}
} else {
+#if PY_VERSION_HEX >= 0x03000000
+ inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
+ PyObject_SetAttr(inst, SWIG_This(), swig_this);
+ Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
+#else
PyObject *dict = PyDict_New();
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
+#endif
}
return inst;
#else
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
return NULL;
} else {
- PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
+ SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
- PySwigObject_append((PyObject*) sthis, obj[1]);
+ SwigPyObject_append((PyObject*) sthis, obj[1]);
} else {
SWIG_Python_SetSwigThis(obj[0], obj[1]);
}
return SWIG_Py_Void();
} else {
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
- PyObject *robj = PySwigObject_New(ptr, type, own);
- PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
+ PyObject *robj = SwigPyObject_New(ptr, type, own);
+ SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
if (inst) {
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
- return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
+ return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
- PySwigClientData *data = (PySwigClientData *) ty->clientdata;
- if (data) PySwigClientData_Del(data);
+ SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
+ if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
SWIG_Python_SetModule(swig_module_info *swig_module) {
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
+#if PY_VERSION_HEX >= 0x03000000
+ /* Add a dummy module object into sys.modules */
+ PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
+#else
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
swig_empty_runtime_method_table);
+#endif
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
if (pointer && module) {
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
- PyObject *key = PyString_FromString(type);
+ PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
-{
+{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
+ char *tmp;
PyObject *old_str = PyObject_Str(value);
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
- PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
+ PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
} else {
- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+ PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
}
+ SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
}
return 1;
}
SWIGRUNTIMEINLINE const char *
-PySwigObject_GetDesc(PyObject *self)
+SwigPyObject_GetDesc(PyObject *self)
{
- PySwigObject *v = (PySwigObject *)self;
+ SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : (char*)"";
}
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
- if (obj && PySwigObject_Check(obj)) {
- const char *otype = (const char *) PySwigObject_GetDesc(obj);
+ if (obj && SwigPyObject_Check(obj)) {
+ const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
- const char *cstr = str ? PyString_AsString(str) : 0;
+ const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
+ SWIG_Python_str_DelForPy3(cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
- if (flags & SWIG_POINTER_EXCEPTION) {
+#if SWIG_POINTER_EXCEPTION
+ if (flags) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
}
+#endif
}
return result;
}
#define SWIGTYPE_p_reference swig_types[26]
#define SWIGTYPE_p_size_type swig_types[27]
#define SWIGTYPE_p_std__invalid_argument swig_types[28]
-#define SWIGTYPE_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t swig_types[29]
-#define SWIGTYPE_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t swig_types[30]
-#define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t swig_types[31]
-#define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type swig_types[32]
-#define SWIGTYPE_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t swig_types[33]
-#define SWIGTYPE_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t swig_types[34]
-#define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t swig_types[35]
-#define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type swig_types[36]
-#define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t swig_types[37]
-#define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type swig_types[38]
-#define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t swig_types[39]
-#define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type swig_types[40]
-#define SWIGTYPE_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t swig_types[41]
-#define SWIGTYPE_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t swig_types[42]
-#define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t swig_types[43]
-#define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type swig_types[44]
-#define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t swig_types[45]
-#define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type swig_types[46]
-#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[47]
-#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[48]
-#define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t swig_types[49]
+#define SWIGTYPE_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t swig_types[29]
+#define SWIGTYPE_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t swig_types[30]
+#define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t swig_types[31]
+#define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type swig_types[32]
+#define SWIGTYPE_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t swig_types[33]
+#define SWIGTYPE_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t swig_types[34]
+#define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t swig_types[35]
+#define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type swig_types[36]
+#define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t swig_types[37]
+#define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type swig_types[38]
+#define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t swig_types[39]
+#define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type swig_types[40]
+#define SWIGTYPE_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t swig_types[41]
+#define SWIGTYPE_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t swig_types[42]
+#define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t swig_types[43]
+#define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type swig_types[44]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[45]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type swig_types[46]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[47]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[48]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[49]
#define SWIGTYPE_p_string swig_types[50]
-#define SWIGTYPE_p_swig__PySwigIterator swig_types[51]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[51]
#define SWIGTYPE_p_value_type swig_types[52]
-#define SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type swig_types[53]
-#define SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type swig_types[54]
-#define SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type swig_types[55]
-#define SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type swig_types[56]
-#define SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type swig_types[57]
+#define SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type swig_types[53]
+#define SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type swig_types[54]
+#define SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type swig_types[55]
+#define SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type swig_types[56]
+#define SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type swig_types[57]
static swig_type_info *swig_types[59];
static swig_module_info swig_module = {swig_types, 58, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
/*-----------------------------------------------
@(target):= _hexablock_swig.so
------------------------------------------------*/
-#define SWIG_init init_hexablock_swig
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_init PyInit__hexablock_swig
+
+#else
+# define SWIG_init init_hexablock_swig
+#endif
#define SWIG_name "_hexablock_swig"
-#define SWIGVERSION 0x010331
+#define SWIGVERSION 0x010340
#define SWIG_VERSION SWIGVERSION
namespace swig {
- class PyObject_ptr {
+ class SwigPtr_PyObject {
protected:
PyObject *_obj;
public:
- PyObject_ptr() :_obj(0)
+ SwigPtr_PyObject() :_obj(0)
{
}
- PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
+ SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
{
Py_XINCREF(_obj);
}
- PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
+ SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
{
- if (initial_ref) Py_XINCREF(_obj);
+ if (initial_ref) {
+ Py_XINCREF(_obj);
+ }
}
- PyObject_ptr & operator=(const PyObject_ptr& item)
+ SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
{
Py_XINCREF(item._obj);
Py_XDECREF(_obj);
return *this;
}
- ~PyObject_ptr()
+ ~SwigPtr_PyObject()
{
Py_XDECREF(_obj);
}
namespace swig {
- struct PyObject_var : PyObject_ptr {
- PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
+ struct SwigVar_PyObject : SwigPtr_PyObject {
+ SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
- PyObject_var & operator = (PyObject* obj)
+ SwigVar_PyObject & operator = (PyObject* obj)
{
Py_XDECREF(_obj);
_obj = obj;
#include <stdexcept>
-
-#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
-# define SWIG_STD_NOASSIGN_STL
-# define SWIG_STD_NOINSERT_TEMPLATE_STL
-# define SWIG_STD_NOITERATOR_TRAITS_STL
-#endif
-
#if defined(__GNUC__)
# if __GNUC__ == 2 && __GNUC_MINOR <= 96
# define SWIG_STD_NOMODERN_STL
#endif
-
-
#include <string>
#include <stdexcept>
struct stop_iteration {
};
- struct PySwigIterator {
+ struct SwigPyIterator {
private:
- PyObject_ptr _seq;
+ SwigPtr_PyObject _seq;
protected:
- PySwigIterator(PyObject *seq) : _seq(seq)
+ SwigPyIterator(PyObject *seq) : _seq(seq)
{
}
public:
- virtual ~PySwigIterator() {}
+ virtual ~SwigPyIterator() {}
// Access iterator method, required by Python
virtual PyObject *value() const = 0;
// Forward iterator method, required by Python
- virtual PySwigIterator *incr(size_t n = 1) = 0;
+ virtual SwigPyIterator *incr(size_t n = 1) = 0;
// Backward iterator method, very common in C++, but not required in Python
- virtual PySwigIterator *decr(size_t n = 1)
+ virtual SwigPyIterator *decr(size_t /*n*/ = 1)
{
throw stop_iteration();
}
// Random access iterator methods, but not required in Python
- virtual ptrdiff_t distance(const PySwigIterator &x) const
+ virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
- virtual bool equal (const PySwigIterator &x) const
+ virtual bool equal (const SwigPyIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
// C++ common/needed methods
- virtual PySwigIterator *copy() const = 0;
+ virtual SwigPyIterator *copy() const = 0;
- PyObject *next()
+ PyObject *next()
{
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
PyObject *obj = value();
- incr();
- return obj;
+ incr();
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+ return obj;
+ }
+
+ /* Make an alias for Python 3.x */
+ PyObject *__next__()
+ {
+ return next();
}
PyObject *previous()
{
+ SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
decr();
- return value();
+ PyObject *obj = value();
+ SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+ return obj;
}
- PySwigIterator *advance(ptrdiff_t n)
+ SwigPyIterator *advance(ptrdiff_t n)
{
return (n > 0) ? incr(n) : decr(-n);
}
- bool operator == (const PySwigIterator& x) const
+ bool operator == (const SwigPyIterator& x) const
{
return equal(x);
}
- bool operator != (const PySwigIterator& x) const
+ bool operator != (const SwigPyIterator& x) const
{
return ! operator==(x);
}
- PySwigIterator& operator += (ptrdiff_t n)
+ SwigPyIterator& operator += (ptrdiff_t n)
{
return *advance(n);
}
- PySwigIterator& operator -= (ptrdiff_t n)
+ SwigPyIterator& operator -= (ptrdiff_t n)
{
return *advance(-n);
}
- PySwigIterator* operator + (ptrdiff_t n) const
+ SwigPyIterator* operator + (ptrdiff_t n) const
{
return copy()->advance(n);
}
- PySwigIterator* operator - (ptrdiff_t n) const
+ SwigPyIterator* operator - (ptrdiff_t n) const
{
return copy()->advance(-n);
}
- ptrdiff_t operator - (const PySwigIterator& x) const
+ ptrdiff_t operator - (const SwigPyIterator& x) const
{
return x.distance(*this);
}
static int init = 0;
static swig_type_info* desc = 0;
if (!init) {
- desc = SWIG_TypeQuery("swig::PySwigIterator *");
+ desc = SWIG_TypeQuery("swig::SwigPyIterator *");
init = 1;
}
return desc;
struct traits_asptr {
static int asptr(PyObject *obj, Type **val) {
Type *p;
- int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
+ int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
if (SWIG_IsOK(res)) {
if (val) *val = p;
}
int res = asval(obj, &v);
if (!obj || !SWIG_IsOK(res)) {
if (!PyErr_Occurred()) {
- SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
}
if (throw_error) throw std::invalid_argument("bad type");
}
{
bool res;
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
- res = PyObject_Compare(v, w) < 0;
+ res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
+ /* This may fall into a case of inconsistent
+ eg. ObjA > ObjX > ObjB
+ but ObjA < ObjB
+ */
+ if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
+ {
+ /* Objects can't be compared, this mostly occurred in Python 3.0 */
+ /* Compare their ptr directly for a workaround */
+ res = (v < w);
+ PyErr_Clear();
+ }
SWIG_PYTHON_THREAD_END_BLOCK;
return res;
}
};
template <>
- struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
+ struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
{
bool
- operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
+ operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
{
return std::less<PyObject *>()(v, w);
}
};
template <>
- struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
+ struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
{
bool
- operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
+ operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
{
return std::less<PyObject *>()(v, w);
}
}
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
+# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
+# define SWIG_STD_NOITERATOR_TRAITS_STL
+# endif
+#endif
+
#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
-namespace std {
+namespace std {
template <class Iterator>
struct iterator_traits {
typedef ptrdiff_t difference_type;
typedef typename Iterator::value_type value_type;
};
-#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
typedef Distance difference_type;
typedef T value_type;
};
-#endif
template <class T>
struct iterator_traits<T*> {
}
return __n;
}
-
-}
+}
#endif
namespace swig {
template<typename OutIterator>
- class PySwigIterator_T : public PySwigIterator
+ class SwigPyIterator_T : public SwigPyIterator
{
public:
typedef OutIterator out_iterator;
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
- typedef PySwigIterator_T<out_iterator> self_type;
+ typedef SwigPyIterator_T<out_iterator> self_type;
- PySwigIterator_T(out_iterator curr, PyObject *seq)
- : PySwigIterator(seq), current(curr)
+ SwigPyIterator_T(out_iterator curr, PyObject *seq)
+ : SwigPyIterator(seq), current(curr)
{
}
}
- bool equal (const PySwigIterator &iter) const
+ bool equal (const SwigPyIterator &iter) const
{
const self_type *iters = dynamic_cast<const self_type *>(&iter);
if (iters) {
}
}
- ptrdiff_t distance(const PySwigIterator &iter) const
+ ptrdiff_t distance(const SwigPyIterator &iter) const
{
const self_type *iters = dynamic_cast<const self_type *>(&iter);
if (iters) {
template<typename OutIterator,
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
typename FromOper = from_oper<ValueType> >
- class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
+ class SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
- typedef PySwigIterator_T<out_iterator> base;
- typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+ typedef SwigPyIterator_T<out_iterator> base;
+ typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
- PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
- : PySwigIterator_T<OutIterator>(curr, seq)
+ SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
+ : SwigPyIterator_T<OutIterator>(curr, seq)
{
}
return from(static_cast<const value_type&>(*(base::current)));
}
- PySwigIterator *copy() const
+ SwigPyIterator *copy() const
{
return new self_type(*this);
}
- PySwigIterator *incr(size_t n = 1)
+ SwigPyIterator *incr(size_t n = 1)
{
while (n--) {
++base::current;
return this;
}
- PySwigIterator *decr(size_t n = 1)
+ SwigPyIterator *decr(size_t n = 1)
{
while (n--) {
--base::current;
template<typename OutIterator,
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
typename FromOper = from_oper<ValueType> >
- class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
+ class SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
- typedef PySwigIterator_T<out_iterator> base;
- typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+ typedef SwigPyIterator_T<out_iterator> base;
+ typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
- PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
- : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
+ SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
+ : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
{
}
}
}
- PySwigIterator *copy() const
+ SwigPyIterator *copy() const
{
return new self_type(*this);
}
- PySwigIterator *incr(size_t n = 1)
+ SwigPyIterator *incr(size_t n = 1)
{
while (n--) {
if (base::current == end) {
return this;
}
- PySwigIterator *decr(size_t n = 1)
+ SwigPyIterator *decr(size_t n = 1)
{
while (n--) {
if (base::current == begin) {
};
template<typename OutIter>
- inline PySwigIterator*
+ inline SwigPyIterator*
make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
{
- return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
+ return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
}
template<typename OutIter>
- inline PySwigIterator*
+ inline SwigPyIterator*
make_output_iterator(const OutIter& current, PyObject *seq = 0)
{
- return new PySwigIteratorOpen_T<OutIter>(current, seq);
+ return new SwigPyIteratorOpen_T<OutIter>(current, seq);
}
}
namespace swig
{
template <class T>
- struct PySequence_Ref
+ struct SwigPySequence_Ref
{
- PySequence_Ref(PyObject* seq, int index)
+ SwigPySequence_Ref(PyObject* seq, int index)
: _seq(seq), _index(index)
{
}
operator T () const
{
- swig::PyObject_var item = PySequence_GetItem(_seq, _index);
+ swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
try {
return swig::as<T>(item, true);
} catch (std::exception& e) {
char msg[1024];
sprintf(msg, "in sequence element %d ", _index);
if (!PyErr_Occurred()) {
- SWIG_Error(SWIG_TypeError, swig::type_name<T>());
+ ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
}
SWIG_Python_AddErrorMsg(msg);
SWIG_Python_AddErrorMsg(e.what());
}
}
- PySequence_Ref& operator=(const T& v)
+ SwigPySequence_Ref& operator=(const T& v)
{
PySequence_SetItem(_seq, _index, swig::from<T>(v));
return *this;
};
template <class T>
- struct PySequence_ArrowProxy
+ struct SwigPySequence_ArrowProxy
{
- PySequence_ArrowProxy(const T& x): m_value(x) {}
+ SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
const T* operator->() const { return &m_value; }
operator const T*() const { return &m_value; }
T m_value;
};
template <class T, class Reference >
- struct PySequence_InputIterator
+ struct SwigPySequence_InputIterator
{
- typedef PySequence_InputIterator<T, Reference > self;
+ typedef SwigPySequence_InputIterator<T, Reference > self;
typedef std::random_access_iterator_tag iterator_category;
typedef Reference reference;
typedef T* pointer;
typedef int difference_type;
- PySequence_InputIterator()
+ SwigPySequence_InputIterator()
{
}
- PySequence_InputIterator(PyObject* seq, int index)
+ SwigPySequence_InputIterator(PyObject* seq, int index)
: _seq(seq), _index(index)
{
}
return reference(_seq, _index);
}
- PySequence_ArrowProxy<T>
+ SwigPySequence_ArrowProxy<T>
operator->() const {
- return PySequence_ArrowProxy<T>(operator*());
+ return SwigPySequence_ArrowProxy<T>(operator*());
}
bool operator==(const self& ri) const
};
template <class T>
- struct PySequence_Cont
+ struct SwigPySequence_Cont
{
- typedef PySequence_Ref<T> reference;
- typedef const PySequence_Ref<T> const_reference;
+ typedef SwigPySequence_Ref<T> reference;
+ typedef const SwigPySequence_Ref<T> const_reference;
typedef T value_type;
typedef T* pointer;
typedef int difference_type;
typedef int size_type;
typedef const pointer const_pointer;
- typedef PySequence_InputIterator<T, reference> iterator;
- typedef PySequence_InputIterator<T, const_reference> const_iterator;
+ typedef SwigPySequence_InputIterator<T, reference> iterator;
+ typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
- PySequence_Cont(PyObject* seq) : _seq(0)
+ SwigPySequence_Cont(PyObject* seq) : _seq(0)
{
if (!PySequence_Check(seq)) {
throw std::invalid_argument("a sequence is expected");
Py_INCREF(_seq);
}
- ~PySequence_Cont()
+ ~SwigPySequence_Cont()
{
- if (_seq) Py_DECREF(_seq);
+ Py_XDECREF(_seq);
}
size_type size() const
{
- return PySequence_Size(_seq);
+ return static_cast<size_type>(PySequence_Size(_seq));
}
bool empty() const
{
int s = size();
for (int i = 0; i < s; ++i) {
- swig::PyObject_var item = PySequence_GetItem(_seq, i);
+ swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
if (!swig::check<value_type>(item)) {
if (set_err) {
char msg[1024];
namespace swig {
- template <class PySeq, class Seq>
+ template <class SwigPySeq, class Seq>
inline void
- assign(const PySeq& pyseq, Seq* seq) {
-#ifdef SWIG_STD_NOASSIGN_STL
- typedef typename PySeq::value_type value_type;
- typename PySeq::const_iterator it = pyseq.begin();
- for (;it != pyseq.end(); ++it) {
+ assign(const SwigPySeq& swigpyseq, Seq* seq) {
+ // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
+ typedef typename SwigPySeq::value_type value_type;
+ typename SwigPySeq::const_iterator it = swigpyseq.begin();
+ for (;it != swigpyseq.end(); ++it) {
seq->insert(seq->end(),(value_type)(*it));
}
-#else
- seq->assign(pyseq.begin(), pyseq.end());
-#endif
}
template <class Seq, class T = typename Seq::value_type >
typedef T value_type;
static int asptr(PyObject *obj, sequence **seq) {
- if (PySequence_Check(obj)) {
+ if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
+ sequence *p;
+ if (::SWIG_ConvertPtr(obj,(void**)&p,
+ swig::type_info<sequence>(),0) == SWIG_OK) {
+ if (seq) *seq = p;
+ return SWIG_OLDOBJ;
+ }
+ } else if (PySequence_Check(obj)) {
try {
- PySequence_Cont<value_type> pyseq(obj);
+ SwigPySequence_Cont<value_type> swigpyseq(obj);
if (seq) {
sequence *pseq = new sequence();
- assign(pyseq, pseq);
+ assign(swigpyseq, pseq);
*seq = pseq;
return SWIG_NEWOBJ;
} else {
- return pyseq.check() ? SWIG_OK : SWIG_ERROR;
+ return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
}
} catch (std::exception& e) {
if (seq) {
}
return SWIG_ERROR;
}
- } else {
- sequence *p;
- if (SWIG_ConvertPtr(obj,(void**)&p,
- swig::type_info<sequence>(),0) == SWIG_OK) {
- if (seq) *seq = p;
- return SWIG_OLDOBJ;
- }
}
return SWIG_ERROR;
}
typedef typename sequence::const_iterator const_iterator;
static PyObject *from(const sequence& seq) {
-
-
-
-
-
-
+#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
+ swig_type_info *desc = swig::type_info<sequence>();
+ if (desc && desc->clientdata) {
+ return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+ }
+#endif
size_type size = seq.size();
if (size <= (size_type)INT_MAX) {
PyObject *obj = PyTuple_New((int)size);
namespace swig {
- template <> struct traits<std::vector<Hex::Hexa*, std::allocator<Hex::Hexa * > > > {
+ template <> struct traits<std::vector<Hex::Hexa*, std::allocator< Hex::Hexa * > > > {
typedef value_category category;
static const char* type_name() {
- return "std::vector<" "Hex::Hexa" " *," "std::allocator<Hex::Hexa * >" " >";
+ return "std::vector<" "Hex::Hexa" " *," "std::allocator< Hex::Hexa * >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector<Hex::Hexa * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector< Hex::Hexa * > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector<Hex::Hexa * > const *self){
+SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector< Hex::Hexa * > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____bool__(std::vector< Hex::Hexa * > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector<Hex::Hexa * > const *self){
+SWIGINTERN std::vector< Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector< Hex::Hexa * > const *self){
return self->size();
}
return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
}
-SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector<Hex::Hexa * > *self){
+SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector< Hex::Hexa * > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >::value_type x = self->back();
+ std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::difference_type j,std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &v){
+SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &v){
swig::setslice(self, i, j, v);
}
-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){
+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){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
+SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::value_type x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::value_type x){
self->push_back(x);
}
namespace swig {
- template <> struct traits<std::vector<Hex::Quad*, std::allocator<Hex::Quad * > > > {
+ template <> struct traits<std::vector<Hex::Quad*, std::allocator< Hex::Quad * > > > {
typedef value_category category;
static const char* type_name() {
- return "std::vector<" "Hex::Quad" " *," "std::allocator<Hex::Quad * >" " >";
+ return "std::vector<" "Hex::Quad" " *," "std::allocator< Hex::Quad * >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector<Hex::Quad * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector< Hex::Quad * > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector<Hex::Quad * > const *self){
+SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector< Hex::Quad * > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____bool__(std::vector< Hex::Quad * > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector<Hex::Quad * > const *self){
+SWIGINTERN std::vector< Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector< Hex::Quad * > const *self){
return self->size();
}
-SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector<Hex::Quad * > *self){
+SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector< Hex::Quad * > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >::value_type x = self->back();
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::difference_type j,std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &v){
+SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &v){
swig::setslice(self, i, j, v);
}
-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){
+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){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
+SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::value_type x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::value_type x){
self->push_back(x);
}
namespace swig {
- template <> struct traits<std::vector<Hex::Edge*, std::allocator<Hex::Edge * > > > {
+ template <> struct traits<std::vector<Hex::Edge*, std::allocator< Hex::Edge * > > > {
typedef value_category category;
static const char* type_name() {
- return "std::vector<" "Hex::Edge" " *," "std::allocator<Hex::Edge * >" " >";
+ return "std::vector<" "Hex::Edge" " *," "std::allocator< Hex::Edge * >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector<Hex::Edge * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector< Hex::Edge * > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector<Hex::Edge * > const *self){
+SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector< Hex::Edge * > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____bool__(std::vector< Hex::Edge * > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector<Hex::Edge * > const *self){
+SWIGINTERN std::vector< Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector< Hex::Edge * > const *self){
return self->size();
}
-SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector<Hex::Edge * > *self){
+SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector< Hex::Edge * > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >::value_type x = self->back();
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::difference_type j,std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &v){
+SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &v){
swig::setslice(self, i, j, v);
}
-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){
+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){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
+SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::value_type x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::value_type x){
self->push_back(x);
}
namespace swig {
- template <> struct traits<std::vector<Hex::Vertex*, std::allocator<Hex::Vertex * > > > {
+ template <> struct traits<std::vector<Hex::Vertex*, std::allocator< Hex::Vertex * > > > {
typedef value_category category;
static const char* type_name() {
- return "std::vector<" "Hex::Vertex" " *," "std::allocator<Hex::Vertex * >" " >";
+ return "std::vector<" "Hex::Vertex" " *," "std::allocator< Hex::Vertex * >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector<Hex::Vertex * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector< Hex::Vertex * > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector<Hex::Vertex * > const *self){
+SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector< Hex::Vertex * > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____bool__(std::vector< Hex::Vertex * > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector<Hex::Vertex * > const *self){
+SWIGINTERN std::vector< Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector< Hex::Vertex * > const *self){
return self->size();
}
-SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector<Hex::Vertex * > *self){
+SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector< Hex::Vertex * > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >::value_type x = self->back();
+ std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::difference_type j,std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &v){
+SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &v){
swig::setslice(self, i, j, v);
}
-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){
+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){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
+SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::value_type x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::value_type x){
self->push_back(x);
}
namespace swig {
- template <> struct traits<std::vector<Hex::NewShape*, std::allocator<Hex::NewShape * > > > {
+ template <> struct traits<std::vector<Hex::NewShape*, std::allocator< Hex::NewShape * > > > {
typedef value_category category;
static const char* type_name() {
- return "std::vector<" "Hex::NewShape" " *," "std::allocator<Hex::NewShape * >" " >";
+ return "std::vector<" "Hex::NewShape" " *," "std::allocator< Hex::NewShape * >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector<Hex::NewShape * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector< Hex::NewShape * > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector<Hex::NewShape * > const *self){
+SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector< Hex::NewShape * > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____bool__(std::vector< Hex::NewShape * > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector<Hex::NewShape * > const *self){
+SWIGINTERN std::vector< Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector< Hex::NewShape * > const *self){
return self->size();
}
-SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector<Hex::NewShape * > *self){
+SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector< Hex::NewShape * > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >::value_type x = self->back();
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::difference_type j,std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &v){
+SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &v){
swig::setslice(self, i, j, v);
}
-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){
+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){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
+SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+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){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::value_type x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::value_type x){
+SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::value_type x){
self->push_back(x);
}
namespace swig {
- template <> struct traits<std::vector<double, std::allocator<double > > > {
+ template <> struct traits<std::vector<double, std::allocator< double > > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "double" "," "std::allocator<double >" " >";
+ return "std::vector<" "double" "," "std::allocator< double >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_double_Sg__iterator(std::vector<double > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector<double > const *self){
+SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<double >::size_type std_vector_Sl_double_Sg____len__(std::vector<double > const *self){
+SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
return self->size();
}
-SWIGINTERN std::vector<double >::value_type std_vector_Sl_double_Sg__pop(std::vector<double > *self){
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<double,std::allocator<double > >::value_type x = self->back();
+ std::vector<double,std::allocator< double > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::difference_type j,std::vector<double,std::allocator<double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
swig::setslice(self, i, j, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::difference_type j){
+SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem__(std::vector<double > *self,std::vector<double >::difference_type i){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<double >::value_type const &std_vector_Sl_double_Sg____getitem__(std::vector<double > const *self,std::vector<double >::difference_type i){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::value_type const &x){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector<double > *self,std::vector<double >::value_type const &x){
+SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
self->push_back(x);
}
#include <limits.h>
-#ifndef LLONG_MIN
-# define LLONG_MIN LONG_LONG_MIN
-#endif
-#ifndef LLONG_MAX
-# define LLONG_MAX LONG_LONG_MAX
-#endif
-#ifndef ULLONG_MAX
-# define ULLONG_MAX ULONG_LONG_MAX
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+# define LLONG_MAX __LONG_LONG_MAX__
+# define LLONG_MIN (-LLONG_MAX - 1LL)
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
#endif
namespace swig {
- template <> struct traits<std::vector<int, std::allocator<int > > > {
+ template <> struct traits<std::vector<int, std::allocator< int > > > {
typedef pointer_category category;
static const char* type_name() {
- return "std::vector<" "int" "," "std::allocator<int >" " >";
+ return "std::vector<" "int" "," "std::allocator< int >" " >";
}
};
}
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector<int > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
-SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector<int > const *self){
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
return !(self->empty());
}
-SWIGINTERN std::vector<int >::size_type std_vector_Sl_int_Sg____len__(std::vector<int > const *self){
+SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
+ return !(self->empty());
+ }
+SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
return self->size();
}
-SWIGINTERN std::vector<int >::value_type std_vector_Sl_int_Sg__pop(std::vector<int > *self){
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
- std::vector<int,std::allocator<int > >::value_type x = self->back();
+ std::vector<int,std::allocator< int > >::value_type x = self->back();
self->pop_back();
return x;
}
-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){
+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){
return swig::getslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j,std::vector<int,std::allocator<int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
swig::setslice(self, i, j, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
swig::delslice(self, i, j);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector<int > *self,std::vector<int >::difference_type i){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
self->erase(swig::getpos(self,i));
}
-SWIGINTERN std::vector<int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector<int > const *self,std::vector<int >::difference_type i){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return NULL;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ return swig::getslice(self, i, j);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::setslice(self, i, j, v);
+ }
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+ Py_ssize_t i, j, step;
+ if( !PySlice_Check(slice) ) {
+ SWIG_Error(SWIG_TypeError, "Slice object expected.");
+ return;
+ }
+ PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+ swig::delslice(self, i,j);
+ }
+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){
return *(swig::cgetpos(self, i));
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::value_type const &x){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
-SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector<int > *self,std::vector<int >::value_type const &x){
+SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
self->push_back(x);
}
return pchar_descriptor ?
SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
+#if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
+#else
return PyString_FromStringAndSize(carray, static_cast< int >(size));
+#endif
}
} else {
return SWIG_Py_Void();
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
- if (PyString_Check(obj)) {
+#if PY_VERSION_HEX>=0x03000000
+ if (PyUnicode_Check(obj))
+#else
+ if (PyString_Check(obj))
+#endif
+ {
char *cstr; Py_ssize_t len;
+#if PY_VERSION_HEX>=0x03000000
+ if (!alloc && cptr) {
+ /* We can't allow converting without allocation, since the internal
+ representation of string in Python 3 is UCS-2/UCS-4 but we require
+ a UTF-8 representation.
+ TODO(bhy) More detailed explanation */
+ return SWIG_RuntimeError;
+ }
+ obj = PyUnicode_AsUTF8String(obj);
+ PyBytes_AsStringAndSize(obj, &cstr, &len);
+ if(alloc) *alloc = SWIG_NEWOBJ;
+#else
PyString_AsStringAndSize(obj, &cstr, &len);
- if (cptr) {
+#endif
+ if (cptr) {
if (alloc) {
/*
In python the user should not be able to modify the inner
*alloc = SWIG_OLDOBJ;
}
} else {
- *cptr = PyString_AsString(obj);
+ #if PY_VERSION_HEX>=0x03000000
+ assert(0); /* Should never reach here in Python 3 */
+ #endif
+ *cptr = SWIG_Python_str_AsChar(obj);
}
}
if (psize) *psize = len + 1;
+#if PY_VERSION_HEX>=0x03000000
+ Py_XDECREF(obj);
+#endif
return SWIG_OK;
} else {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
- if (obj == Py_True) {
- if (val) *val = true;
- return SWIG_OK;
- } else if (obj == Py_False) {
- if (val) *val = false;
- return SWIG_OK;
- } else {
- long v = 0;
- int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
- if (SWIG_IsOK(res) && val) *val = v ? true : false;
- return res;
- }
+ int r = PyObject_IsTrue(obj);
+ if (r == -1)
+ return SWIG_ERROR;
+ if (val) *val = r ? true : false;
+ return SWIG_OK;
}
#ifdef __cplusplus
extern "C" {
#endif
-SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- PyObject *result = 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
- result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
+ result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
}
catch(swig::stop_iteration &_e) {
{
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
size_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
- result = (swig::PySwigIterator *)(arg1)->incr(arg2);
+ result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *result = 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
- result = (swig::PySwigIterator *)(arg1)->incr();
+ result = (swig::SwigPyIterator *)(arg1)->incr();
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_PySwigIterator_incr__SWIG_1(self, args);
+ return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_PySwigIterator_incr__SWIG_0(self, args);
+ return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
}
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n Possible C/C++ prototypes are:\n incr(size_t)\n incr()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_incr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " incr(swig::SwigPyIterator *,size_t)\n"
+ " incr(swig::SwigPyIterator *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
size_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
- result = (swig::PySwigIterator *)(arg1)->decr(arg2);
+ result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *result = 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
- result = (swig::PySwigIterator *)(arg1)->decr();
+ result = (swig::SwigPyIterator *)(arg1)->decr();
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_PySwigIterator_decr__SWIG_1(self, args);
+ return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_PySwigIterator_decr__SWIG_0(self, args);
+ return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
}
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n Possible C/C++ prototypes are:\n decr(size_t)\n decr()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_decr'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " decr(swig::SwigPyIterator *,size_t)\n"
+ " decr(swig::SwigPyIterator *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *arg2 = 0 ;
- ptrdiff_t result;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ ptrdiff_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
- arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
try {
- result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
+ result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
}
catch(std::invalid_argument &_e) {
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;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *arg2 = 0 ;
- bool result;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
- arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
try {
- result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
}
catch(std::invalid_argument &_e) {
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;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *result = 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- PyObject *result = 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
result = (PyObject *)(arg1)->next();
}
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
PyObject *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
+ }
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ try {
+ result = (PyObject *)(arg1)->__next__();
+ }
+ catch(swig::stop_iteration &_e) {
+ {
+ (void)_e;
+ SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+ SWIG_fail;
+ }
+ }
+
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
try {
result = (PyObject *)(arg1)->previous();
}
}
-SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
- result = (swig::PySwigIterator *)(arg1)->advance(arg2);
+ result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *arg2 = 0 ;
- bool result;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
- arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
- result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *arg2 = 0 ;
- bool result;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
- arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
- result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
- {
- swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
- result = (swig::PySwigIterator *) &_result_ref;
- }
+ result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
- {
- swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
- result = (swig::PySwigIterator *) &_result_ref;
- }
+ result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
- result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
ptrdiff_t arg2 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
- result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
+ result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
}
catch(swig::stop_iteration &_e) {
{
}
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
- swig::PySwigIterator *arg2 = 0 ;
- ptrdiff_t result;
+ swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
+ swig::SwigPyIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ ptrdiff_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
}
- arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
+ arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
}
- arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
- result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
+ arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
+ result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
- return _wrap_PySwigIterator___sub____SWIG_1(self, args);
+ return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = SWIG_CheckState(res);
}
if (_v) {
- return _wrap_PySwigIterator___sub____SWIG_0(self, args);
+ return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
}
}
}
}
-SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- bool result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector< Hex::Hexa * > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorHexas___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___bool__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector<Hex::Hexa * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____bool__((std::vector< Hex::Hexa * > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector<Hex::Hexa * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector< Hex::Hexa * > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::value_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
try {
- result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
+ result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
- std::vector<Hex::Hexa * >::difference_type arg3 ;
- std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *result = 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
+ std::vector< Hex::Hexa * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
try {
- result = (std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_OWN | 0 );
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
- std::vector<Hex::Hexa * >::difference_type arg3 ;
- std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *arg4 = 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
+ std::vector< Hex::Hexa * >::difference_type arg3 ;
+ std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
{
- std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
+ std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
}
if (!ptr) {
- 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 &""'");
+ 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 &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &)*arg4);
+ std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
- std::vector<Hex::Hexa * >::difference_type arg3 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
+ std::vector< Hex::Hexa * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
try {
std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
}
}
-SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
try {
- std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(arg1,arg2);
+ std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
- std::vector<Hex::Hexa * >::value_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
try {
- result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(arg1,arg2);
+ result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::difference_type arg2 ;
- std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
+ }
+ if (!ptr) {
+ 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 &""'");
+ }
+ arg3 = ptr;
}
- arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
try {
- std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(arg1,arg2,arg3);
+ std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
- std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
- result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = 0 ;
- std::vector<Hex::Hexa * > *result = 0 ;
- int res1 = SWIG_OLDOBJ ;
- PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
- {
- std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
- res1 = swig::asptr(obj0, &ptr);
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorHexas___delitem____SWIG_1(self, args);
+ }
}
- if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorHexas___delitem____SWIG_0(self, args);
+ }
}
- arg1 = ptr;
}
- result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >((std::vector<Hex::Hexa * > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
- if (SWIG_IsNewObj(res1)) delete arg1;
- return resultobj;
-fail:
- if (SWIG_IsNewObj(res1)) delete arg1;
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (bool)((std::vector<Hex::Hexa * > const *)arg1)->empty();
- resultobj = SWIG_From_bool(static_cast< bool >(result));
- return resultobj;
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type)\n"
+ " __delitem__(std::vector< Hex::Hexa * > *,PySliceObject *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< Hex::Hexa * >::value_type result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->size();
- resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
+ try {
+ result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- (arg1)->clear();
- resultobj = SWIG_Py_Void();
- return resultobj;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorHexas___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorHexas___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< Hex::Hexa * > *,PySliceObject *)\n"
+ " __getitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * > *arg2 = 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::difference_type arg2 ;
+ std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
+ arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
+ try {
+ std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
}
- arg2 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp2);
- (arg1)->swap(*arg2);
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
resultobj = SWIG_Py_Void();
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- SwigValueWrapper<std::allocator<Hex::Hexa * > > result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorHexas___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorHexas___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<Hex::Hexa * >::allocator_type(static_cast< const std::vector<Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
- return resultobj;
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< Hex::Hexa * > *,PySliceObject *,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n"
+ " __setitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::value_type)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
+ std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::const_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
+ result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >();
+ 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 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Hexa * > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * > *result = 0 ;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_begin__SWIG_0(self, args);
+ if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
+ {
+ std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
+ res1 = swig::asptr(obj0, &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
}
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_begin__SWIG_1(self, args);
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
}
+ arg1 = ptr;
}
-
+ result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >((std::vector< Hex::Hexa * > const &)*arg1);
+ 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 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (bool)((std::vector< Hex::Hexa * > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::const_iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::size_type result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_end__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_end__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ (arg1)->clear();
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::reverse_iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg2 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::const_reverse_iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< Hex::Hexa * > > result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< Hex::Hexa * >::allocator_type(static_cast< const std::vector< Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::const_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_rbegin__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::reverse_iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::const_reverse_iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::const_reverse_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::const_reverse_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorHexas_rend__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * >::size_type arg1 ;
- std::vector<Hex::Hexa * > *result = 0 ;
+ std::vector< Hex::Hexa * >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
- result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
+ result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1);
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type arg2 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator arg2 ;
- std::vector<Hex::Hexa * >::iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Hexa * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator arg2 ;
- std::vector<Hex::Hexa * >::iterator arg3 ;
- std::vector<Hex::Hexa * >::iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::iterator arg2 ;
+ std::vector< Hex::Hexa * >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Hexa * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorHexas_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorHexas_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Hexa * >::iterator)\n erase(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator)\n"
+ " erase(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * >::size_type arg1 ;
- std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
- std::vector<Hex::Hexa * > *result = 0 ;
+ std::vector< Hex::Hexa * >::size_type arg1 ;
+ std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Hexa * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
- result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
+ result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1,arg2);
+ 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 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorHexas__SWIG_1(self, args);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorHexas__SWIG_3(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorHexas'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Hexa)>()\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * > const &)\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type)\n std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorHexas'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< Hex::Hexa * >()\n"
+ " std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * > const &)\n"
+ " std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * >::size_type)\n"
+ " std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
(arg1)->push_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::value_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->front();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->front();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::value_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->back();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->back();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type arg2 ;
- std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::size_type arg2 ;
+ std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
(arg1)->assign(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type arg2 ;
- std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::size_type arg2 ;
+ std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
(arg1)->resize(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorHexas_resize__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Hexa * >::size_type)\n resize(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::size_type)\n"
+ " resize(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator arg2 ;
- std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
- std::vector<Hex::Hexa * >::iterator result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::iterator arg2 ;
+ std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Hexa * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
result = (arg1)->insert(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::iterator arg2 ;
- std::vector<Hex::Hexa * >::size_type arg3 ;
- std::vector<Hex::Hexa * >::value_type arg4 = (std::vector<Hex::Hexa * >::value_type) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::iterator arg2 ;
+ std::vector< Hex::Hexa * >::size_type arg3 ;
+ std::vector< Hex::Hexa * >::value_type arg4 = (std::vector< Hex::Hexa * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg3 = static_cast< std::vector<Hex::Hexa * >::size_type >(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 | 0 );
+ arg3 = static_cast< std::vector< Hex::Hexa * >::size_type >(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
}
- arg4 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp4);
+ arg4 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp4);
(arg1)->insert(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorHexas_insert__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorHexas_insert__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::value_type)\n insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::value_type)\n"
+ " insert(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type arg2 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
- std::vector<Hex::Hexa * >::size_type result;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Hexa * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
- result = ((std::vector<Hex::Hexa * > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
+ result = ((std::vector< Hex::Hexa * > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
+ std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- bool result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector< Hex::Quad * > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___bool__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector<Hex::Quad * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____bool__((std::vector< Hex::Quad * > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector<Hex::Quad * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector< Hex::Quad * > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::value_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
try {
- result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
+ result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
- std::vector<Hex::Quad * >::difference_type arg3 ;
- std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *result = 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
+ std::vector< Hex::Quad * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
try {
- result = (std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_OWN | 0 );
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
- std::vector<Hex::Quad * >::difference_type arg3 ;
- std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *arg4 = 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
+ std::vector< Hex::Quad * >::difference_type arg3 ;
+ std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
}
if (!ptr) {
- 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 &""'");
+ 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 &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &)*arg4);
+ std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
- std::vector<Hex::Quad * >::difference_type arg3 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
+ std::vector< Hex::Quad * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
try {
std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
}
}
-SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
try {
- std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(arg1,arg2);
+ std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
- std::vector<Hex::Quad * >::value_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
try {
- result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(arg1,arg2);
+ result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::difference_type arg2 ;
- std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
+ }
+ if (!ptr) {
+ 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 &""'");
+ }
+ arg3 = ptr;
}
- arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
try {
- std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(arg1,arg2,arg3);
+ std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
- std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
+ try {
+ std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
resultobj = SWIG_Py_Void();
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *result = 0 ;
+SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
- result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = 0 ;
- std::vector<Hex::Quad * > *result = 0 ;
- int res1 = SWIG_OLDOBJ ;
- PyObject * obj0 = 0 ;
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorQuads___delitem____SWIG_1(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorQuads___delitem____SWIG_0(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type)\n"
+ " __delitem__(std::vector< Hex::Quad * > *,PySliceObject *)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< Hex::Quad * >::value_type result;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
+ try {
+ result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorQuads___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorQuads___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< Hex::Quad * > *,PySliceObject *)\n"
+ " __getitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::difference_type arg2 ;
+ std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
+ }
+ arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
+ try {
+ std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorQuads___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorQuads___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< Hex::Quad * > *,PySliceObject *,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n"
+ " __setitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::value_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
+ }
+ arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
+ std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
+ result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >();
+ 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 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
}
arg1 = ptr;
}
- result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >((std::vector<Hex::Quad * > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >((std::vector< Hex::Quad * > const &)*arg1);
+ 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 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- bool result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (bool)((std::vector<Hex::Quad * > const *)arg1)->empty();
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (bool)((std::vector< Hex::Quad * > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->size();
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * > *arg2 = 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- SwigValueWrapper<std::allocator<Hex::Quad * > > result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< Hex::Quad * > > result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<Hex::Quad * >::allocator_type(static_cast< const std::vector<Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< Hex::Quad * >::allocator_type(static_cast< const std::vector< Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::const_iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::const_reverse_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_begin__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::const_reverse_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Quad * >::size_type arg1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
+ ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
+ }
+ arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
+ result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1);
+ 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 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::const_iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_end__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_end__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::const_reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_rbegin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::const_reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorQuads_rend__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * >::size_type arg1 ;
- std::vector<Hex::Quad * > *result = 0 ;
- size_t val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_size_t(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
- }
- arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
- result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- (arg1)->pop_back();
- resultobj = SWIG_Py_Void();
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ (arg1)->pop_back();
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type arg2 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator arg2 ;
- std::vector<Hex::Quad * >::iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Quad * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator arg2 ;
- std::vector<Hex::Quad * >::iterator arg3 ;
- std::vector<Hex::Quad * >::iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::iterator arg2 ;
+ std::vector< Hex::Quad * >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Quad * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorQuads_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorQuads_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Quad * >::iterator)\n erase(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator)\n"
+ " erase(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * >::size_type arg1 ;
- std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
- std::vector<Hex::Quad * > *result = 0 ;
+ std::vector< Hex::Quad * >::size_type arg1 ;
+ std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Quad * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
- result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
+ result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1,arg2);
+ 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 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorQuads__SWIG_1(self, args);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorQuads__SWIG_3(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorQuads'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Quad)>()\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * > const &)\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type)\n std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorQuads'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< Hex::Quad * >()\n"
+ " std::vector< Hex::Quad * >(std::vector< Hex::Quad * > const &)\n"
+ " std::vector< Hex::Quad * >(std::vector< Hex::Quad * >::size_type)\n"
+ " std::vector< Hex::Quad * >(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
(arg1)->push_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::value_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->front();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->front();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::value_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->back();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->back();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type arg2 ;
- std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::size_type arg2 ;
+ std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
(arg1)->assign(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type arg2 ;
- std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::size_type arg2 ;
+ std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
(arg1)->resize(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorQuads_resize__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Quad * >::size_type)\n resize(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::size_type)\n"
+ " resize(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator arg2 ;
- std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
- std::vector<Hex::Quad * >::iterator result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::iterator arg2 ;
+ std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Quad * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
result = (arg1)->insert(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::iterator arg2 ;
- std::vector<Hex::Quad * >::size_type arg3 ;
- std::vector<Hex::Quad * >::value_type arg4 = (std::vector<Hex::Quad * >::value_type) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::iterator arg2 ;
+ std::vector< Hex::Quad * >::size_type arg3 ;
+ std::vector< Hex::Quad * >::value_type arg4 = (std::vector< Hex::Quad * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg3 = static_cast< std::vector<Hex::Quad * >::size_type >(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 | 0 );
+ arg3 = static_cast< std::vector< Hex::Quad * >::size_type >(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector<Hex::Quad * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector< Hex::Quad * >::value_type""'");
}
- arg4 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp4);
+ arg4 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp4);
(arg1)->insert(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorQuads_insert__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorQuads_insert__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::value_type)\n insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::value_type)\n"
+ " insert(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type arg2 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
- std::vector<Hex::Quad * >::size_type result;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Quad * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
- result = ((std::vector<Hex::Quad * > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
+ result = ((std::vector< Hex::Quad * > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
+ std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- bool result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector< Hex::Edge * > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorEdges___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___bool__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector<Hex::Edge * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____bool__((std::vector< Hex::Edge * > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector<Hex::Edge * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector< Hex::Edge * > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::value_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
try {
- result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
+ result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
- std::vector<Hex::Edge * >::difference_type arg3 ;
- std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *result = 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
+ std::vector< Hex::Edge * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
try {
- result = (std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_OWN | 0 );
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
- std::vector<Hex::Edge * >::difference_type arg3 ;
- std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *arg4 = 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
+ std::vector< Hex::Edge * >::difference_type arg3 ;
+ std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
{
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
}
if (!ptr) {
- 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 &""'");
+ 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 &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &)*arg4);
+ std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
- std::vector<Hex::Edge * >::difference_type arg3 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
+ std::vector< Hex::Edge * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
try {
std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
}
}
-SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
try {
- std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(arg1,arg2);
+ std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
- std::vector<Hex::Edge * >::value_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
try {
- result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(arg1,arg2);
+ result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::difference_type arg2 ;
- std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
+ }
+ if (!ptr) {
+ 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 &""'");
+ }
+ arg3 = ptr;
}
- arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
try {
- std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(arg1,arg2,arg3);
+ std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
- std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
- result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = 0 ;
- std::vector<Hex::Edge * > *result = 0 ;
- int res1 = SWIG_OLDOBJ ;
- PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
- {
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
- res1 = swig::asptr(obj0, &ptr);
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorEdges___delitem____SWIG_1(self, args);
+ }
}
- if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorEdges___delitem____SWIG_0(self, args);
+ }
}
- arg1 = ptr;
}
- result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >((std::vector<Hex::Edge * > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
- if (SWIG_IsNewObj(res1)) delete arg1;
- return resultobj;
+
fail:
- if (SWIG_IsNewObj(res1)) delete arg1;
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type)\n"
+ " __delitem__(std::vector< Hex::Edge * > *,PySliceObject *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- bool result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< Hex::Edge * >::value_type result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (bool)((std::vector<Hex::Edge * > const *)arg1)->empty();
- resultobj = SWIG_From_bool(static_cast< bool >(result));
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
+ try {
+ result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->size();
- resultobj = SWIG_From_size_t(static_cast< size_t >(result));
- return resultobj;
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorEdges___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorEdges___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< Hex::Edge * > *,PySliceObject *)\n"
+ " __getitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::difference_type arg2 ;
+ std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- (arg1)->clear();
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
+ }
+ arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
+ try {
+ std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
resultobj = SWIG_Py_Void();
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorEdges___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorEdges___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< Hex::Edge * > *,PySliceObject *,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n"
+ " __setitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::value_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * > *arg2 = 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp2);
- (arg1)->swap(*arg2);
+ arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
+ std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- SwigValueWrapper<std::allocator<Hex::Edge * > > result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<Hex::Edge * >::allocator_type(static_cast< const std::vector<Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
+ if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
+ result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >();
+ 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 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
+ std::vector< Hex::Edge * > *arg1 = 0 ;
+ int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
+ {
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
+ res1 = swig::asptr(obj0, &ptr);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
+ }
+ arg1 = ptr;
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >((std::vector< Hex::Edge * > const &)*arg1);
+ 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 );
+ if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::const_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_begin__SWIG_1(self, args);
- }
- }
-
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (bool)((std::vector< Hex::Edge * > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::size_type result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::const_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ (arg1)->clear();
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_end__SWIG_0(self, args);
- }
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
}
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_end__SWIG_1(self, args);
- }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
}
-
+ arg2 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::reverse_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< Hex::Edge * > > result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< Hex::Edge * >::allocator_type(static_cast< const std::vector< Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::const_reverse_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::const_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_rbegin__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::reverse_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::const_reverse_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::const_reverse_iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorEdges_rend__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * >::size_type arg1 ;
- std::vector<Hex::Edge * > *result = 0 ;
+ std::vector< Hex::Edge * >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
- result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
+ result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1);
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type arg2 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator arg2 ;
- std::vector<Hex::Edge * >::iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Edge * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator arg2 ;
- std::vector<Hex::Edge * >::iterator arg3 ;
- std::vector<Hex::Edge * >::iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::iterator arg2 ;
+ std::vector< Hex::Edge * >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Edge * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorEdges_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorEdges_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Edge * >::iterator)\n erase(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator)\n"
+ " erase(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * >::size_type arg1 ;
- std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
- std::vector<Hex::Edge * > *result = 0 ;
+ std::vector< Hex::Edge * >::size_type arg1 ;
+ std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Edge * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
- result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
+ result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1,arg2);
+ 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 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorEdges__SWIG_1(self, args);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorEdges__SWIG_3(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorEdges'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Edge)>()\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * > const &)\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type)\n std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorEdges'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< Hex::Edge * >()\n"
+ " std::vector< Hex::Edge * >(std::vector< Hex::Edge * > const &)\n"
+ " std::vector< Hex::Edge * >(std::vector< Hex::Edge * >::size_type)\n"
+ " std::vector< Hex::Edge * >(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
(arg1)->push_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::value_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->front();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->front();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::value_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->back();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->back();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type arg2 ;
- std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::size_type arg2 ;
+ std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
(arg1)->assign(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type arg2 ;
- std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::size_type arg2 ;
+ std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
(arg1)->resize(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorEdges_resize__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Edge * >::size_type)\n resize(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::size_type)\n"
+ " resize(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator arg2 ;
- std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
- std::vector<Hex::Edge * >::iterator result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::iterator arg2 ;
+ std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Edge * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
result = (arg1)->insert(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::iterator arg2 ;
- std::vector<Hex::Edge * >::size_type arg3 ;
- std::vector<Hex::Edge * >::value_type arg4 = (std::vector<Hex::Edge * >::value_type) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::iterator arg2 ;
+ std::vector< Hex::Edge * >::size_type arg3 ;
+ std::vector< Hex::Edge * >::value_type arg4 = (std::vector< Hex::Edge * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg3 = static_cast< std::vector<Hex::Edge * >::size_type >(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 | 0 );
+ arg3 = static_cast< std::vector< Hex::Edge * >::size_type >(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector<Hex::Edge * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector< Hex::Edge * >::value_type""'");
}
- arg4 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp4);
+ arg4 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp4);
(arg1)->insert(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorEdges_insert__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorEdges_insert__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::value_type)\n insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::value_type)\n"
+ " insert(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type arg2 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
- std::vector<Hex::Edge * >::size_type result;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Edge * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
- result = ((std::vector<Hex::Edge * > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
+ result = ((std::vector< Hex::Edge * > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
+ std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- bool result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector< Hex::Vertex * > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___bool__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector<Hex::Vertex * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____bool__((std::vector< Hex::Vertex * > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector<Hex::Vertex * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector< Hex::Vertex * > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::value_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
try {
- result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
+ result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
- std::vector<Hex::Vertex * >::difference_type arg3 ;
- std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *result = 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
+ std::vector< Hex::Vertex * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
try {
- result = (std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_OWN | 0 );
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
- std::vector<Hex::Vertex * >::difference_type arg3 ;
- std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *arg4 = 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
+ std::vector< Hex::Vertex * >::difference_type arg3 ;
+ std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
{
- std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
+ std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
}
if (!ptr) {
- 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 &""'");
+ 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 &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &)*arg4);
+ std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
- std::vector<Hex::Vertex * >::difference_type arg3 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
+ std::vector< Hex::Vertex * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
try {
std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
}
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_Py_Void();
- return resultobj;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
+ try {
+ std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
+ }
+ if (!ptr) {
+ 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 &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorVertices___delitem____SWIG_1(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorVertices___delitem____SWIG_0(self, args);
+ }
+ }
+ }
+
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type)\n"
+ " __delitem__(std::vector< Hex::Vertex * > *,PySliceObject *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Vertex * >::value_type result;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
try {
- std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(arg1,arg2);
+ result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_Py_Void();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
- std::vector<Hex::Vertex * >::value_type result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
- }
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
- try {
- result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(arg1,arg2);
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorVertices___getitem____SWIG_0(self, args);
+ }
+ }
}
- catch(std::out_of_range &_e) {
- SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorVertices___getitem____SWIG_1(self, args);
+ }
+ }
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
- return resultobj;
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< Hex::Vertex * > *,PySliceObject *)\n"
+ " __getitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::difference_type arg2 ;
- std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::difference_type arg2 ;
+ std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
try {
- std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(arg1,arg2,arg3);
+ std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorVertices___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorVertices___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< Hex::Vertex * > *,PySliceObject *,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n"
+ " __setitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::value_type)\n");
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *result = 0 ;
+ std::vector< Hex::Vertex * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
- result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >();
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = 0 ;
- std::vector<Hex::Vertex * > *result = 0 ;
+ std::vector< Hex::Vertex * > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
{
- std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
+ std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
}
arg1 = ptr;
}
- result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >((std::vector<Hex::Vertex * > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >((std::vector< Hex::Vertex * > const &)*arg1);
+ 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 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- bool result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (bool)((std::vector<Hex::Vertex * > const *)arg1)->empty();
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (bool)((std::vector< Hex::Vertex * > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->size();
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * > *arg2 = 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- SwigValueWrapper<std::allocator<Hex::Vertex * > > result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< Hex::Vertex * > > result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<Hex::Vertex * >::allocator_type(static_cast< const std::vector<Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::const_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_begin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::const_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_end__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_end__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::const_reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_rbegin__SWIG_1(self, args);
- }
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< Hex::Vertex * >::allocator_type(static_cast< const std::vector< Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::reverse_iterator result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::const_reverse_iterator result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::const_reverse_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorVertices_rend__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::const_reverse_iterator result;
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * >::size_type arg1 ;
- std::vector<Hex::Vertex * > *result = 0 ;
+ std::vector< Hex::Vertex * >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
- result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
+ result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1);
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type arg2 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator arg2 ;
- std::vector<Hex::Vertex * >::iterator result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Vertex * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator arg2 ;
- std::vector<Hex::Vertex * >::iterator arg3 ;
- std::vector<Hex::Vertex * >::iterator result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::iterator arg2 ;
+ std::vector< Hex::Vertex * >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Vertex * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorVertices_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorVertices_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::Vertex * >::iterator)\n erase(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator)\n"
+ " erase(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * >::size_type arg1 ;
- std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
- std::vector<Hex::Vertex * > *result = 0 ;
+ std::vector< Hex::Vertex * >::size_type arg1 ;
+ std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::Vertex * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
- result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
+ result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1,arg2);
+ 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 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorVertices__SWIG_1(self, args);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorVertices__SWIG_3(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorVertices'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::Vertex)>()\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * > const &)\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type)\n std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorVertices'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< Hex::Vertex * >()\n"
+ " std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * > const &)\n"
+ " std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * >::size_type)\n"
+ " std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
(arg1)->push_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::value_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->front();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->front();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::value_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->back();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->back();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type arg2 ;
- std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::size_type arg2 ;
+ std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
(arg1)->assign(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type arg2 ;
- std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::size_type arg2 ;
+ std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
(arg1)->resize(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorVertices_resize__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::Vertex * >::size_type)\n resize(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::size_type)\n"
+ " resize(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator arg2 ;
- std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
- std::vector<Hex::Vertex * >::iterator result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::iterator arg2 ;
+ std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::Vertex * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
result = (arg1)->insert(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::iterator arg2 ;
- std::vector<Hex::Vertex * >::size_type arg3 ;
- std::vector<Hex::Vertex * >::value_type arg4 = (std::vector<Hex::Vertex * >::value_type) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::iterator arg2 ;
+ std::vector< Hex::Vertex * >::size_type arg3 ;
+ std::vector< Hex::Vertex * >::value_type arg4 = (std::vector< Hex::Vertex * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg3 = static_cast< std::vector<Hex::Vertex * >::size_type >(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 | 0 );
+ arg3 = static_cast< std::vector< Hex::Vertex * >::size_type >(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
}
- arg4 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp4);
+ arg4 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp4);
(arg1)->insert(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorVertices_insert__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorVertices_insert__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::value_type)\n insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::value_type)\n"
+ " insert(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type arg2 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
- std::vector<Hex::Vertex * >::size_type result;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::Vertex * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
- result = ((std::vector<Hex::Vertex * > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
+ result = ((std::vector< Hex::Vertex * > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
+ std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- bool result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector< Hex::NewShape * > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___bool__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector<Hex::NewShape * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____bool__((std::vector< Hex::NewShape * > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector<Hex::NewShape * > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector< Hex::NewShape * > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::value_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
try {
- result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
+ result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
- std::vector<Hex::NewShape * >::difference_type arg3 ;
- std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *result = 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
+ std::vector< Hex::NewShape * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
try {
- result = (std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_OWN | 0 );
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
- std::vector<Hex::NewShape * >::difference_type arg3 ;
- std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *arg4 = 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
+ std::vector< Hex::NewShape * >::difference_type arg3 ;
+ std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
{
- std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
}
if (!ptr) {
- 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 &""'");
+ 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 &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &)*arg4);
+ std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
- std::vector<Hex::NewShape * >::difference_type arg3 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
+ std::vector< Hex::NewShape * >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
+ arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
try {
std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
}
}
-SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
+ try {
+ std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
+ }
+ if (!ptr) {
+ 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 &""'");
+ }
+ arg3 = ptr;
+ }
+ try {
+ std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
try {
- std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(arg1,arg2);
+ std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorShapes___delitem____SWIG_1(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorShapes___delitem____SWIG_0(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type)\n"
+ " __delitem__(std::vector< Hex::NewShape * > *,PySliceObject *)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
- std::vector<Hex::NewShape * >::value_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::NewShape * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
try {
- result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(arg1,arg2);
+ result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorShapes___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorShapes___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< Hex::NewShape * > *,PySliceObject *)\n"
+ " __getitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::difference_type arg2 ;
- std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::difference_type arg2 ;
+ std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
try {
- std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(arg1,arg2,arg3);
+ std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_Py_Void();
- return resultobj;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorShapes___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorShapes___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< Hex::NewShape * > *,PySliceObject *,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n"
+ " __setitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *result = 0 ;
+ std::vector< Hex::NewShape * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
- result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >();
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = 0 ;
- std::vector<Hex::NewShape * > *result = 0 ;
+ std::vector< Hex::NewShape * > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
{
- std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
}
arg1 = ptr;
}
- result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >((std::vector<Hex::NewShape * > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >((std::vector< Hex::NewShape * > const &)*arg1);
+ 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 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- bool result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (bool)((std::vector<Hex::NewShape * > const *)arg1)->empty();
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (bool)((std::vector< Hex::NewShape * > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->size();
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * > *arg2 = 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- SwigValueWrapper<std::allocator<Hex::NewShape * > > result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< Hex::NewShape * > > result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<Hex::NewShape * >::allocator_type(static_cast< const std::vector<Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< Hex::NewShape * >::allocator_type(static_cast< const std::vector< Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::const_iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_begin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::const_iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_end__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_end__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::const_reverse_iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_rbegin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::reverse_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::const_reverse_iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorShapes_rend__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * >::size_type arg1 ;
- std::vector<Hex::NewShape * > *result = 0 ;
+ std::vector< Hex::NewShape * >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
- result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
+ result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1);
+ 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 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type arg2 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator arg2 ;
- std::vector<Hex::NewShape * >::iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::NewShape * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator arg2 ;
- std::vector<Hex::NewShape * >::iterator arg3 ;
- std::vector<Hex::NewShape * >::iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::iterator arg2 ;
+ std::vector< Hex::NewShape * >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::NewShape * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorShapes_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorShapes_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<Hex::NewShape * >::iterator)\n erase(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator)\n"
+ " erase(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * >::size_type arg1 ;
- std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
- std::vector<Hex::NewShape * > *result = 0 ;
+ std::vector< Hex::NewShape * >::size_type arg1 ;
+ std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< Hex::NewShape * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
- result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW | 0 );
+ arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
+ result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1,arg2);
+ 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 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorShapes__SWIG_1(self, args);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorShapes__SWIG_3(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorShapes'.\n Possible C/C++ prototypes are:\n std::vector<(p.Hex::NewShape)>()\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * > const &)\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type)\n std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorShapes'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< Hex::NewShape * >()\n"
+ " std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * > const &)\n"
+ " std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * >::size_type)\n"
+ " std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
+ arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
(arg1)->push_back(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::value_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->front();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->front();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::value_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->back();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->back();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type arg2 ;
- std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::size_type arg2 ;
+ std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
(arg1)->assign(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type arg2 ;
- std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::size_type arg2 ;
+ std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
(arg1)->resize(arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorShapes_resize__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<Hex::NewShape * >::size_type)\n resize(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::size_type)\n"
+ " resize(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator arg2 ;
- std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
- std::vector<Hex::NewShape * >::iterator result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::iterator arg2 ;
+ std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< Hex::NewShape * >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
+ arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
result = (arg1)->insert(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::iterator arg2 ;
- std::vector<Hex::NewShape * >::size_type arg3 ;
- std::vector<Hex::NewShape * >::value_type arg4 = (std::vector<Hex::NewShape * >::value_type) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::iterator arg2 ;
+ std::vector< Hex::NewShape * >::size_type arg3 ;
+ std::vector< Hex::NewShape * >::value_type arg4 = (std::vector< Hex::NewShape * >::value_type) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg3 = static_cast< std::vector<Hex::NewShape * >::size_type >(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 | 0 );
+ arg3 = static_cast< std::vector< Hex::NewShape * >::size_type >(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
}
- arg4 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp4);
+ arg4 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp4);
(arg1)->insert(arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorShapes_insert__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
if (_v) {
void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_VectorShapes_insert__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::value_type)\n insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::value_type)\n"
+ " insert(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type arg2 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
}
- arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
+ arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
- std::vector<Hex::NewShape * >::size_type result;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< Hex::NewShape * >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
- result = ((std::vector<Hex::NewShape * > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
+ result = ((std::vector< Hex::NewShape * > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
+ std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
}
- arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- bool result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector<double > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = std_vector_Sl_double_Sg____len__((std::vector<double > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::value_type result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
try {
- result = (std::vector<double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
+ result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
- std::vector<double >::difference_type arg3 ;
- std::vector<double,std::allocator<double > > *result = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
+ std::vector< double >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< double,std::allocator< double > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
- arg3 = static_cast< std::vector<double >::difference_type >(val3);
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
try {
- result = (std::vector<double,std::allocator<double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
- std::vector<double >::difference_type arg3 ;
- std::vector<double,std::allocator<double > > *arg4 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
+ std::vector< double >::difference_type arg3 ;
+ std::vector< double,std::allocator< double > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
}
- arg3 = static_cast< std::vector<double >::difference_type >(val3);
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg4 = ptr;
}
try {
- std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector<double,std::allocator<double > > const &)*arg4);
+ std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
- std::vector<double >::difference_type arg3 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
+ std::vector< double >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
+ }
+ arg3 = static_cast< std::vector< double >::difference_type >(val3);
+ try {
+ std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg3 = static_cast< std::vector<double >::difference_type >(val3);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
+ try {
+ std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ std::vector< double,std::allocator< double > > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ try {
+ result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< double,std::allocator< double > > *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res3 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ }
+ arg3 = ptr;
+ }
try {
- std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
+ std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
fail:
+ if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
- }
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
try {
- std_vector_Sl_double_Sg____delitem__(arg1,arg2);
+ std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorReal___delitem____SWIG_1(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorReal___delitem____SWIG_0(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< double > *,std::vector< double >::difference_type)\n"
+ " __delitem__(std::vector< double > *,PySliceObject *)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
- std::vector<double >::value_type *result = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
try {
- {
- std::vector<double >::value_type const &_result_ref = std_vector_Sl_double_Sg____getitem__((std::vector<double > const *)arg1,arg2);
- result = (std::vector<double >::value_type *) &_result_ref;
- }
+ result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorReal___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorReal___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< double > *,PySliceObject *)\n"
+ " __getitem__(std::vector< double > const *,std::vector< double >::difference_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::difference_type arg2 ;
- std::vector<double >::value_type *arg3 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::difference_type arg2 ;
+ std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
- std::vector<double >::value_type temp3 ;
+ std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
}
- arg2 = static_cast< std::vector<double >::difference_type >(val2);
+ arg2 = static_cast< std::vector< double >::difference_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
- temp3 = static_cast< std::vector<double >::value_type >(val3);
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
try {
- std_vector_Sl_double_Sg____setitem__(arg1,arg2,(double const &)*arg3);
+ std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2,(double const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorReal___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorReal___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< double > *,PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
+ " __setitem__(std::vector< double > *,std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::value_type *arg2 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- std::vector<double >::value_type temp2 ;
+ std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
- temp2 = static_cast< std::vector<double >::value_type >(val2);
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
resultobj = SWIG_Py_Void();
SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *result = 0 ;
+ std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
- result = (std::vector<double > *)new std::vector<double >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< double > *)new std::vector< double >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = 0 ;
- std::vector<double > *result = 0 ;
+ std::vector< double > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
+ std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
}
arg1 = ptr;
}
- result = (std::vector<double > *)new std::vector<double >((std::vector<double > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- bool result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (bool)((std::vector<double > const *)arg1)->empty();
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (bool)((std::vector< double > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector<double > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->size();
- resultobj = SWIG_From_size_t(static_cast< size_t >(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector<double > *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- (arg1)->clear();
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double > *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector<double > *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
- }
- arg2 = reinterpret_cast< std::vector<double > * >(argp2);
- (arg1)->swap(*arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- SwigValueWrapper<std::allocator<double > > result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector<double > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<double >::allocator_type(static_cast< const std::vector<double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::const_iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_begin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::const_iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ (arg1)->clear();
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double > *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_end__SWIG_0(self, args);
- }
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
}
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_end__SWIG_1(self, args);
- }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
}
-
+ arg2 = reinterpret_cast< std::vector< double > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::reverse_iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< double > > result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::const_reverse_iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
+SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ std::vector< double >::const_iterator result;
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_rbegin__SWIG_1(self, args);
- }
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
-
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
+ return resultobj;
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::reverse_iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::const_reverse_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::const_reverse_iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorReal_rend__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double >::size_type arg1 ;
- std::vector<double > *result = 0 ;
+ std::vector< double >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
}
- arg1 = static_cast< std::vector<double >::size_type >(val1);
- result = (std::vector<double > *)new std::vector<double >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
+ result = (std::vector< double > *)new std::vector< double >(arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorReal_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type arg2 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
- arg2 = static_cast< std::vector<double >::size_type >(val2);
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator arg2 ;
- std::vector<double >::iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator arg2 ;
- std::vector<double >::iterator arg3 ;
- std::vector<double >::iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::iterator arg2 ;
+ std::vector< double >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorReal_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorReal_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<double >::iterator)\n erase(std::vector<double >::iterator,std::vector<double >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< double > *,std::vector< double >::iterator)\n"
+ " erase(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double >::size_type arg1 ;
- std::vector<double >::value_type *arg2 = 0 ;
- std::vector<double > *result = 0 ;
+ std::vector< double >::size_type arg1 ;
+ std::vector< double >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
- std::vector<double >::value_type temp2 ;
+ std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< double > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
}
- arg1 = static_cast< std::vector<double >::size_type >(val1);
+ arg1 = static_cast< std::vector< double >::size_type >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
- temp2 = static_cast< std::vector<double >::value_type >(val2);
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
- result = (std::vector<double > *)new std::vector<double >(arg1,(std::vector<double >::value_type const &)*arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorReal__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorReal'.\n Possible C/C++ prototypes are:\n std::vector<(double)>()\n std::vector<(double)>(std::vector<double > const &)\n std::vector<(double)>(std::vector<double >::size_type)\n std::vector<(double)>(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorReal'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< double >()\n"
+ " std::vector< double >(std::vector< double > const &)\n"
+ " std::vector< double >(std::vector< double >::size_type)\n"
+ " std::vector< double >(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::value_type *arg2 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- std::vector<double >::value_type temp2 ;
+ std::vector< double >::value_type temp2 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
}
- temp2 = static_cast< std::vector<double >::value_type >(val2);
+ temp2 = static_cast< std::vector< double >::value_type >(val2);
arg2 = &temp2;
- (arg1)->push_back((std::vector<double >::value_type const &)*arg2);
+ (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::value_type *result = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector<double > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- {
- std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->front();
- result = (std::vector<double >::value_type *) &_result_ref;
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::value_type *result = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector<double > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- {
- std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->back();
- result = (std::vector<double >::value_type *) &_result_ref;
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
resultobj = SWIG_From_double(static_cast< double >(*result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type arg2 ;
- std::vector<double >::value_type *arg3 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::size_type arg2 ;
+ std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
- std::vector<double >::value_type temp3 ;
+ std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
- arg2 = static_cast< std::vector<double >::size_type >(val2);
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
- temp3 = static_cast< std::vector<double >::value_type >(val3);
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
- (arg1)->assign(arg2,(std::vector<double >::value_type const &)*arg3);
+ (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type arg2 ;
- std::vector<double >::value_type *arg3 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::size_type arg2 ;
+ std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
- std::vector<double >::value_type temp3 ;
+ std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
- arg2 = static_cast< std::vector<double >::size_type >(val2);
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
- temp3 = static_cast< std::vector<double >::value_type >(val3);
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
- (arg1)->resize(arg2,(std::vector<double >::value_type const &)*arg3);
+ (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<double >::size_type)\n resize(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< double > *,std::vector< double >::size_type)\n"
+ " resize(std::vector< double > *,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator arg2 ;
- std::vector<double >::value_type *arg3 = 0 ;
- std::vector<double >::iterator result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::iterator arg2 ;
+ std::vector< double >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- std::vector<double >::value_type temp3 ;
+ std::vector< double >::value_type temp3 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< double >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
}
- temp3 = static_cast< std::vector<double >::value_type >(val3);
+ temp3 = static_cast< std::vector< double >::value_type >(val3);
arg3 = &temp3;
- result = (arg1)->insert(arg2,(std::vector<double >::value_type const &)*arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ result = (arg1)->insert(arg2,(std::vector< double >::value_type const &)*arg3);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::iterator arg2 ;
- std::vector<double >::size_type arg3 ;
- std::vector<double >::value_type *arg4 = 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::iterator arg2 ;
+ std::vector< double >::size_type arg3 ;
+ std::vector< double >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
- std::vector<double >::value_type temp4 ;
+ std::vector< double >::value_type temp4 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
}
- arg3 = static_cast< std::vector<double >::size_type >(val3);
+ arg3 = static_cast< std::vector< double >::size_type >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector<double >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
}
- temp4 = static_cast< std::vector<double >::value_type >(val4);
+ temp4 = static_cast< std::vector< double >::value_type >(val4);
arg4 = &temp4;
- (arg1)->insert(arg2,arg3,(std::vector<double >::value_type const &)*arg4);
+ (arg1)->insert(arg2,arg3,(std::vector< double >::value_type const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<double >::iterator,std::vector<double >::value_type const &)\n insert(std::vector<double >::iterator,std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
+ " insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type arg2 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+ std::vector< double >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
}
- arg2 = static_cast< std::vector<double >::size_type >(val2);
+ arg2 = static_cast< std::vector< double >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
- std::vector<double >::size_type result;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< double >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector<double > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
- result = ((std::vector<double > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+ result = ((std::vector< double > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<double > *arg1 = (std::vector<double > *) 0 ;
+ std::vector< double > *arg1 = (std::vector< double > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector<double > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector< double > *""'");
}
- arg1 = reinterpret_cast< std::vector<double > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< double > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
- swig::PySwigIterator *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ swig::SwigPyIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- bool result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ bool result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector<int > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = std_vector_Sl_int_Sg____len__((std::vector<int > const *)arg1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::value_type result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
try {
- result = (std::vector<int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+ result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
+ std::vector< int >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ std::vector< int,std::allocator< int > > *result = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
+ try {
+ result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
+ std::vector< int >::difference_type arg3 ;
+ std::vector< int,std::allocator< int > > *arg4 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ int res4 = SWIG_OLDOBJ ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ PyObject * obj3 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
+ {
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
+ res4 = swig::asptr(obj3, &ptr);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
+ }
+ arg4 = ptr;
+ }
+ try {
+ std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+ catch(std::invalid_argument &_e) {
+ SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res4)) delete arg4;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
+ std::vector< int >::difference_type arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ ptrdiff_t val3 ;
+ int ecode3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
+ ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg3 = static_cast< std::vector< int >::difference_type >(val3);
+ try {
+ std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ ptrdiff_t val2 ;
+ int ecode2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
+ }
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
+ try {
+ std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
+ }
+ catch(std::out_of_range &_e) {
+ SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ }
+
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- std::vector<int >::difference_type arg3 ;
- std::vector<int,std::allocator<int > > *result = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- ptrdiff_t val3 ;
- int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ std::vector< int,std::allocator< int > > *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
- }
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
- ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
- }
- arg3 = static_cast< std::vector<int >::difference_type >(val3);
try {
- result = (std::vector<int,std::allocator<int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
+ result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_OWN | 0 );
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- std::vector<int >::difference_type arg3 ;
- std::vector<int,std::allocator<int > > *arg4 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
+ std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- ptrdiff_t val3 ;
- int ecode3 = 0 ;
- int res4 = SWIG_OLDOBJ ;
+ int res3 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
- }
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
- ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
- }
- arg3 = static_cast< std::vector<int >::difference_type >(val3);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
- std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
- res4 = swig::asptr(obj3, &ptr);
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
+ arg2 = (PySliceObject *) obj1;
+ }
+ {
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
+ res3 = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
}
- arg4 = ptr;
+ arg3 = ptr;
}
try {
- std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector<int,std::allocator<int > > const &)*arg4);
+ std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
- if (SWIG_IsNewObj(res4)) delete arg4;
+ if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
fail:
- if (SWIG_IsNewObj(res4)) delete arg4;
+ if (SWIG_IsNewObj(res3)) delete arg3;
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- std::vector<int >::difference_type arg3 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- ptrdiff_t val3 ;
- int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ {
+ arg2 = (PySliceObject *) obj1;
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
- }
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
- ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
- }
- arg3 = static_cast< std::vector<int >::difference_type >(val3);
try {
- std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
+ std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- ptrdiff_t val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
- }
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
- try {
- std_vector_Sl_int_Sg____delitem__(arg1,arg2);
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorInt___delitem____SWIG_1(self, args);
+ }
+ }
}
- catch(std::out_of_range &_e) {
- SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorInt___delitem____SWIG_0(self, args);
+ }
+ }
}
- resultobj = SWIG_Py_Void();
- return resultobj;
fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___delitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __delitem__(std::vector< int > *,std::vector< int >::difference_type)\n"
+ " __delitem__(std::vector< int > *,PySliceObject *)\n");
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- std::vector<int >::value_type *result = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
try {
- {
- std::vector<int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector<int > const *)arg1,arg2);
- result = (std::vector<int >::value_type *) &_result_ref;
- }
+ result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
-SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[3];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ return _wrap_VectorInt___getitem____SWIG_0(self, args);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorInt___getitem____SWIG_1(self, args);
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___getitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __getitem__(std::vector< int > *,PySliceObject *)\n"
+ " __getitem__(std::vector< int > const *,std::vector< int >::difference_type)\n");
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::difference_type arg2 ;
- std::vector<int >::value_type *arg3 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::difference_type arg2 ;
+ std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
- std::vector<int >::value_type temp3 ;
+ std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
}
- arg2 = static_cast< std::vector<int >::difference_type >(val2);
+ arg2 = static_cast< std::vector< int >::difference_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
- temp3 = static_cast< std::vector<int >::value_type >(val3);
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
try {
- std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
+ std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2,(int const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
+SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) {
+ int argc;
+ PyObject *argv[4];
+ int ii;
+
+ if (!PyTuple_Check(args)) SWIG_fail;
+ argc = (int)PyObject_Length(args);
+ for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+ argv[ii] = PyTuple_GET_ITEM(args,ii);
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ _v = PySlice_Check(argv[1]);
+ }
+ if (_v) {
+ int res = swig::asptr(argv[2], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_VectorInt___setitem____SWIG_0(self, args);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_VectorInt___setitem____SWIG_1(self, args);
+ }
+ }
+ }
+ }
+
+fail:
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___setitem__'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " __setitem__(std::vector< int > *,PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
+ " __setitem__(std::vector< int > *,std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::value_type *arg2 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- std::vector<int >::value_type temp2 ;
+ std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
- temp2 = static_cast< std::vector<int >::value_type >(val2);
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
resultobj = SWIG_Py_Void();
SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *result = 0 ;
+ std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
- result = (std::vector<int > *)new std::vector<int >();
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< int > *)new std::vector< int >();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = 0 ;
- std::vector<int > *result = 0 ;
+ std::vector< int > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
+ std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
{
- std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
}
arg1 = ptr;
}
- result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
}
-SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector<int > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (bool)((std::vector<int > const *)arg1)->empty();
- resultobj = SWIG_From_bool(static_cast< bool >(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector<int > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->size();
- resultobj = SWIG_From_size_t(static_cast< size_t >(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector<int > *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- (arg1)->clear();
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int > *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector<int > *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
- }
- arg2 = reinterpret_cast< std::vector<int > * >(argp2);
- (arg1)->swap(*arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- SwigValueWrapper<std::allocator<int > > result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->get_allocator();
- resultobj = SWIG_NewPointerObj((new std::vector<int >::allocator_type(static_cast< const std::vector<int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (bool)((std::vector< int > const *)arg1)->empty();
+ resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::size_type result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->size();
+ resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::const_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->begin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ (arg1)->clear();
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_begin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_begin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_begin'.\n Possible C/C++ prototypes are:\n begin()\n begin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
+ }
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg2 = reinterpret_cast< std::vector< int > * >(argp2);
+ (arg1)->swap(*arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::const_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ SwigValueWrapper< std::allocator< int > > result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->end();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->get_allocator();
+ resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_end__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_end__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_end'.\n Possible C/C++ prototypes are:\n end()\n end()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::reverse_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->begin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::const_reverse_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::const_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->rbegin();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->end();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_rbegin__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_rbegin__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rbegin'.\n Possible C/C++ prototypes are:\n rbegin()\n rbegin()\n");
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::reverse_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::const_reverse_iterator result;
- if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = (arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->rbegin();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::const_reverse_iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->rend();
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->rend();
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *self, PyObject *args) {
- int argc;
- PyObject *argv[2];
- int ii;
-
- if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
- for (ii = 0; (ii < argc) && (ii < 1); ii++) {
- argv[ii] = PyTuple_GET_ITEM(args,ii);
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_rend__SWIG_0(self, args);
- }
- }
- if (argc == 1) {
- int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_VectorInt_rend__SWIG_1(self, args);
- }
- }
-
-fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rend'.\n Possible C/C++ prototypes are:\n rend()\n rend()\n");
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int >::size_type arg1 ;
- std::vector<int > *result = 0 ;
+ std::vector< int >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
}
- arg1 = static_cast< std::vector<int >::size_type >(val1);
- result = (std::vector<int > *)new std::vector<int >(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
+ result = (std::vector< int > *)new std::vector< int >(arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type arg2 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
- arg2 = static_cast< std::vector<int >::size_type >(val2);
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator arg2 ;
- std::vector<int >::iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
result = (arg1)->erase(arg2);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator arg2 ;
- std::vector<int >::iterator arg3 ;
- std::vector<int >::iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::iterator arg2 ;
+ std::vector< int >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- swig::PySwigIterator *iter3 = 0 ;
+ swig::SwigPyIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
- res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+ res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter3);
+ swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorInt_erase__SWIG_0(self, args);
}
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_VectorInt_erase__SWIG_1(self, args);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_erase'.\n Possible C/C++ prototypes are:\n erase(std::vector<int >::iterator)\n erase(std::vector<int >::iterator,std::vector<int >::iterator)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_erase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " erase(std::vector< int > *,std::vector< int >::iterator)\n"
+ " erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int >::size_type arg1 ;
- std::vector<int >::value_type *arg2 = 0 ;
- std::vector<int > *result = 0 ;
+ std::vector< int >::size_type arg1 ;
+ std::vector< int >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
- std::vector<int >::value_type temp2 ;
+ std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ std::vector< int > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
}
- arg1 = static_cast< std::vector<int >::size_type >(val1);
+ arg1 = static_cast< std::vector< int >::size_type >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
- temp2 = static_cast< std::vector<int >::value_type >(val2);
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
- result = (std::vector<int > *)new std::vector<int >(arg1,(std::vector<int >::value_type const &)*arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW | 0 );
+ result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
if (argc == 1) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_VectorInt__SWIG_1(self, args);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorInt'.\n Possible C/C++ prototypes are:\n std::vector<(int)>()\n std::vector<(int)>(std::vector<int > const &)\n std::vector<(int)>(std::vector<int >::size_type)\n std::vector<(int)>(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorInt'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " std::vector< int >()\n"
+ " std::vector< int >(std::vector< int > const &)\n"
+ " std::vector< int >(std::vector< int >::size_type)\n"
+ " std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::value_type *arg2 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- std::vector<int >::value_type temp2 ;
+ std::vector< int >::value_type temp2 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
}
- temp2 = static_cast< std::vector<int >::value_type >(val2);
+ temp2 = static_cast< std::vector< int >::value_type >(val2);
arg2 = &temp2;
- (arg1)->push_back((std::vector<int >::value_type const &)*arg2);
+ (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::value_type *result = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector<int > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- {
- std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->front();
- result = (std::vector<int >::value_type *) &_result_ref;
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::value_type *result = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector<int > const *""'");
- }
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- {
- std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->back();
- result = (std::vector<int >::value_type *) &_result_ref;
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
resultobj = SWIG_From_int(static_cast< int >(*result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type arg2 ;
- std::vector<int >::value_type *arg3 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::size_type arg2 ;
+ std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
- std::vector<int >::value_type temp3 ;
+ std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
- arg2 = static_cast< std::vector<int >::size_type >(val2);
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
- temp3 = static_cast< std::vector<int >::value_type >(val3);
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
- (arg1)->assign(arg2,(std::vector<int >::value_type const &)*arg3);
+ (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type arg2 ;
- std::vector<int >::value_type *arg3 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::size_type arg2 ;
+ std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
- std::vector<int >::value_type temp3 ;
+ std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
- arg2 = static_cast< std::vector<int >::size_type >(val2);
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
- temp3 = static_cast< std::vector<int >::value_type >(val3);
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
- (arg1)->resize(arg2,(std::vector<int >::value_type const &)*arg3);
+ (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_resize'.\n Possible C/C++ prototypes are:\n resize(std::vector<int >::size_type)\n resize(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_resize'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " resize(std::vector< int > *,std::vector< int >::size_type)\n"
+ " resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator arg2 ;
- std::vector<int >::value_type *arg3 = 0 ;
- std::vector<int >::iterator result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::iterator arg2 ;
+ std::vector< int >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
- std::vector<int >::value_type temp3 ;
+ std::vector< int >::value_type temp3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ std::vector< int >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
}
- temp3 = static_cast< std::vector<int >::value_type >(val3);
+ temp3 = static_cast< std::vector< int >::value_type >(val3);
arg3 = &temp3;
- result = (arg1)->insert(arg2,(std::vector<int >::value_type const &)*arg3);
- resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
- swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+ result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3);
+ resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
+ swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::iterator arg2 ;
- std::vector<int >::size_type arg3 ;
- std::vector<int >::value_type *arg4 = 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::iterator arg2 ;
+ std::vector< int >::size_type arg3 ;
+ std::vector< int >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- swig::PySwigIterator *iter2 = 0 ;
+ swig::SwigPyIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
- std::vector<int >::value_type temp4 ;
+ std::vector< int >::value_type temp4 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
} else {
- swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+ swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
}
- arg3 = static_cast< std::vector<int >::size_type >(val3);
+ arg3 = static_cast< std::vector< int >::size_type >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector<int >::value_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
}
- temp4 = static_cast< std::vector<int >::value_type >(val4);
+ temp4 = static_cast< std::vector< int >::value_type >(val4);
arg4 = &temp4;
- (arg1)->insert(arg2,arg3,(std::vector<int >::value_type const &)*arg4);
+ (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
}
if (argc == 4) {
int _v;
- int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+ int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
- swig::PySwigIterator *iter = 0;
- int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
- _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+ swig::SwigPyIterator *iter = 0;
+ int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
+ _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_insert'.\n Possible C/C++ prototypes are:\n insert(std::vector<int >::iterator,std::vector<int >::value_type const &)\n insert(std::vector<int >::iterator,std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_insert'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
+ " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type arg2 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+ std::vector< int >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
}
- arg2 = static_cast< std::vector<int >::size_type >(val2);
+ arg2 = static_cast< std::vector< int >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
- std::vector<int >::size_type result;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ std::vector< int >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector<int > const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
- result = ((std::vector<int > const *)arg1)->capacity();
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+ result = ((std::vector< int > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+ std::vector< int > *arg1 = (std::vector< int > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector<int > *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'");
}
- arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+ arg1 = reinterpret_cast< std::vector< int > * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_NewClientData(obj));
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
-SWIGINTERN int ABR_TYPES_set(PyObject *) {
+SWIGINTERN int Swig_var_ABR_TYPES_set(PyObject *) {
SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
return 1;
}
-SWIGINTERN PyObject *ABR_TYPES_get(void) {
+SWIGINTERN PyObject *Swig_var_ABR_TYPES_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
pchar arg2 = (pchar) 0 ;
- pchar result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ pchar result;
if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'fatal_error'.\n Possible C/C++ prototypes are:\n Hex::fatal_error(cpchar,cpchar,cpchar)\n Hex::fatal_error(cpchar,cpchar)\n Hex::fatal_error(cpchar)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'fatal_error'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::fatal_error(cpchar,cpchar,cpchar)\n"
+ " Hex::fatal_error(cpchar,cpchar)\n"
+ " Hex::fatal_error(cpchar)\n");
return NULL;
}
PyObject *resultobj = 0;
double *arg1 ;
double *arg2 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
double *arg1 ;
double *arg2 ;
double *arg3 ;
- double *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
double *arg1 ;
double *arg2 ;
double *arg3 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
- double result;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
- double result;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
PyObject *resultobj = 0;
double *arg1 ;
double *arg2 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
PyObject *resultobj = 0;
double *arg1 ;
double *arg2 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
- double result;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
double *arg1 = (double *) 0 ;
double *arg2 = (double *) 0 ;
double arg3 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
double *arg2 = (double *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'same_coords'.\n Possible C/C++ prototypes are:\n Hex::same_coords(double *,double *,double)\n Hex::same_coords(double *,double *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'same_coords'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::same_coords(double *,double *,double)\n"
+ " Hex::same_coords(double *,double *)\n");
return NULL;
}
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
- bool result;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
double *arg2 = (double *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'requals'.\n Possible C/C++ prototypes are:\n Hex::requals(double const,double const)\n Hex::requals(double const *,double const *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'requals'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::requals(double const,double const)\n"
+ " Hex::requals(double const *,double const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
- int result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
int *arg2 = 0 ;
- char *result = 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
string *arg1 = 0 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string, 0 );
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
string *arg2 = 0 ;
- int result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
}
-SWIGINTERN int Epsil_set(PyObject *) {
+SWIGINTERN int Swig_var_Epsil_set(PyObject *) {
SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
return 1;
}
-SWIGINTERN PyObject *Epsil_get(void) {
+SWIGINTERN PyObject *Swig_var_Epsil_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
}
-SWIGINTERN int UnEpsil_set(PyObject *) {
+SWIGINTERN int Swig_var_UnEpsil_set(PyObject *) {
SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
return 1;
}
-SWIGINTERN PyObject *UnEpsil_get(void) {
+SWIGINTERN PyObject *Swig_var_UnEpsil_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
}
-SWIGINTERN int Epsil2_set(PyObject *) {
+SWIGINTERN int Swig_var_Epsil2_set(PyObject *) {
SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
return 1;
}
-SWIGINTERN PyObject *Epsil2_get(void) {
+SWIGINTERN PyObject *Swig_var_Epsil2_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setError'.\n Possible C/C++ prototypes are:\n setError(int)\n setError()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setError'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " setError(Hex::EltBase *,int)\n"
+ " setError(Hex::EltBase *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::EnumElt arg2 ;
- Hex::EltBase *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::EltBase *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EnumElt arg1 ;
- Hex::EltBase *result = 0 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EltBase'.\n Possible C/C++ prototypes are:\n Hex::EltBase(Hex::Document *,Hex::EnumElt)\n Hex::EltBase(Hex::Document *)\n Hex::EltBase(Hex::EnumElt)\n Hex::EltBase()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EltBase'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::EltBase(Hex::Document *,Hex::EnumElt)\n"
+ " Hex::EltBase(Hex::Document *)\n"
+ " Hex::EltBase(Hex::EnumElt)\n"
+ " Hex::EltBase()\n");
return NULL;
}
}
arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
char *arg2 = (char *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
int arg1 ;
int arg2 ;
char *arg3 = (char *) 0 ;
- char *result = 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- Hex::EltBase *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- Hex::EnumElt result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::EnumElt result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
int arg2 ;
- Hex::EltBase *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
pchar arg2 = (pchar) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_printName'.\n Possible C/C++ prototypes are:\n printName(cpchar)\n printName()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_printName'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " printName(Hex::EltBase *,cpchar)\n"
+ " printName(Hex::EltBase *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_getName'.\n Possible C/C++ prototypes are:\n getName(pchar)\n getName()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_getName'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " getName(Hex::EltBase *,pchar)\n"
+ " getName(Hex::EltBase *)\n");
return NULL;
}
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setName'.\n Possible C/C++ prototypes are:\n setName(string const &)\n setName(cpchar)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setName'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " setName(Hex::EltBase *,string const &)\n"
+ " setName(Hex::EltBase *,cpchar)\n");
return NULL;
}
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
int arg2 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_debug'.\n Possible C/C++ prototypes are:\n debug(int)\n debug()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_debug'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " debug(Hex::EltBase *,int)\n"
+ " debug(Hex::EltBase *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
- string result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ string result;
if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 | 0 );
SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
int arg3 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
double arg2 ;
double arg3 ;
double arg4 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
int arg3 ;
double arg4 ;
double arg5 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
int arg3 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
PyObject *resultobj = 0;
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
PyObject *resultobj = 0;
Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Edge * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
Hex::Quad *arg1 = (Hex::Quad *) 0 ;
int arg2 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
PyObject *resultobj = 0;
Hex::Quad *arg1 = (Hex::Quad *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
Hex::Quad *arg1 = (Hex::Quad *) 0 ;
Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
int arg3 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
PyObject *resultobj = 0;
Hex::Quad *arg1 = (Hex::Quad *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
PyObject *resultobj = 0;
Hex::Quad *arg1 = (Hex::Quad *) 0 ;
double *arg2 = (double *) 0 ;
- double *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Quad * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
int arg2 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
int arg2 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 | 0 );
Hex::Quad *arg4 = (Hex::Quad *) 0 ;
Hex::Quad *arg5 = (Hex::Quad *) 0 ;
Hex::Quad *arg6 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vector *arg1 = (Hex::Vector *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vector *arg1 = (Hex::Vector *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vector *arg1 = (Hex::Vector *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vector *arg1 = (Hex::Vector *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Vector *arg1 = (Hex::Vector *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 | 0 );
double arg2 ;
double arg3 ;
double arg4 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
double arg3 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vector'.\n Possible C/C++ prototypes are:\n Hex::Vector(Hex::Document *,double,double,double)\n Hex::Vector(Hex::Document *,double,double)\n Hex::Vector(Hex::Document *,double)\n Hex::Vector(Hex::Document *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vector'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::Vector(Hex::Document *,double,double,double)\n"
+ " Hex::Vector(Hex::Document *,double,double)\n"
+ " Hex::Vector(Hex::Document *,double)\n"
+ " Hex::Vector(Hex::Document *)\n");
return NULL;
}
}
arg1 = reinterpret_cast< Hex::Vector * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
Hex::Hex *arg2 = (Hex::Hex *) 0 ;
- Hex::Document *result = 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
cpchar arg1 = (cpchar) 0 ;
- Hex::Document *result = 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Document'.\n Possible C/C++ prototypes are:\n Hex::Document(cpchar,Hex::Hex *)\n Hex::Document(cpchar)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Document'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::Document(cpchar,Hex::Hex *)\n"
+ " Hex::Document(cpchar)\n");
return NULL;
}
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
char *arg2 = (char *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
char *arg2 = (char *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- double result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ double result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
double arg2 ;
double arg3 ;
double arg4 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
double arg3 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVertex'.\n Possible C/C++ prototypes are:\n addVertex(double,double,double)\n addVertex(double,double)\n addVertex(double)\n addVertex()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVertex'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " addVertex(Hex::Document *,double,double,double)\n"
+ " addVertex(Hex::Document *,double,double)\n"
+ " addVertex(Hex::Document *,double)\n"
+ " addVertex(Hex::Document *)\n");
return NULL;
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Edge *arg3 = (Hex::Edge *) 0 ;
Hex::Edge *arg4 = (Hex::Edge *) 0 ;
Hex::Edge *arg5 = (Hex::Edge *) 0 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Quad *arg5 = (Hex::Quad *) 0 ;
Hex::Quad *arg6 = (Hex::Quad *) 0 ;
Hex::Quad *arg7 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
Hex::Quad *arg3 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
Hex::Quad *arg3 = (Hex::Quad *) 0 ;
Hex::Quad *arg4 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Quad *arg3 = (Hex::Quad *) 0 ;
Hex::Quad *arg4 = (Hex::Quad *) 0 ;
Hex::Quad *arg5 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Quad *arg4 = (Hex::Quad *) 0 ;
Hex::Quad *arg5 = (Hex::Quad *) 0 ;
Hex::Quad *arg6 = (Hex::Quad *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
double arg2 ;
double arg3 ;
double arg4 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
double arg3 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVector'.\n Possible C/C++ prototypes are:\n addVector(double,double,double)\n addVector(double,double)\n addVector(double)\n addVector()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVector'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " addVector(Hex::Document *,double,double,double)\n"
+ " addVector(Hex::Document *,double,double)\n"
+ " addVector(Hex::Document *,double)\n"
+ " addVector(Hex::Document *)\n");
return NULL;
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
- Hex::Law *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Law *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
bool arg3 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaws'.\n Possible C/C++ prototypes are:\n addLaws(double,bool)\n addLaws(double)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaws'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " addLaws(Hex::Document *,double,bool)\n"
+ " addLaws(Hex::Document *,double)\n");
return NULL;
}
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
double arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
double arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
double arg4 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
double arg5 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
Hex::Quad *arg3 = (Hex::Quad *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
Hex::Edge *arg3 = (Hex::Edge *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexas arg2 ;
Hex::Edges arg3 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
+ std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp4 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Edge *arg3 = (Hex::Edge *) 0 ;
Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::IntVector arg4 ;
double arg5 ;
double arg6 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
double val5 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
Hex::IntVector arg5 ;
double arg6 ;
bool arg7 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
{
- std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
+ std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
+ std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
+ std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Vector *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vector *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::NewShape *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::NewShape *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Law *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Law *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Propagation *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Propagation *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
+SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ Hex::Document *arg1 = (Hex::Document *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject * obj0 = 0 ;
+ cpchar result;
+
+ if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
+ }
+ arg1 = reinterpret_cast< Hex::Document * >(argp1);
+ result = (cpchar)(arg1)->getFirstExplicitShape();
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
double arg2 ;
double arg3 ;
double arg4 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Edge *arg2 = (Hex::Edge *) 0 ;
Hex::Edge *arg3 = (Hex::Edge *) 0 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findQuad'.\n Possible C/C++ prototypes are:\n findQuad(Hex::Vertex *,Hex::Vertex *)\n findQuad(Hex::Edge *,Hex::Edge *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findQuad'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " findQuad(Hex::Document *,Hex::Vertex *,Hex::Vertex *)\n"
+ " findQuad(Hex::Document *,Hex::Edge *,Hex::Edge *)\n");
return NULL;
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Law *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Law *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Edge *arg2 = (Hex::Edge *) 0 ;
- Hex::Propagation *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Propagation *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Elements *arg2 = (Hex::Elements *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Group *arg2 = (Hex::Group *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Law *arg2 = (Hex::Law *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg9 ;
int arg10 ;
int arg11 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::RealVector arg6 ;
Hex::RealVector arg7 ;
Hex::RealVector arg8 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg5 = reinterpret_cast< Hex::Vector * >(argp5);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj5, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj6, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj7, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg9 ;
int arg10 ;
int arg11 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::RealVector arg5 ;
Hex::RealVector arg6 ;
Hex::RealVector arg7 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj5, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj6, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg9 ;
int arg10 ;
int arg11 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::RealVector arg5 ;
Hex::RealVector arg6 ;
Hex::RealVector arg7 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj5, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj6, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
int arg3 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalTop'.\n Possible C/C++ prototypes are:\n makeSphericalTop(int,int)\n makeSphericalTop(int)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalTop'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " makeSphericalTop(Hex::Document *,int,int)\n"
+ " makeSphericalTop(Hex::Document *,int)\n");
return NULL;
}
double arg5 ;
int arg6 ;
int arg7 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
double arg5 ;
int arg6 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 7); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalUni'.\n Possible C/C++ prototypes are:\n makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalUni'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " makeSphericalUni(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n"
+ " makeSphericalUni(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
return NULL;
}
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
Hex::RealVector arg5 ;
int arg6 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
Hex::RealVector arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
_v = SWIG_CheckState(res);
if (_v) {
- int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[4], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_Document_makeSpherical__SWIG_1(self, args);
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
_v = SWIG_CheckState(res);
if (_v) {
- int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
+ int res = swig::asptr(argv[4], (std::vector<double,std::allocator< double > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSpherical'.\n Possible C/C++ prototypes are:\n makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSpherical'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " makeSpherical(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n"
+ " makeSpherical(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
return NULL;
}
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg9 ;
int arg10 ;
int arg11 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::RealVector arg5 ;
Hex::RealVector arg6 ;
Hex::RealVector arg7 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj5, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj6, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg10 ;
int arg11 ;
int arg12 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::RealVector arg5 ;
Hex::RealVector arg6 ;
Hex::RealVector arg7 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj5, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
if (SWIG_IsNewObj(res)) delete ptr;
}
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj6, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
Hex::Vector *arg7 = (Hex::Vector *) 0 ;
double arg8 ;
double arg9 ;
- Hex::BiCylinder *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
+ Hex::BiCylinder *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
double arg9 ;
double arg10 ;
double arg11 ;
- Hex::BiCylinder *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
+ Hex::BiCylinder *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
int arg3 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
double arg4 ;
int arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
Hex::RealVector arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg3 = reinterpret_cast< Hex::Vector * >(argp3);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quads arg2 ;
int arg3 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
double arg4 ;
int arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
Hex::Quads arg2 ;
Hex::Vector *arg3 = (Hex::Vector *) 0 ;
Hex::RealVector arg4 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
}
arg3 = reinterpret_cast< Hex::Vector * >(argp3);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
double arg5 ;
int arg6 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
Hex::RealVector arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
double arg5 ;
int arg6 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
Hex::Vector *arg4 = (Hex::Vector *) 0 ;
Hex::RealVector arg5 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
}
arg4 = reinterpret_cast< Hex::Vector * >(argp4);
{
- std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
+ std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
int arg8 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
int arg8 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
Hex::RealVector *arg8 = 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
}
arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
- res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
+ res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
}
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
Hex::RealVector *arg8 = 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp3 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
{
- std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
}
arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
- res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
+ res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Edge *arg2 = (Hex::Edge *) 0 ;
int arg3 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Edge *arg2 = (Hex::Edge *) 0 ;
Hex::RealVector *arg3 = 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
}
arg2 = reinterpret_cast< Hex::Edge * >(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 );
+ res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
Hex::EnumGroup arg3 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
pfile arg2 = (pfile) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findVertex'.\n Possible C/C++ prototypes are:\n findVertex(double,double,double)\n findVertex(int)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findVertex'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " findVertex(Hex::Document *,double,double,double)\n"
+ " findVertex(Hex::Document *,int)\n");
return NULL;
}
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quad *arg2 = (Hex::Quad *) 0 ;
Hex::Quad *arg3 = (Hex::Quad *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Law *arg2 = (Hex::Law *) 0 ;
- Hex::Law *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Law *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaw'.\n Possible C/C++ prototypes are:\n addLaw(char const *,int)\n addLaw(Hex::Law *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaw'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " addLaw(Hex::Document *,char const *,int)\n"
+ " addLaw(Hex::Document *,Hex::Law *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
long arg2 ;
char *arg3 = (char *) 0 ;
- Hex::NewShape *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
long val2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::NewShape *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Document * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
- Hex::Edges *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Edges *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
}
arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
- {
- Hex::Edges const &_result_ref = (arg1)->getEdges();
- result = (Hex::Edges *) &_result_ref;
- }
- resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > >(*result));
+ result = (Hex::Edges *) &(arg1)->getEdges();
+ resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > >(*result));
return resultobj;
fail:
return NULL;
SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
- Hex::Law *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Law *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ bool result;
if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
PyObject *resultobj = 0;
Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
Hex::Law *arg2 = (Hex::Law *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::Propagation *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Propagation *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
int arg2 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_addDocument'.\n Possible C/C++ prototypes are:\n addDocument(cpchar)\n addDocument()\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_addDocument'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " addDocument(Hex::Hex *,cpchar)\n"
+ " addDocument(Hex::Hex *)\n");
return NULL;
}
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
string *arg2 = 0 ;
- Hex::Document *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Document *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_findDocument'.\n Possible C/C++ prototypes are:\n findDocument(cpchar)\n findDocument(string const &)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_findDocument'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " findDocument(Hex::Hex *,cpchar)\n"
+ " findDocument(Hex::Hex *,string const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
PyObject *resultobj = 0;
Hex::Hex *arg1 = (Hex::Hex *) 0 ;
int arg2 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Hex * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
int arg2 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
int arg2 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
int arg2 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
int arg2 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
int arg2 ;
int arg3 ;
int arg4 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
PyObject *resultobj = 0;
Hex::Elements *arg1 = (Hex::Elements *) 0 ;
cpchar arg2 = (cpchar) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::Elements *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Elements * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::BiCylinder *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::BiCylinder *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Hexa *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Hexa *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Quad *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Quad *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Edge *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Edge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
int arg3 ;
int arg4 ;
int arg5 ;
- Hex::Vertex *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
+ Hex::Vertex *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
int arg2 ;
- cpchar result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ cpchar result;
if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::EnumShape arg2 ;
- Hex::NewShape *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::NewShape *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
- Hex::NewShape *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::NewShape *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewShape'.\n Possible C/C++ prototypes are:\n Hex::NewShape(Hex::Document *,Hex::EnumShape)\n Hex::NewShape(Hex::Document *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewShape'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " Hex::NewShape(Hex::Document *,Hex::EnumShape)\n"
+ " Hex::NewShape(Hex::Document *)\n");
return NULL;
}
}
arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
- Hex::EnumGroup result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
+ Hex::EnumGroup result;
if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
int arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ int result;
if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
- argc = PyObject_Length(args);
+ argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
}
fail:
- SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeElement'.\n Possible C/C++ prototypes are:\n removeElement(int)\n removeElement(Hex::EltBase *)\n");
+ SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeElement'.\n"
+ " Possible C/C++ prototypes are:\n"
+ " removeElement(Hex::Group *,int)\n"
+ " removeElement(Hex::Group *,Hex::EltBase *)\n");
return NULL;
}
PyObject *resultobj = 0;
Hex::Group *arg1 = (Hex::Group *) 0 ;
int arg2 ;
- Hex::EltBase *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ Hex::EltBase *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 | 0 );
Hex::Document *arg1 = (Hex::Document *) 0 ;
cpchar arg2 = (cpchar) 0 ;
Hex::EnumGroup arg3 ;
- Hex::Group *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ Hex::Group *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
}
arg1 = reinterpret_cast< Hex::Group * >(argp1);
delete arg1;
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+ if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
static PyMethodDef SwigMethods[] = {
- { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
- { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
+ { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
+ { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
+ { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
{ (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorHexas___bool__", _wrap_VectorHexas___bool__, METH_VARARGS, NULL},
{ (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
{ (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
{ (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
{ (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorQuads___bool__", _wrap_VectorQuads___bool__, METH_VARARGS, NULL},
{ (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
{ (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
{ (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
{ (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorEdges___bool__", _wrap_VectorEdges___bool__, METH_VARARGS, NULL},
{ (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
{ (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
{ (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
{ (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorVertices___bool__", _wrap_VectorVertices___bool__, METH_VARARGS, NULL},
{ (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
{ (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
{ (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
{ (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorShapes___bool__", _wrap_VectorShapes___bool__, METH_VARARGS, NULL},
{ (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
{ (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
{ (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
{ (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorReal___bool__", _wrap_VectorReal___bool__, METH_VARARGS, NULL},
{ (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
{ (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
{ (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
{ (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
{ (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
{ (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
+ { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL},
{ (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
{ (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
{ (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
{ (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
{ (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
{ (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
+ { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
{ (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
{ (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
{ (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
-static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Vector *) x));
}
-static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::NewShape *) x));
}
-static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Group *) x));
}
-static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Propagation *) x));
}
-static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Vertex *) x));
}
-static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Hexa *) x));
}
-static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Edge *) x));
}
-static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Quad *) x));
}
-static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Elements *) x));
}
-static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) ((Hex::Document *) x));
}
-static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x) {
+static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
}
-static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x) {
+static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((Hex::Elements *) ((Hex::BiCylinder *) x));
}
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|Hex::Real *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t = {"_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t", "std::vector<Hex::AssoEdge *,std::allocator<Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t = {"_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t", "std::vector<Hex::EdgeShape *,std::allocator<Hex::EdgeShape * > > *|Hex::EdgeShapes *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t", "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *|Hex::Edges *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type", "std::allocator<Hex::Edge * > *|std::vector<Hex::Edge * >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t = {"_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t", "std::vector<Hex::EltBase *,std::allocator<Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t = {"_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t", "std::vector<Hex::FaceShape *,std::allocator<Hex::FaceShape * > > *|Hex::FaceShapes *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t", "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *|Hex::Hexas *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type", "std::allocator<Hex::Hexa * > *|std::vector<Hex::Hexa * >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t", "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *|Hex::NewShapes *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type", "std::allocator<Hex::NewShape * > *|std::vector<Hex::NewShape * >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t", "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *|Hex::Quads *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type", "std::allocator<Hex::Quad * > *|std::vector<Hex::Quad * >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t = {"_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t", "std::vector<Hex::Shape *,std::allocator<Hex::Shape * > > *|Hex::Shapes *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t = {"_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t", "std::vector<Hex::SubShape *,std::allocator<Hex::SubShape * > > *|Hex::SubShapes *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t", "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *|Hex::Vertices *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type", "std::allocator<Hex::Vertex * > *|std::vector<Hex::Vertex * >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t", "std::vector<double,std::allocator<double > > *|Hex::RealVector *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type", "std::allocator<double > *|std::vector<double >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t = {"_p_std__vectorTint_std__allocatorTint_t_t", "std::vector<int,std::allocator<int > > *|Hex::IntVector *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type = {"_p_std__vectorTint_std__allocatorTint_t_t__allocator_type", "std::allocator<int > *|std::vector<int >::allocator_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t = {"_p_std__vectorTstd__string_std__allocatorTstd__string_t_t", "std::vector<std::string,std::allocator<std::string > > *|Hex::TabText *", 0, 0, (void*)0, 0};
+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};
+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};
+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};
+static swig_type_info _swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type", "std::vector< Hex::Edge * >::allocator_type *|std::allocator< Hex::Edge * > *", 0, 0, (void*)0, 0};
+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};
+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};
+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};
+static swig_type_info _swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type", "std::vector< Hex::Hexa * >::allocator_type *|std::allocator< Hex::Hexa * > *", 0, 0, (void*)0, 0};
+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};
+static swig_type_info _swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type = {"_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type", "std::vector< Hex::NewShape * >::allocator_type *|std::allocator< Hex::NewShape * > *", 0, 0, (void*)0, 0};
+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};
+static swig_type_info _swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type", "std::vector< Hex::Quad * >::allocator_type *|std::allocator< Hex::Quad * > *", 0, 0, (void*)0, 0};
+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};
+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};
+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};
+static swig_type_info _swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type", "std::vector< Hex::Vertex * >::allocator_type *|std::allocator< Hex::Vertex * > *", 0, 0, (void*)0, 0};
+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};
+static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type = {"_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
+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};
+static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type = {"_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
+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};
static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type = {"_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type", "Hex::Edge *|std::vector<Hex::Edge * >::value_type", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type = {"_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type", "Hex::Hexa *|std::vector<Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type = {"_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type", "Hex::NewShape *|std::vector<Hex::NewShape * >::value_type", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type = {"_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type", "Hex::Quad *|std::vector<Hex::Quad * >::value_type", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type = {"_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type", "Hex::Vertex *|std::vector<Hex::Vertex * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type = {"_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type", "std::vector< Hex::Edge * >::value_type|Hex::Edge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type = {"_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type", "Hex::Hexa *|std::vector< Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type = {"_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type", "std::vector< Hex::NewShape * >::value_type|Hex::NewShape *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type = {"_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type", "std::vector< Hex::Quad * >::value_type|Hex::Quad *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type = {"_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type", "std::vector< Hex::Vertex * >::value_type|Hex::Vertex *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_FILE,
&_swigt__p_reference,
&_swigt__p_size_type,
&_swigt__p_std__invalid_argument,
- &_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
- &_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
- &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
- &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
- &_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
- &_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
- &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
- &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
- &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
- &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
- &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
- &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
- &_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
- &_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
- &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
- &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
- &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t,
- &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
- &_swigt__p_std__vectorTint_std__allocatorTint_t_t,
- &_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
- &_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
+ &_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
+ &_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
+ &_swigt__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__allocator_type,
+ &_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
+ &_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
+ &_swigt__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__allocator_type,
+ &_swigt__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__allocator_type,
+ &_swigt__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__allocator_type,
+ &_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
+ &_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
+ &_swigt__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__allocator_type,
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
+ &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
+ &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
+ &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
&_swigt__p_string,
- &_swigt__p_swig__PySwigIterator,
+ &_swigt__p_swig__SwigPyIterator,
&_swigt__p_value_type,
- &_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
- &_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
- &_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
- &_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
- &_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
+ &_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type,
+ &_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type,
+ &_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type,
+ &_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type,
+ &_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type,
};
static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__BiCylinder[] = { {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Document[] = { {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__Edge[] = { {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__Edge[] = { {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
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}};
-static swig_cast_info _swigc__p_Hex__EltBase[] = { {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Elements, _p_Hex__ElementsTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__EltBase[] = { {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, _p_Hex__NewShapeTo_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__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0}, {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0}, {&_swigt__p_Hex__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}};
static swig_cast_info _swigc__p_Hex__Group[] = { {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Hex[] = { {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = { {&_swigt__p_Hex__Group, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Elements, 0, 0, 0}, {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0}, {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Propagation, 0, 0, 0}, {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, 0, 0, 0}, {&_swigt__p_Hex__BiCylinder, 0, 0, 0}, {&_swigt__p_Hex__Document, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__Hexa[] = { {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = { {&_swigt__p_Hex__Group, 0, 0, 0}, {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0}, {&_swigt__p_Hex__Elements, 0, 0, 0}, {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0}, {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Propagation, 0, 0, 0}, {&_swigt__p_Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0}, {&_swigt__p_Hex__Vector, 0, 0, 0}, {&_swigt__p_Hex__BiCylinder, 0, 0, 0}, {&_swigt__p_Hex__Document, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__Hexa[] = { {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Law[] = { {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__NewShape[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__NewShape[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Propagation[] = { {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__Quad[] = { {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__Quad[] = { {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Shape[] = { {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__Vector[] = { {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Hex__Vertex[] = { {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Hex__Vertex[] = { {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Hex__XmlWriter[] = { {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = { {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = { {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t[] = { {&_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t[] = { {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t[] = { {&_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t[] = { {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t[] = { {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t[] = { {&_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t[] = { {&_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t[] = { {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t[] = { {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type[] = { {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t[] = { {&_swigt__p_std__vectorTint_std__allocatorTint_t_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type[] = { {&_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t[] = { {&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+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}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+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}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+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}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
+static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+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}};
static swig_cast_info _swigc__p_string[] = { {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type[] = { {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type[] = { {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type[] = { {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type[] = { {&_swigt__p_Hex__NewShape, 0, 0, 0}, {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type[] = { {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type[] = { {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0}, {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_FILE,
_swigc__p_reference,
_swigc__p_size_type,
_swigc__p_std__invalid_argument,
- _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
- _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
- _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
- _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
- _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
- _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
- _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
- _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
- _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
- _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
- _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
- _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
- _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
- _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
- _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
- _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
- _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t,
- _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
- _swigc__p_std__vectorTint_std__allocatorTint_t_t,
- _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
- _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
+ _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
+ _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
+ _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
+ _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type,
+ _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
+ _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
+ _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
+ _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type,
+ _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
+ _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type,
+ _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
+ _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type,
+ _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
+ _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
+ _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
+ _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type,
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
+ _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
+ _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
+ _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
_swigc__p_string,
- _swigc__p_swig__PySwigIterator,
+ _swigc__p_swig__SwigPyIterator,
_swigc__p_value_type,
- _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
- _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
- _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
- _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
- _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
+ _swigc__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type,
+ _swigc__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type,
+ _swigc__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type,
+ _swigc__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type,
+ _swigc__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type,
};
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
- int found;
+ int found, init;
clientdata = clientdata;
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
+ init = 1;
+ } else {
+ init = 0;
}
/* Try and load any already created modules */
module_head->next = &swig_module;
}
+ /* When multiple interpeters are used, a module could have already been initialized in
+ a different interpreter, but not yet have a pointer in this interpreter.
+ In this case, we do not want to continue adding types... everything should be
+ set up already */
+ if (init == 0) return;
+
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
+#if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_InternFromString("<Swig global variables>");
+#else
return PyString_FromString("<Swig global variables>");
+#endif
}
SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject *v) {
+#if PY_VERSION_HEX >= 0x03000000
+ PyObject *str = PyUnicode_InternFromString("(");
+ PyObject *tail;
+ PyObject *joined;
+ swig_globalvar *var;
+ for (var = v->vars; var; var=var->next) {
+ tail = PyUnicode_FromString(var->name);
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+ if (var->next) {
+ tail = PyUnicode_InternFromString(", ");
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+ }
+ }
+ tail = PyUnicode_InternFromString(")");
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+#else
PyObject *str = PyString_FromString("(");
- swig_globalvar *var;
+ swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
+#endif
return str;
}
SWIGINTERN int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
+ char *tmp;
PyObject *str = swig_varlink_str(v);
fprintf(fp,"Swig global variables ");
- fprintf(fp,"%s\n", PyString_AsString(str));
+ fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
+ SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(str);
return 0;
}
if (!type_init) {
const PyTypeObject tmp
= {
+ /* PyObject header changed in Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
PyObject_HEAD_INIT(NULL)
0, /* Number of items in variable part (ob_size) */
+#endif
(char *)"swigvarlink", /* Type name (tp_name) */
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
0, /* Itemsize (tp_itemsize) */
- (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
+ (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
(printfunc) swig_varlink_print, /* Print (tp_print) */
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
- (reprfunc)swig_varlink_str, /* tp_str */
+ (reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
#endif
};
varlink_type = tmp;
+ /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
+#if PY_VERSION_HEX < 0x03000000
varlink_type.ob_type = &PyType_Type;
+#endif
type_init = 1;
}
return &varlink_type;
#ifdef __cplusplus
extern "C"
#endif
-SWIGEXPORT void SWIG_init(void) {
- PyObject *m, *d;
+
+SWIGEXPORT
+#if PY_VERSION_HEX >= 0x03000000
+PyObject*
+#else
+void
+#endif
+SWIG_init(void) {
+ PyObject *m, *d;
+#if PY_VERSION_HEX >= 0x03000000
+ static struct PyModuleDef SWIG_module = {
+ PyModuleDef_HEAD_INIT,
+ (char *) SWIG_name,
+ NULL,
+ -1,
+ SwigMethods,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+ };
+#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
+#if PY_VERSION_HEX >= 0x03000000
+ m = PyModule_Create(&SWIG_module);
+#else
m = Py_InitModule((char *) SWIG_name, SwigMethods);
+#endif
d = PyModule_GetDict(m);
SWIG_InitializeModule(0);
SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
- SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",ABR_TYPES_get, ABR_TYPES_set);
+ SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",Swig_var_ABR_TYPES_get, Swig_var_ABR_TYPES_set);
SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
- SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Epsil_get, Epsil_set);
- SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",UnEpsil_get, UnEpsil_set);
- SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Epsil2_get, Epsil2_set);
+ SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Swig_var_Epsil_get, Swig_var_Epsil_set);
+ SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",Swig_var_UnEpsil_get, Swig_var_UnEpsil_set);
+ SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Swig_var_Epsil2_get, Swig_var_Epsil2_set);
+#if PY_VERSION_HEX >= 0x03000000
+ return m;
+#else
+ return;
+#endif
}
