/* ----------------------------------------------------------------------------

* This file was automatically generated by SWIG (http://www.swig.org).

* Version 1.3.25

*

* 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

* changes to this file unless you know what you are doing--modify the SWIG

* interface file instead.

* ----------------------------------------------------------------------------- */

#define SWIGPYTHON

#ifdef __cplusplus

template<class T> class SwigValueWrapper {

T *tt;

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);

};

#endif

#ifndef SWIG_TEMPLATE_DISAMBIGUATOR

# if defined(__SUNPRO_CC)

# define SWIG_TEMPLATE_DISAMBIGUATOR template

# else

# define SWIG_TEMPLATE_DISAMBIGUATOR

# endif

#endif

#include <Python.h>

/***********************************************************************

* swigrun.swg

*

* This file contains generic CAPI 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 "2"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */

#ifdef SWIG_TYPE_TABLE

#define SWIG_QUOTE_STRING(x) #x

#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

#else

#define SWIG_TYPE_TABLE_NAME

#endif

#include <string.h>

#ifndef SWIGINLINE

#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))

# define SWIGINLINE inline

#else

# define SWIGINLINE

#endif

#endif

/* attritbute passed for some compilers to avoid unused method warnings */

#ifndef SWIGUNUSED

#ifdef __GNUC__

#define SWIGUNUSED __attribute__ ((unused))

#else

#define SWIGUNUSED

#endif

#endif

/*

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'.

But only do this if is strictly necessary, ie, if you have problems

with your compiler or so.

*/

#ifndef SWIGRUNTIME

#define SWIGRUNTIME static SWIGUNUSED

#endif

#ifndef SWIGRUNTIMEINLINE

#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

#endif

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

# if !defined(STATIC_LINKED)

# define SWIGEXPORT(a) __declspec(dllexport) a

# else

# define SWIGEXPORT(a) a

# endif

#else

# define SWIGEXPORT(a) a

#endif

#ifdef __cplusplus

extern "C" {

#endif

typedef void *(*swig_converter_func)(void *);

typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store inforomation 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 */

swig_dycast_func dcast; /* dynamic cast function down a hierarchy */

struct swig_cast_info *cast; /* linked list of types that can cast into this type */

void *clientdata; /* language specific type data */

} swig_type_info;

/* Structure to store a type and conversion function used for casting */

typedef struct swig_cast_info {

swig_type_info *type; /* pointer to type that is equivalent to this type */

swig_converter_func converter; /* function to cast the void pointers */

struct swig_cast_info *next; /* pointer to next cast in linked list */

struct swig_cast_info *prev; /* pointer to the previous cast */

} swig_cast_info;

/* Structure used to store module information

* Each module generates one structure like this, and the runtime collects

* all of these structures and stores them in a circularly linked list.*/

typedef struct swig_module_info {

swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */

int size; /* Number of types in this module */

struct swig_module_info *next; /* Pointer to next element in circularly linked list */

swig_type_info **type_initial; /* Array of initially generated type structures */

swig_cast_info **cast_initial; /* Array of initially generated casting structures */

void *clientdata; /* Language specific module data */

} swig_module_info;

/*

Compare two type names skipping the space characters, therefore

"char*" == "char *" and "Class<int>" == "Class<int >", etc.

Return 0 when the two name types are equivalent, as in

strncmp, but skipping ' '.

*/

SWIGRUNTIME int

SWIG_TypeNameComp(const char *f1, const char *l1,

const char *f2, const char *l2) {

for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {

while ((*f1 == ' ') && (f1 != l1)) ++f1;

while ((*f2 == ' ') && (f2 != l2)) ++f2;

if (*f1 != *f2) return *f1 - *f2;

}

return (l1 - f1) - (l2 - f2);

}

/*

Check type equivalence in a name list like <name1>|<name2>|...

Return 0 if not equal, 1 if equal

*/

SWIGRUNTIME int

SWIG_TypeEquiv(const char *nb, const char *tb) {

int equiv = 0;

const char* te = tb + strlen(tb);

const char* ne = nb;

while (!equiv && *ne) {

for (nb = ne; *ne; ++ne) {

if (*ne == '|') break;

}

equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;

if (*ne) ++ne;

}

return equiv;

}

/*

Check type equivalence in a name list like <name1>|<name2>|...

Return 0 if equal, -1 if nb < tb, 1 if nb > tb

*/

SWIGRUNTIME int

SWIG_TypeCompare(const char *nb, const char *tb) {

int equiv = 0;

const char* te = tb + strlen(tb);

const char* ne = nb;

while (!equiv && *ne) {

for (nb = ne; *ne; ++ne) {

if (*ne == '|') break;

}

equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;

if (*ne) ++ne;

}

return equiv;

}

/* think of this as a c++ template<> or a scheme macro */

#define SWIG_TypeCheck_Template(comparison, ty) \

do { \

swig_cast_info *iter; \

if (!ty) return 0; \

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; \

} while(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);

}

/* Same as previous function, 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);

}

/*

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);

}

/*

Dynamic pointer casting. Down an inheritance hierarchy

*/

SWIGRUNTIME swig_type_info *

SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {

swig_type_info *lastty = ty;

if (!ty || !ty->dcast) return ty;

while (ty && (ty->dcast)) {

ty = (*ty->dcast)(ptr);

if (ty) lastty = ty;

}

return lastty;

}

/*

Return the name associated with this type

*/

SWIGRUNTIMEINLINE const char *

SWIG_TypeName(const swig_type_info *ty) {

return ty->name;

}

/*

Return the pretty name associated with this type,

that is an unmangled type name in a form presentable to the user.

*/

SWIGRUNTIME const char *

SWIG_TypePrettyName(const swig_type_info *type) {

/* The "str" field contains the equivalent pretty names of the

type, separated by vertical-bar characters. We choose

to print the last name, as it is often (?) the most

specific. */

if (type->str != NULL) {

const char *last_name = type->str;

const char *s;

for (s = type->str; *s; s++)

if (*s == '|') last_name = s+1;

return last_name;

}

else

return type->name;

}

/*

Set the clientdata field for a type

*/

SWIGRUNTIME void

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

swig_cast_info *cast;

if (ti->clientdata) return;

/* if (ti->clientdata == clientdata) return; */

ti->clientdata = clientdata;

cast = ti->cast;

while (cast) {

if (!cast->converter)

SWIG_TypeClientData(cast->type, clientdata);

cast = cast->next;

}

}

/*

Search for a swig_type_info structure only by mangled name

Search is a O(log #types)

We start searching at module start, and finish searching when start == end.

Note: if start == end at the beginning of the function, we go all the way around

the circular list.

*/

SWIGRUNTIME swig_type_info *

SWIG_MangledTypeQueryModule(swig_module_info *start,

swig_module_info *end,

const char *name) {

swig_module_info *iter;

int l, r, i, compare;

iter = start;

do {

l = 0;

r = iter->size - 1;

while (l <= r) {

i = (l + r) / 2;

if (!(iter->types[i]->name)) break; /* should never happen */

compare = strcmp(name, iter->types[i]->name);

if (compare == 0)

return iter->types[i];

else if (compare < 0)

r = i - 1;

else if (compare > 0)

l = i + 1;

}

iter = iter->next;

} while (iter != end);

return 0;

}

/*

Search for a swig_type_info structure for either a mangled name or a human readable name.

It first searches the mangled names of the types, which is a O(log #types)

If a type is not found it then searches the human readable names, which is O(#types).

We start searching at module start, and finish searching when start == end.

Note: if start == end at the beginning of the function, we go all the way around

the circular list.

*/

SWIGRUNTIME swig_type_info *

SWIG_TypeQueryModule(swig_module_info *start,

swig_module_info *end,

const char *name) {

swig_module_info *iter;

swig_type_info *ret;

int i;

/* STEP 1: Search the name field using binary search */

ret = SWIG_MangledTypeQueryModule(start, end, name);

if (ret) return ret;

/* STEP 2: If the type hasn't been found, do a complete search

of the str field (the human readable name) */

iter = start;

do {

for (i = 0; i < iter->size; ++i) {

if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))

return iter->types[i];

}

iter = iter->next;

} while (iter != end);

/* neither found a match */

return 0;

}

/*

Pack binary data into a string

*/

SWIGRUNTIME char *

SWIG_PackData(char *c, void *ptr, size_t sz) {

static char hex[17] = "0123456789abcdef";

unsigned char *u = (unsigned char *) ptr;

const unsigned char *eu = u + sz;

register unsigned char uu;

for (; u != eu; ++u) {

uu = *u;

*(c++) = hex[(uu & 0xf0) >> 4];

*(c++) = hex[uu & 0xf];

}

return c;

}

/*

Unpack binary data from a string

*/

SWIGRUNTIME const char *

SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

register unsigned char *u = (unsigned char *) ptr;

register const unsigned char *eu = u + sz;

for (; u != eu; ++u) {

register int d = *(c++);

register unsigned char uu = 0;

if ((d >= '0') && (d <= '9'))

uu = ((d - '0') << 4);

else if ((d >= 'a') && (d <= 'f'))

uu = ((d - ('a'-10)) << 4);

else

return (char *) 0;

d = *(c++);

if ((d >= '0') && (d <= '9'))

uu |= (d - '0');

else if ((d >= 'a') && (d <= 'f'))

uu |= (d - ('a'-10));

else

return (char *) 0;

*u = uu;

}

return c;

}

/*

Pack 'void *' into a string buffer.

*/

SWIGRUNTIME char *

SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {

char *r = buff;

if ((2*sizeof(void *) + 2) > bsz) return 0;

*(r++) = '_';

r = SWIG_PackData(r,&ptr,sizeof(void *));

if (strlen(name) + 1 > (bsz - (r - buff))) return 0;

strcpy(r,name);

return buff;

}

SWIGRUNTIME const char *

SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {

if (*c != '_') {

if (strcmp(c,"NULL") == 0) {

*ptr = (void *) 0;

return name;

} else {

return 0;

}

}

return SWIG_UnpackData(++c,ptr,sizeof(void *));

}

SWIGRUNTIME char *

SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {

char *r = buff;

size_t lname = (name ? strlen(name) : 0);

if ((2*sz + 2 + lname) > bsz) return 0;

*(r++) = '_';

r = SWIG_PackData(r,ptr,sz);

if (lname) {

strncpy(r,name,lname+1);

} else {

*r = 0;

}

return buff;

}

SWIGRUNTIME const char *

SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {

if (*c != '_') {

if (strcmp(c,"NULL") == 0) {

memset(ptr,0,sz);

return name;

} else {

return 0;

}

}

return SWIG_UnpackData(++c,ptr,sz);

}

#ifdef __cplusplus

}

#endif

/* -----------------------------------------------------------------------------

* SWIG API. Portion that goes into the runtime

* ----------------------------------------------------------------------------- */

#ifdef __cplusplus

extern "C" {

#endif

/* -----------------------------------------------------------------------------

* for internal method declarations

* ----------------------------------------------------------------------------- */

#ifndef SWIGINTERN

# define SWIGINTERN static SWIGUNUSED

#endif

#ifndef SWIGINTERNSHORT

# define SWIGINTERNSHORT SWIGINTERN SWIGINLINE

#endif

/*

Exception handling in wrappers

*/

#define SWIG_fail goto fail

#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)

#define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)

#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)

#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)

#define SWIG_null_ref(type) SWIG_Python_NullRef(type)

/*

Contract support

*/

#define SWIG_contract_assert(expr, msg) \

if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else

/* -----------------------------------------------------------------------------

* Constant declarations

* ----------------------------------------------------------------------------- */

/* Constant Types */

#define SWIG_PY_INT 1

#define SWIG_PY_FLOAT 2

#define SWIG_PY_STRING 3

#define SWIG_PY_POINTER 4

#define SWIG_PY_BINARY 5

/* Constant information structure */

typedef struct swig_const_info {

int type;

char *name;

long lvalue;

double dvalue;

void *pvalue;

swig_type_info **ptype;

} swig_const_info;

/* -----------------------------------------------------------------------------

* Alloc. memory flags

* ----------------------------------------------------------------------------- */

#define SWIG_OLDOBJ 1

#define SWIG_NEWOBJ SWIG_OLDOBJ + 1

#define SWIG_PYSTR SWIG_NEWOBJ + 1

#ifdef __cplusplus

}

#endif

/***********************************************************************

* pyrun.swg

*

* This file contains the runtime support for Python modules

* and includes code for managing global variables and pointer

* type checking.

*

* Author : David Beazley ([email protected])

************************************************************************/

/* Common SWIG API */

#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)

#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)

#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)

/* Python-specific SWIG API */

#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)

#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)

/* Runtime API */

#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()

#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)

/* -----------------------------------------------------------------------------

* Pointer declarations

* ----------------------------------------------------------------------------- */

/*

Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent

C/C++ pointers in the python side. Very useful for debugging, but

not always safe.

*/

#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)

# define SWIG_COBJECT_TYPES

#endif

/* Flags for pointer conversion */

#define SWIG_POINTER_EXCEPTION 0x1

#define SWIG_POINTER_DISOWN 0x2

/* Add PyOS_snprintf for old Pythons */

#if PY_VERSION_HEX < 0x02020000

#define PyOS_snprintf snprintf

#endif

#ifdef __cplusplus

extern "C" {

#endif

/* -----------------------------------------------------------------------------

* Create a new pointer string

* ----------------------------------------------------------------------------- */

#ifndef SWIG_BUFFER_SIZE

#define SWIG_BUFFER_SIZE 1024

#endif

#if defined(SWIG_COBJECT_TYPES)

#if !defined(SWIG_COBJECT_PYTHON)

/* -----------------------------------------------------------------------------

* Implements a simple Swig Object type, and use it instead of PyCObject

* ----------------------------------------------------------------------------- */

typedef struct {

PyObject_HEAD

void *ptr;

const char *desc;

} PySwigObject;

/* Declarations for objects of type PySwigObject */

SWIGRUNTIME int

PySwigObject_print(PySwigObject *v, FILE *fp, int flags)

{

char result[SWIG_BUFFER_SIZE];

flags = flags;

if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {

fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);

return 0;

} else {

return 1;

}

}

SWIGRUNTIME PyObject *

PySwigObject_repr(PySwigObject *v)

{

char result[SWIG_BUFFER_SIZE];

return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?

PyString_FromFormat("<Swig Object at %s>", result) : 0;

}

SWIGRUNTIME PyObject *

PySwigObject_str(PySwigObject *v)

{

char result[SWIG_BUFFER_SIZE];

return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?

PyString_FromString(result) : 0;

}

SWIGRUNTIME PyObject *

PySwigObject_long(PySwigObject *v)

{

return PyLong_FromUnsignedLong((unsigned long) v->ptr);

}

SWIGRUNTIME PyObject *

PySwigObject_oct(PySwigObject *v)

{

char buf[100];

unsigned long x = (unsigned long)v->ptr;

if (x == 0)

strcpy(buf, "0");

else

PyOS_snprintf(buf, sizeof(buf), "0%lo", x);

return PyString_FromString(buf);

}

SWIGRUNTIME PyObject *

PySwigObject_hex(PySwigObject *v)

{

char buf[100];

PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);

return PyString_FromString(buf);

}

SWIGRUNTIME int

PySwigObject_compare(PySwigObject *v, PySwigObject *w)

{

int c = strcmp(v->desc, w->desc);

if (c) {

return c;

} else {

void *i = v->ptr;

void *j = w->ptr;

return (i < j) ? -1 : (i > j) ? 1 : 0;

}

}

SWIGRUNTIME void

PySwigObject_dealloc(PySwigObject *self)

{

PyObject_DEL(self);

}

SWIGRUNTIME PyTypeObject*

PySwigObject_GetType() {

static char PySwigObject_Type__doc__[] =

"Swig object carries a C/C++ instance pointer";

static PyNumberMethods PySwigObject_as_number = {

(binaryfunc)0, /*nb_add*/

(binaryfunc)0, /*nb_subtract*/

(binaryfunc)0, /*nb_multiply*/

(binaryfunc)0, /*nb_divide*/

(binaryfunc)0, /*nb_remainder*/

(binaryfunc)0, /*nb_divmod*/

(ternaryfunc)0,/*nb_power*/

(unaryfunc)0, /*nb_negative*/

(unaryfunc)0, /*nb_positive*/

(unaryfunc)0, /*nb_absolute*/

(inquiry)0, /*nb_nonzero*/

0, /*nb_invert*/

0, /*nb_lshift*/

0, /*nb_rshift*/

0, /*nb_and*/

0, /*nb_xor*/

0, /*nb_or*/

(coercion)0, /*nb_coerce*/

(unaryfunc)PySwigObject_long, /*nb_int*/

(unaryfunc)PySwigObject_long, /*nb_long*/

(unaryfunc)0, /*nb_float*/

(unaryfunc)PySwigObject_oct, /*nb_oct*/

(unaryfunc)PySwigObject_hex, /*nb_hex*/

#if PY_VERSION_HEX >= 0x02000000

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */

#endif

};

static int type_init = 0;

static PyTypeObject PySwigObject_Type;

if (!type_init) {

PyTypeObject tmp = {

PyObject_HEAD_INIT(&PyType_Type)

0, /*ob_size*/

"PySwigObject", /*tp_name*/

sizeof(PySwigObject), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor)PySwigObject_dealloc, /*tp_dealloc*/

(printfunc)PySwigObject_print, /*tp_print*/

(getattrfunc)0, /*tp_getattr*/

(setattrfunc)0, /*tp_setattr*/

(cmpfunc)PySwigObject_compare, /*tp_compare*/

(reprfunc)PySwigObject_repr, /*tp_repr*/

&PySwigObject_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*/

/* Space for future expansion */

0L,0L,0L,0L,

PySwigObject_Type__doc__, /* Documentation string */

#if PY_VERSION_HEX >= 0x02000000

0, /* tp_traverse */

0, /* tp_clear */

#endif

#if PY_VERSION_HEX >= 0x02010000

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

#endif

#if PY_VERSION_HEX >= 0x02020000

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

#endif

#if PY_VERSION_HEX >= 0x02030000

0, /* tp_del */

#endif

#ifdef COUNT_ALLOCS

0,0,0,0 /* tp_alloc -> tp_next */

#endif

};

PySwigObject_Type = tmp;

type_init = 1;

}

return &PySwigObject_Type;

}

SWIGRUNTIME PyObject *

PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)

{

PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());

if (self == NULL) return NULL;

self->ptr = ptr;

self->desc = desc;

return (PyObject *)self;

}

SWIGRUNTIMEINLINE void *

PySwigObject_AsVoidPtr(PyObject *self)

{

return ((PySwigObject *)self)->ptr;

}

SWIGRUNTIMEINLINE const char *

PySwigObject_GetDesc(PyObject *self)

{

return ((PySwigObject *)self)->desc;

}

SWIGRUNTIMEINLINE int

PySwigObject_Check(PyObject *op) {

return ((op)->ob_type == PySwigObject_GetType())

|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);

}

/* -----------------------------------------------------------------------------

* Implements a simple Swig Packed type, and use it instead of string

* ----------------------------------------------------------------------------- */

typedef struct {

PyObject_HEAD

void *pack;

const char *desc;

size_t size;

} PySwigPacked;

SWIGRUNTIME int

PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)

{

char result[SWIG_BUFFER_SIZE];

flags = flags;

fputs("<Swig Packed ", fp);

if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {

fputs("at ", fp);

fputs(result, fp);

}

fputs(v->desc,fp);

fputs(">", fp);

return 0;

}

SWIGRUNTIME PyObject *

PySwigPacked_repr(PySwigPacked *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->desc);

} else {

return PyString_FromFormat("<Swig Packed %s>", v->desc);

}

}

SWIGRUNTIME PyObject *

PySwigPacked_str(PySwigPacked *v)

{

char result[SWIG_BUFFER_SIZE];

if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){

return PyString_FromFormat("%s%s", result, v->desc);

} else {

return PyString_FromFormat("%s", v->desc);

}

}

SWIGRUNTIME int

PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)

{

int c = strcmp(v->desc, w->desc);

if (c) {

return c;

} else {

size_t i = v->size;

size_t j = w->size;

int s = (i < j) ? -1 : (i > j) ? 1 : 0;

return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);

}

}

SWIGRUNTIME void

PySwigPacked_dealloc(PySwigPacked *self)

{

free(self->pack);

PyObject_DEL(self);

}

SWIGRUNTIME PyTypeObject*

PySwigPacked_GetType() {

static char PySwigPacked_Type__doc__[] =

"Swig object carries a C/C++ instance pointer";

static int type_init = 0;

static PyTypeObject PySwigPacked_Type;

if (!type_init) {

PyTypeObject tmp = {

PyObject_HEAD_INIT(&PyType_Type)

0, /*ob_size*/

"PySwigPacked", /*tp_name*/

sizeof(PySwigPacked), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor)PySwigPacked_dealloc, /*tp_dealloc*/

(printfunc)PySwigPacked_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*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

(hashfunc)0, /*tp_hash*/

(ternaryfunc)0, /*tp_call*/

(reprfunc)PySwigPacked_str, /*tp_str*/

/* Space for future expansion */

0L,0L,0L,0L,

PySwigPacked_Type__doc__, /* Documentation string */

#if PY_VERSION_HEX >= 0x02000000

0, /* tp_traverse */

0, /* tp_clear */

#endif

#if PY_VERSION_HEX >= 0x02010000

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

#endif

#if PY_VERSION_HEX >= 0x02020000

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

#endif

#if PY_VERSION_HEX >= 0x02030000

0, /* tp_del */

#endif

#ifdef COUNT_ALLOCS

0,0,0,0 /* tp_alloc -> tp_next */

#endif

};

PySwigPacked_Type = tmp;

type_init = 1;

}

return &PySwigPacked_Type;

}

SWIGRUNTIME PyObject *

PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)

{

PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());

if (self == NULL) {

return NULL;

} else {

void *pack = malloc(size);

memcpy(pack, ptr, size);

self->pack = pack;

self->desc = desc;

self->size = size;

return (PyObject *) self;

}

}

SWIGRUNTIMEINLINE const char *

PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)

{

PySwigPacked *self = (PySwigPacked *)obj;

if (self->size != size) return 0;

memcpy(ptr, self->pack, size);

return self->desc;

}

SWIGRUNTIMEINLINE const char *

PySwigPacked_GetDesc(PyObject *self)

{

return ((PySwigPacked *)self)->desc;

}

SWIGRUNTIMEINLINE int

PySwigPacked_Check(PyObject *op) {

return ((op)->ob_type == PySwigPacked_GetType())

|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);

}

#else

/* -----------------------------------------------------------------------------

* Use the old Python PyCObject instead of PySwigObject

* ----------------------------------------------------------------------------- */

#define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)

#define PySwigObject_Check(obj) PyCObject_Check(obj)

#define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)

#define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)

#endif

#endif

/* -----------------------------------------------------------------------------

* errors manipulation