18 #pragma clang system_header
22 #ifndef SWIGTEMPLATEDISAMBIGUATOR
23 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
24 # define SWIGTEMPLATEDISAMBIGUATOR template
25 # elif defined(__HP_aCC)
28 # define SWIGTEMPLATEDISAMBIGUATOR template
30 # define SWIGTEMPLATEDISAMBIGUATOR
36 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
37 # define SWIGINLINE inline
45 # if defined(__GNUC__)
46 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
47 # define SWIGUNUSED __attribute__ ((__unused__))
52 # define SWIGUNUSED __attribute__ ((__unused__))
58 #ifndef SWIG_MSC_UNSUPPRESS_4505
59 # if defined(_MSC_VER)
60 # pragma warning(disable : 4505)
64 #ifndef SWIGUNUSEDPARM
66 # define SWIGUNUSEDPARM(p)
68 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
74 # define SWIGINTERN static SWIGUNUSED
78 #ifndef SWIGINTERNINLINE
79 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
83 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
84 # ifndef GCC_HASCLASSVISIBILITY
85 # define GCC_HASCLASSVISIBILITY
90 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91 # if defined(STATIC_LINKED)
94 # define SWIGEXPORT __declspec(dllexport)
97 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108 # define SWIGSTDCALL __stdcall
115 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116 # define _CRT_SECURE_NO_DEPRECATE
120 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121 # define _SCL_SECURE_NO_DEPRECATE
125 #define SWIG_UnknownError -1
126 #define SWIG_IOError -2
127 #define SWIG_RuntimeError -3
128 #define SWIG_IndexError -4
129 #define SWIG_TypeError -5
130 #define SWIG_DivisionByZero -6
131 #define SWIG_OverflowError -7
132 #define SWIG_SyntaxError -8
133 #define SWIG_ValueError -9
134 #define SWIG_SystemError -10
135 #define SWIG_AttributeError -11
136 #define SWIG_MemoryError -12
137 #define SWIG_NullReferenceError -13
141 #define SWIG_UnknownError -1
142 #define SWIG_IOError -2
143 #define SWIG_RuntimeError -3
144 #define SWIG_IndexError -4
145 #define SWIG_TypeError -5
146 #define SWIG_DivisionByZero -6
147 #define SWIG_OverflowError -7
148 #define SWIG_SyntaxError -8
149 #define SWIG_ValueError -9
150 #define SWIG_SystemError -10
151 #define SWIG_AttributeError -11
152 #define SWIG_MemoryError -12
153 #define SWIG_NullReferenceError -13
165 #define SWIG_RUNTIME_VERSION "4"
168 #ifdef SWIG_TYPE_TABLE
169 # define SWIG_QUOTE_STRING(x) #x
170 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
171 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
173 # define SWIG_TYPE_TABLE_NAME
186 # define SWIGRUNTIME SWIGINTERN
189 #ifndef SWIGRUNTIMEINLINE
190 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
194 #ifndef SWIG_BUFFER_SIZE
195 # define SWIG_BUFFER_SIZE 1024
199 #define SWIG_POINTER_DISOWN 0x1
200 #define SWIG_CAST_NEW_MEMORY 0x2
203 #define SWIG_POINTER_OWN 0x1
286 #define SWIG_ERROR (-1)
287 #define SWIG_IsOK(r) (r >= 0)
288 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
291 #define SWIG_CASTRANKLIMIT (1 << 8)
293 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
295 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
297 #define SWIG_BADOBJ (SWIG_ERROR)
298 #define SWIG_OLDOBJ (SWIG_OK)
299 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
300 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
302 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
303 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
304 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
305 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
306 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
307 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
310 #if defined(SWIG_CASTRANK_MODE)
311 # ifndef SWIG_TypeRank
312 # define SWIG_TypeRank unsigned long
314 # ifndef SWIG_MAXCASTRANK
315 # define SWIG_MAXCASTRANK (2)
317 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
318 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
319 SWIGINTERNINLINE
int SWIG_AddCast(
int r) {
320 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
322 SWIGINTERNINLINE
int SWIG_CheckState(
int r) {
323 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
326 # define SWIG_AddCast
327 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
337 typedef void *(*swig_converter_func)(
void *,
int *);
338 typedef struct swig_type_info *(*swig_dycast_func)(
void **);
341 typedef struct swig_type_info {
344 swig_dycast_func dcast;
345 struct swig_cast_info *cast;
351 typedef struct swig_cast_info {
352 swig_type_info *type;
353 swig_converter_func converter;
354 struct swig_cast_info *next;
355 struct swig_cast_info *prev;
361 typedef struct swig_module_info {
362 swig_type_info **types;
364 struct swig_module_info *next;
365 swig_type_info **type_initial;
366 swig_cast_info **cast_initial;
378 SWIG_TypeNameComp(
const char *f1,
const char *l1,
379 const char *f2,
const char *l2) {
380 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
381 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
382 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
383 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
385 return (
int)((l1 - f1) - (l2 - f2));
393 SWIG_TypeEquiv(
const char *nb,
const char *tb) {
395 const char* te = tb + strlen(tb);
397 while (!equiv && *ne) {
398 for (nb = ne; *ne; ++ne) {
399 if (*ne ==
'|')
break;
401 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
412 SWIG_TypeCompare(
const char *nb,
const char *tb) {
414 const char* te = tb + strlen(tb);
416 while (!equiv && *ne) {
417 for (nb = ne; *ne; ++ne) {
418 if (*ne ==
'|')
break;
420 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(
const char *c, swig_type_info *ty) {
433 swig_cast_info *iter = ty->cast;
435 if (strcmp(iter->type->name, c) == 0) {
436 if (iter == ty->cast)
439 iter->prev->next = iter->next;
441 iter->next->prev = iter->prev;
442 iter->next = ty->cast;
444 if (ty->cast) ty->cast->prev = iter;
457 SWIGRUNTIME swig_cast_info *
458 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
460 swig_cast_info *iter = ty->cast;
462 if (iter->type == from) {
463 if (iter == ty->cast)
466 iter->prev->next = iter->next;
468 iter->next->prev = iter->prev;
469 iter->next = ty->cast;
471 if (ty->cast) ty->cast->prev = iter;
484 SWIGRUNTIMEINLINE
void *
485 SWIG_TypeCast(swig_cast_info *ty,
void *ptr,
int *newmemory) {
486 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
492 SWIGRUNTIME swig_type_info *
493 SWIG_TypeDynamicCast(swig_type_info *ty,
void **ptr) {
494 swig_type_info *lastty = ty;
495 if (!ty || !ty->dcast)
return ty;
496 while (ty && (ty->dcast)) {
497 ty = (*ty->dcast)(ptr);
506 SWIGRUNTIMEINLINE
const char *
507 SWIG_TypeName(
const swig_type_info *ty) {
515 SWIGRUNTIME
const char *
516 SWIG_TypePrettyName(
const swig_type_info *type) {
521 if (!type)
return nullptr;
522 if (type->str !=
nullptr) {
523 const char *last_name = type->str;
525 for (s = type->str; *s; s++)
526 if (*s ==
'|') last_name = s+1;
537 SWIG_TypeClientData(swig_type_info *ti,
void *clientdata) {
538 swig_cast_info *cast = ti->cast;
540 ti->clientdata = clientdata;
543 if (!cast->converter) {
544 swig_type_info *tc = cast->type;
545 if (!tc->clientdata) {
546 SWIG_TypeClientData(tc, clientdata);
553 SWIG_TypeNewClientData(swig_type_info *ti,
void *clientdata) {
554 SWIG_TypeClientData(ti, clientdata);
566 SWIGRUNTIME swig_type_info *
567 SWIG_MangledTypeQueryModule(swig_module_info *start,
568 swig_module_info *end,
570 swig_module_info *iter = start;
573 register size_t l = 0;
574 register size_t r = iter->size - 1;
577 register size_t i = (l + r) >> 1;
578 const char *iname = iter->types[i]->name;
580 register int compare = strcmp(name, iname);
582 return iter->types[i];
583 }
else if (compare < 0) {
589 }
else if (compare > 0) {
598 }
while (iter != end);
611 SWIGRUNTIME swig_type_info *
612 SWIG_TypeQueryModule(swig_module_info *start,
613 swig_module_info *end,
616 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
622 swig_module_info *iter = start;
624 register size_t i = 0;
625 for (; i < iter->size; ++i) {
626 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
627 return iter->types[i];
630 }
while (iter != end);
641 SWIG_PackData(
char *c,
void *ptr,
size_t sz) {
642 static const char hex[17] =
"0123456789abcdef";
643 register const unsigned char *
u = (
unsigned char *) ptr;
644 register const unsigned char *eu = u + sz;
645 for (; u != eu; ++u) {
646 register unsigned char uu = *u;
647 *(c++) = hex[(uu & 0xf0) >> 4];
648 *(c++) = hex[uu & 0xf];
656 SWIGRUNTIME
const char *
657 SWIG_UnpackData(
const char *c,
void *ptr,
size_t sz) {
658 register unsigned char *u = (
unsigned char *) ptr;
659 register const unsigned char *eu = u + sz;
660 for (; u != eu; ++u) {
661 register char d = *(c++);
662 register unsigned char uu;
663 if ((d >=
'0') && (d <=
'9'))
664 uu = ((d -
'0') << 4);
665 else if ((d >=
'a') && (d <=
'f'))
666 uu = ((d - (
'a'-10)) << 4);
670 if ((d >=
'0') && (d <=
'9'))
672 else if ((d >=
'a') && (d <=
'f'))
673 uu |= (d - (
'a'-10));
685 SWIG_PackVoidPtr(
char *buff,
void *ptr,
const char *name,
size_t bsz) {
687 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
689 r = SWIG_PackData(r,&ptr,
sizeof(
void *));
690 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
695 SWIGRUNTIME
const char *
696 SWIG_UnpackVoidPtr(
const char *c,
void **ptr,
const char *name) {
698 if (strcmp(c,
"nullptr") == 0) {
705 return SWIG_UnpackData(++c,ptr,
sizeof(
void *));
709 SWIG_PackDataName(
char *buff,
void *ptr,
size_t sz,
const char *name,
size_t bsz) {
711 size_t lname = (name ? strlen(name) : 0);
712 if ((2*sz + 2 + lname) > bsz)
return 0;
714 r = SWIG_PackData(r,ptr,sz);
716 strncpy(r,name,lname+1);
723 SWIGRUNTIME
const char *
724 SWIG_UnpackDataName(
const char *c,
void *ptr,
size_t sz,
const char *name) {
726 if (strcmp(c,
"nullptr") == 0) {
733 return SWIG_UnpackData(++c,ptr,sz);
740 #if PY_VERSION_HEX >= 0x03000000
742 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
743 #define PyInt_Check(x) PyLong_Check(x)
744 #define PyInt_AsLong(x) PyLong_AsLong(x)
745 #define PyInt_FromLong(x) PyLong_FromLong(x)
746 #define PyString_Check(name) PyBytes_Check(name)
747 #define PyString_FromString(x) PyUnicode_FromString(x)
748 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
749 #define PyString_AsString(str) PyBytes_AsString(str)
750 #define PyString_Size(str) PyBytes_Size(str)
751 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
752 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
753 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
754 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
759 # define Py_TYPE(op) ((op)->ob_type)
764 #if PY_VERSION_HEX >= 0x03000000
765 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
767 # define SWIG_Python_str_FromFormat PyString_FromFormat
775 SWIG_Python_str_AsChar(PyObject *str)
777 #if PY_VERSION_HEX >= 0x03000000
781 str = PyUnicode_AsUTF8String(str);
782 PyBytes_AsStringAndSize(str, &cstr, &len);
783 newstr = (
char *) malloc(len+1);
784 memcpy(newstr, cstr, len+1);
788 return PyString_AsString(str);
792 #if PY_VERSION_HEX >= 0x03000000
793 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
795 # define SWIG_Python_str_DelForPy3(x)
800 SWIG_Python_str_FromChar(
const char *c)
802 #if PY_VERSION_HEX >= 0x03000000
803 return PyUnicode_FromString(c);
805 return PyString_FromString(c);
810 #if PY_VERSION_HEX < 0x02020000
811 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
812 # define PyOS_snprintf _snprintf
814 # define PyOS_snprintf snprintf
819 #if PY_VERSION_HEX < 0x02020000
821 #ifndef SWIG_PYBUFFER_SIZE
822 # define SWIG_PYBUFFER_SIZE 1024
826 PyString_FromFormat(
const char *fmt, ...) {
828 char buf[SWIG_PYBUFFER_SIZE * 2];
831 res = vsnprintf(buf,
sizeof(buf), fmt, ap);
833 return (res < 0 || res >= (
int)
sizeof(buf)) ? 0 : PyString_FromString(buf);
838 #if PY_VERSION_HEX < 0x01060000
839 # define PyObject_Del(op) PyMem_DEL((op))
842 # define PyObject_DEL PyObject_Del
846 #if PY_VERSION_HEX < 0x02020000
847 # ifndef PyExc_StopIteration
848 # define PyExc_StopIteration PyExc_RuntimeError
850 # ifndef PyObject_GenericGetAttr
851 # define PyObject_GenericGetAttr 0
856 #if PY_VERSION_HEX < 0x02010000
857 # ifndef Py_NotImplemented
858 # define Py_NotImplemented PyExc_RuntimeError
863 #if PY_VERSION_HEX < 0x02010000
864 # ifndef PyString_AsStringAndSize
865 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
870 #if PY_VERSION_HEX < 0x02000000
871 # ifndef PySequence_Size
872 # define PySequence_Size PySequence_Length
877 #if PY_VERSION_HEX < 0x02030000
879 PyObject *PyBool_FromLong(
long ok)
881 PyObject *result = ok ? Py_True : Py_False;
890 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
891 typedef int Py_ssize_t;
892 # define PY_SSIZE_T_MAX INT_MAX
893 # define PY_SSIZE_T_MIN INT_MIN
894 typedef inquiry lenfunc;
895 typedef intargfunc ssizeargfunc;
896 typedef intintargfunc ssizessizeargfunc;
897 typedef intobjargproc ssizeobjargproc;
898 typedef intintobjargproc ssizessizeobjargproc;
899 typedef getreadbufferproc readbufferproc;
900 typedef getwritebufferproc writebufferproc;
901 typedef getsegcountproc segcountproc;
902 typedef getcharbufferproc charbufferproc;
903 static long PyNumber_AsSsize_t (PyObject *x,
void *SWIGUNUSEDPARM(exc))
906 PyObject *i = PyNumber_Int(x);
908 result = PyInt_AsLong(i);
915 #if PY_VERSION_HEX < 0x02040000
916 #define Py_VISIT(op) \
919 int vret = visit((op), arg); \
926 #if PY_VERSION_HEX < 0x02030000
929 PyNumberMethods as_number;
930 PyMappingMethods as_mapping;
931 PySequenceMethods as_sequence;
932 PyBufferProcs as_buffer;
933 PyObject *name, *slots;
937 #if PY_VERSION_HEX < 0x02030000
938 typedef destructor freefunc;
941 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
942 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
943 (PY_MAJOR_VERSION > 3))
944 # define SWIGPY_USE_CAPSULE
945 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
948 #if PY_VERSION_HEX < 0x03020000
949 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
950 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
956 SWIGRUNTIME PyObject*
957 SWIG_Python_ErrorType(
int code) {
960 case SWIG_MemoryError:
961 type = PyExc_MemoryError;
964 type = PyExc_IOError;
966 case SWIG_RuntimeError:
967 type = PyExc_RuntimeError;
969 case SWIG_IndexError:
970 type = PyExc_IndexError;
973 type = PyExc_TypeError;
975 case SWIG_DivisionByZero:
976 type = PyExc_ZeroDivisionError;
978 case SWIG_OverflowError:
979 type = PyExc_OverflowError;
981 case SWIG_SyntaxError:
982 type = PyExc_SyntaxError;
984 case SWIG_ValueError:
985 type = PyExc_ValueError;
987 case SWIG_SystemError:
988 type = PyExc_SystemError;
990 case SWIG_AttributeError:
991 type = PyExc_AttributeError;
994 type = PyExc_RuntimeError;
1001 SWIG_Python_AddErrorMsg(
const char* mesg)
1004 PyObject *value = 0;
1005 PyObject *traceback = 0;
1007 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1010 PyObject *old_str = PyObject_Str(value);
1014 PyErr_Format(type,
"%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1015 SWIG_Python_str_DelForPy3(tmp);
1019 PyErr_SetString(PyExc_RuntimeError, mesg);
1022 #if defined(SWIG_PYTHON_NO_THREADS)
1023 # if defined(SWIG_PYTHON_THREADS)
1024 # undef SWIG_PYTHON_THREADS
1027 #if defined(SWIG_PYTHON_THREADS)
1028 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1029 # if (PY_VERSION_HEX >= 0x02030000)
1030 # define SWIG_PYTHON_USE_GIL
1033 # if defined(SWIG_PYTHON_USE_GIL)
1034 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1035 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1038 class SWIG_Python_Thread_Block {
1040 PyGILState_STATE state;
1042 void end() {
if (status) { PyGILState_Release(state); status =
false;} }
1043 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1044 ~SWIG_Python_Thread_Block() { end(); }
1046 class SWIG_Python_Thread_Allow {
1048 PyThreadState *save;
1050 void end() {
if (status) { PyEval_RestoreThread(save); status =
false; }}
1051 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1052 ~SWIG_Python_Thread_Allow() { end(); }
1054 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1055 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1056 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1057 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1059 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1060 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1061 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1062 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1065 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1066 # define SWIG_PYTHON_INITIALIZE_THREADS
1068 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1069 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1071 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1072 # define SWIG_PYTHON_THREAD_END_BLOCK
1074 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1075 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1077 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1078 # define SWIG_PYTHON_THREAD_END_ALLOW
1082 # define SWIG_PYTHON_INITIALIZE_THREADS
1083 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1084 # define SWIG_PYTHON_THREAD_END_BLOCK
1085 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1086 # define SWIG_PYTHON_THREAD_END_ALLOW
1101 #define SWIG_PY_POINTER 4
1102 #define SWIG_PY_BINARY 5
1105 typedef struct swig_const_info {
1111 swig_type_info **ptype;
1119 #if PY_VERSION_HEX >= 0x03000000
1120 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(
self), PyObject *func)
1122 return PyInstanceMethod_New(func);
1125 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(
self), PyObject *SWIGUNUSEDPARM(func))
1147 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1148 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1149 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1151 #ifdef SWIGPYTHON_BUILTIN
1152 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1154 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(nullptr, ptr, type, flags)
1157 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(nullptr, ptr, type, flags)
1159 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1160 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1161 #define swig_owntype int
1164 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1165 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1168 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1169 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1172 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1173 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(nullptr, ptr, type, 0)
1176 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1177 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1182 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1183 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1184 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1186 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1187 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1188 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1189 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1190 #define SWIG_fail goto fail
1198 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1199 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1200 PyErr_SetObject(errtype, obj);
1202 SWIG_PYTHON_THREAD_END_BLOCK;
1206 SWIG_Python_SetErrorMsg(PyObject *errtype,
const char *msg) {
1207 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1208 PyErr_SetString(errtype, (
char *) msg);
1209 SWIG_PYTHON_THREAD_END_BLOCK;
1212 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1216 #if defined(SWIGPYTHON_BUILTIN)
1219 SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1220 PyObject *s = PyString_InternFromString(key);
1221 PyList_Append(seq, s);
1226 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface,
const char *name, PyObject *obj) {
1227 PyDict_SetItemString(d, (
char *)name, obj);
1229 if (public_interface)
1230 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1236 SWIG_Python_SetConstant(PyObject *d,
const char *name, PyObject *obj) {
1237 PyDict_SetItemString(d, (
char *)name, obj);
1245 SWIGINTERN PyObject*
1246 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1247 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1250 }
else if (result == Py_None) {
1254 if (!PyList_Check(result)) {
1255 PyObject *o2 = result;
1256 result = PyList_New(1);
1257 PyList_SetItem(result, 0, o2);
1259 PyList_Append(result,obj);
1268 }
else if (result == Py_None) {
1272 if (!PyTuple_Check(result)) {
1274 result = PyTuple_New(1);
1275 PyTuple_SET_ITEM(result, 0, o2);
1277 o3 = PyTuple_New(1);
1278 PyTuple_SET_ITEM(o3, 0, obj);
1280 result = PySequence_Concat(o2, o3);
1291 SWIG_Python_UnpackTuple(PyObject *args,
const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1297 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1298 name, (min == max ?
"" :
"at least "), (
int)min);
1302 if (!PyTuple_Check(args)) {
1303 if (min <= 1 && max >= 1) {
1306 for (i = 1; i < max; ++i) {
1311 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1314 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1316 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1317 name, (min == max ?
"" :
"at least "), (
int)min, (
int)l);
1319 }
else if (l > max) {
1320 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1321 name, (min == max ?
"" :
"at most "), (
int)max, (
int)l);
1325 for (i = 0; i < l; ++i) {
1326 objs[i] = PyTuple_GET_ITEM(args, i);
1328 for (; l < max; ++l) {
1337 #if PY_VERSION_HEX >= 0x02020000
1338 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, nullptr);
1340 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1348 #define SWIG_STATIC_POINTER(var) var
1350 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1358 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1359 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1361 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1363 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1364 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1371 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1372 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1373 # ifndef SWIG_PYTHON_BUILD_NONE
1374 # define SWIG_PYTHON_BUILD_NONE
1379 #ifdef SWIG_PYTHON_BUILD_NONE
1382 # define Py_None SWIG_Py_None()
1384 SWIGRUNTIMEINLINE PyObject *
1387 PyObject *none = Py_BuildValue((
char*)
"");
1391 SWIGRUNTIME PyObject *
1394 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1401 SWIGRUNTIMEINLINE PyObject *
1404 PyObject *none = Py_None;
1418 PyTypeObject *pytype;
1421 SWIGRUNTIMEINLINE
int
1422 SWIG_Python_CheckImplicit(swig_type_info *ty)
1424 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1425 return data ? data->implicitconv : 0;
1428 SWIGRUNTIMEINLINE PyObject *
1429 SWIG_Python_ExceptionType(swig_type_info *desc) {
1430 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1431 PyObject *klass = data ? data->klass : 0;
1432 return (klass ? klass : PyExc_RuntimeError);
1436 SWIGRUNTIME SwigPyClientData *
1437 SwigPyClientData_New(PyObject* obj)
1442 SwigPyClientData *data = (SwigPyClientData *)malloc(
sizeof(SwigPyClientData));
1445 Py_INCREF(data->klass);
1447 if (PyClass_Check(obj)) {
1449 data->newargs = obj;
1452 #if (PY_VERSION_HEX < 0x02020000)
1455 data->newraw = PyObject_GetAttrString(data->klass, (
char *)
"__new__");
1458 Py_INCREF(data->newraw);
1459 data->newargs = PyTuple_New(1);
1460 PyTuple_SetItem(data->newargs, 0, obj);
1462 data->newargs = obj;
1464 Py_INCREF(data->newargs);
1467 data->destroy = PyObject_GetAttrString(data->klass, (
char *)
"__swig_destroy__");
1468 if (PyErr_Occurred()) {
1472 if (data->destroy) {
1474 Py_INCREF(data->destroy);
1475 flags = PyCFunction_GET_FLAGS(data->destroy);
1477 data->delargs = !(flags & (METH_O));
1484 data->implicitconv = 0;
1491 SwigPyClientData_Del(SwigPyClientData *data) {
1492 Py_XDECREF(data->newraw);
1493 Py_XDECREF(data->newargs);
1494 Py_XDECREF(data->destroy);
1505 #ifdef SWIGPYTHON_BUILTIN
1510 SWIGRUNTIME PyObject *
1511 SwigPyObject_long(SwigPyObject *v)
1513 return PyLong_FromVoidPtr(v->ptr);
1516 SWIGRUNTIME PyObject *
1517 SwigPyObject_format(
const char* fmt, SwigPyObject *v)
1519 PyObject *res =
nullptr;
1520 PyObject *args = PyTuple_New(1);
1522 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1523 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1525 #if PY_VERSION_HEX >= 0x03000000
1526 res = PyUnicode_Format(ofmt,args);
1528 res = PyString_Format(ofmt,args);
1538 SWIGRUNTIME PyObject *
1539 SwigPyObject_oct(SwigPyObject *v)
1541 return SwigPyObject_format(
"%o",v);
1544 SWIGRUNTIME PyObject *
1545 SwigPyObject_hex(SwigPyObject *v)
1547 return SwigPyObject_format(
"%x",v);
1550 SWIGRUNTIME PyObject *
1552 SwigPyObject_repr(SwigPyObject *v)
1554 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1557 const char *name = SWIG_TypePrettyName(v->ty);
1558 PyObject *repr = SWIG_Python_str_FromFormat(
"<Swig Object of type '%s' at %p>", name, (
void *)v);
1561 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1563 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1565 # if PY_VERSION_HEX >= 0x03000000
1566 PyObject *joined = PyUnicode_Concat(repr, nrep);
1571 PyString_ConcatAndDel(&repr,nrep);
1578 SwigPyObject_print(SwigPyObject *v, FILE *fp,
int SWIGUNUSEDPARM(flags))
1582 PyObject *repr = SwigPyObject_repr(v);
1584 PyObject *repr = SwigPyObject_repr(v,
nullptr);
1587 str = SWIG_Python_str_AsChar(repr);
1589 SWIG_Python_str_DelForPy3(str);
1597 SWIGRUNTIME PyObject *
1598 SwigPyObject_str(SwigPyObject *v)
1600 char result[SWIG_BUFFER_SIZE];
1601 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name,
sizeof(result)) ?
1602 SWIG_Python_str_FromChar(result) : 0;
1606 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1610 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1614 SWIGRUNTIME PyObject*
1615 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w,
int op)
1618 if( op != Py_EQ && op != Py_NE ) {
1619 Py_INCREF(Py_NotImplemented);
1620 return Py_NotImplemented;
1622 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1627 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(
void);
1629 #ifdef SWIGPYTHON_BUILTIN
1630 static swig_type_info *SwigPyObject_stype = 0;
1631 SWIGRUNTIME PyTypeObject*
1632 SwigPyObject_type(
void) {
1633 SwigPyClientData *cd;
1634 assert(SwigPyObject_stype);
1635 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1641 SWIGRUNTIME PyTypeObject*
1642 SwigPyObject_type(
void) {
1643 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1648 SWIGRUNTIMEINLINE
int
1649 SwigPyObject_Check(PyObject *op) {
1650 #ifdef SWIGPYTHON_BUILTIN
1651 PyTypeObject *target_tp = SwigPyObject_type();
1652 if (PyType_IsSubtype(op->ob_type, target_tp))
1654 return (strcmp(op->ob_type->tp_name,
"SwigPyObject") == 0);
1656 return (Py_TYPE(op) == SwigPyObject_type())
1657 || (strcmp(Py_TYPE(op)->tp_name,
"SwigPyObject") == 0);
1661 SWIGRUNTIME PyObject *
1662 SwigPyObject_New(
void *ptr, swig_type_info *ty,
int own);
1665 SwigPyObject_dealloc(PyObject *v)
1667 SwigPyObject *sobj = (SwigPyObject *) v;
1668 PyObject *next = sobj->next;
1669 if (sobj->own == SWIG_POINTER_OWN) {
1670 swig_type_info *ty = sobj->ty;
1671 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1672 PyObject *destroy = data ? data->destroy : 0;
1676 if (data->delargs) {
1678 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1679 res = SWIG_Python_CallFunctor(destroy, tmp);
1682 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1683 PyObject *mself = PyCFunction_GET_SELF(destroy);
1684 res = ((*meth)(mself, v));
1688 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1690 const char *name = SWIG_TypePrettyName(ty);
1691 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1699 SWIGRUNTIME PyObject*
1700 SwigPyObject_append(PyObject* v, PyObject* next)
1702 SwigPyObject *sobj = (SwigPyObject *) v;
1705 if (!PyArg_ParseTuple(next,(
char *)
"O:append", &tmp))
return nullptr;
1708 if (!SwigPyObject_Check(next)) {
1713 return SWIG_Py_Void();
1716 SWIGRUNTIME PyObject*
1718 SwigPyObject_next(PyObject* v)
1720 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1723 SwigPyObject *sobj = (SwigPyObject *) v;
1725 Py_INCREF(sobj->next);
1728 return SWIG_Py_Void();
1732 SWIGINTERN PyObject*
1734 SwigPyObject_disown(PyObject *v)
1736 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1739 SwigPyObject *sobj = (SwigPyObject *)v;
1741 return SWIG_Py_Void();
1744 SWIGINTERN PyObject*
1746 SwigPyObject_acquire(PyObject *v)
1748 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1751 SwigPyObject *sobj = (SwigPyObject *)v;
1752 sobj->own = SWIG_POINTER_OWN;
1753 return SWIG_Py_Void();
1756 SWIGINTERN PyObject*
1757 SwigPyObject_own(PyObject *v, PyObject *args)
1760 #if (PY_VERSION_HEX < 0x02020000)
1761 if (!PyArg_ParseTuple(args,(
char *)
"|O:own",&val))
1763 if (!PyArg_UnpackTuple(args, (
char *)
"own", 0, 1, &val))
1770 SwigPyObject *sobj = (SwigPyObject *)v;
1771 PyObject *obj = PyBool_FromLong(sobj->own);
1774 if (PyObject_IsTrue(val)) {
1775 SwigPyObject_acquire(v);
1777 SwigPyObject_disown(v);
1780 if (PyObject_IsTrue(val)) {
1781 SwigPyObject_acquire(v,args);
1783 SwigPyObject_disown(v,args);
1793 swigobject_methods[] = {
1794 {(
char *)
"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (
char *)
"releases ownership of the pointer"},
1795 {(
char *)
"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (
char *)
"aquires ownership of the pointer"},
1796 {(
char *)
"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1797 {(
char *)
"append", (PyCFunction)SwigPyObject_append, METH_O, (
char *)
"appends another 'this' object"},
1798 {(
char *)
"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (
char *)
"returns the next 'this' object"},
1799 {(
char *)
"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (
char *)
"returns object representation"},
1804 swigobject_methods[] = {
1805 {(
char *)
"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (
char *)
"releases ownership of the pointer"},
1806 {(
char *)
"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (
char *)
"aquires ownership of the pointer"},
1807 {(
char *)
"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1808 {(
char *)
"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (
char *)
"appends another 'this' object"},
1809 {(
char *)
"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (
char *)
"returns the next 'this' object"},
1810 {(
char *)
"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (
char *)
"returns object representation"},
1815 #if PY_VERSION_HEX < 0x02020000
1816 SWIGINTERN PyObject *
1817 SwigPyObject_getattr(SwigPyObject *sobj,
char *name)
1819 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1823 SWIGRUNTIME PyTypeObject*
1824 SwigPyObject_TypeOnce(
void) {
1825 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
1827 static PyNumberMethods SwigPyObject_as_number = {
1832 #
if PY_VERSION_HEX < 0x03000000
1848 #
if PY_VERSION_HEX < 0x03000000
1851 (unaryfunc)SwigPyObject_long,
1852 #if PY_VERSION_HEX < 0x03000000
1853 (unaryfunc)SwigPyObject_long,
1858 #if PY_VERSION_HEX < 0x03000000
1859 (unaryfunc)SwigPyObject_oct,
1860 (unaryfunc)SwigPyObject_hex,
1862 #if PY_VERSION_HEX >= 0x03000000
1863 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1864 #elif PY_VERSION_HEX >= 0x02050000
1865 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1866 #elif PY_VERSION_HEX >= 0x02020000
1867 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1868 #elif PY_VERSION_HEX >= 0x02000000
1869 0,0,0,0,0,0,0,0,0,0,0
1873 static PyTypeObject swigpyobject_type;
1874 static int type_init = 0;
1876 const PyTypeObject tmp = {
1878 #if PY_VERSION_HEX >= 0x03000000
1879 PyVarObject_HEAD_INIT(
nullptr, 0)
1881 PyObject_HEAD_INIT(
nullptr)
1884 (
char *)
"SwigPyObject",
1885 sizeof(SwigPyObject),
1887 (destructor)SwigPyObject_dealloc,
1888 (printfunc)SwigPyObject_print,
1889 #if PY_VERSION_HEX < 0x02020000
1890 (getattrfunc)SwigPyObject_getattr,
1895 #
if PY_VERSION_HEX >= 0x03000000
1898 (cmpfunc)SwigPyObject_compare,
1900 (reprfunc)SwigPyObject_repr,
1901 &SwigPyObject_as_number,
1906 (reprfunc)SwigPyObject_str,
1907 PyObject_GenericGetAttr,
1914 (richcmpfunc)SwigPyObject_richcompare,
1916 #
if PY_VERSION_HEX >= 0x02020000
1938 #
if PY_VERSION_HEX >= 0x02030000
1941 #
if PY_VERSION_HEX >= 0x02060000
1948 swigpyobject_type = tmp;
1950 #if PY_VERSION_HEX < 0x02020000
1951 swigpyobject_type.ob_type = &PyType_Type;
1953 if (PyType_Ready(&swigpyobject_type) < 0)
1957 return &swigpyobject_type;
1960 SWIGRUNTIME PyObject *
1961 SwigPyObject_New(
void *ptr, swig_type_info *ty,
int own)
1963 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1970 return (PyObject *)sobj;
1985 SwigPyPacked_print(SwigPyPacked *v, FILE *fp,
int SWIGUNUSEDPARM(flags))
1987 char result[SWIG_BUFFER_SIZE];
1988 fputs(
"<Swig Packed ", fp);
1989 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))) {
1993 fputs(v->ty->name,fp);
1998 SWIGRUNTIME PyObject *
1999 SwigPyPacked_repr(SwigPyPacked *v)
2001 char result[SWIG_BUFFER_SIZE];
2002 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))) {
2003 return SWIG_Python_str_FromFormat(
"<Swig Packed at %s%s>", result, v->ty->name);
2005 return SWIG_Python_str_FromFormat(
"<Swig Packed %s>", v->ty->name);
2009 SWIGRUNTIME PyObject *
2010 SwigPyPacked_str(SwigPyPacked *v)
2012 char result[SWIG_BUFFER_SIZE];
2013 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))){
2014 return SWIG_Python_str_FromFormat(
"%s%s", result, v->ty->name);
2016 return SWIG_Python_str_FromChar(v->ty->name);
2021 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2025 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2026 return s ? s : strncmp((
char *)v->pack, (
char *)w->pack, 2*v->size);
2029 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(
void);
2031 SWIGRUNTIME PyTypeObject*
2032 SwigPyPacked_type(
void) {
2033 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2037 SWIGRUNTIMEINLINE
int
2038 SwigPyPacked_Check(PyObject *op) {
2039 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2040 || (strcmp((op)->ob_type->tp_name,
"SwigPyPacked") == 0);
2044 SwigPyPacked_dealloc(PyObject *v)
2046 if (SwigPyPacked_Check(v)) {
2047 SwigPyPacked *sobj = (SwigPyPacked *) v;
2053 SWIGRUNTIME PyTypeObject*
2054 SwigPyPacked_TypeOnce(
void) {
2055 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2056 static PyTypeObject swigpypacked_type;
2057 static int type_init = 0;
2059 const PyTypeObject tmp = {
2061 #if PY_VERSION_HEX>=0x03000000
2062 PyVarObject_HEAD_INIT(
nullptr, 0)
2064 PyObject_HEAD_INIT(
nullptr)
2067 (
char *)
"SwigPyPacked",
2068 sizeof(SwigPyPacked),
2070 (destructor)SwigPyPacked_dealloc,
2071 (printfunc)SwigPyPacked_print,
2074 #if PY_VERSION_HEX>=0x03000000
2077 (cmpfunc)SwigPyPacked_compare,
2079 (reprfunc)SwigPyPacked_repr,
2085 (reprfunc)SwigPyPacked_str,
2086 PyObject_GenericGetAttr,
2095 #
if PY_VERSION_HEX >= 0x02020000
2117 #
if PY_VERSION_HEX >= 0x02030000
2120 #
if PY_VERSION_HEX >= 0x02060000
2127 swigpypacked_type = tmp;
2129 #if PY_VERSION_HEX < 0x02020000
2130 swigpypacked_type.ob_type = &PyType_Type;
2132 if (PyType_Ready(&swigpypacked_type) < 0)
2136 return &swigpypacked_type;
2139 SWIGRUNTIME PyObject *
2140 SwigPyPacked_New(
void *ptr,
size_t size, swig_type_info *ty)
2142 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2144 void *pack = malloc(size);
2146 memcpy(pack, ptr, size);
2151 PyObject_DEL((PyObject *) sobj);
2155 return (PyObject *) sobj;
2158 SWIGRUNTIME swig_type_info *
2159 SwigPyPacked_UnpackData(PyObject *obj,
void *ptr,
size_t size)
2161 if (SwigPyPacked_Check(obj)) {
2162 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2163 if (sobj->size != size)
return 0;
2164 memcpy(ptr, sobj->pack, size);
2175 SWIGRUNTIMEINLINE PyObject *
2178 return SWIG_Python_str_FromChar(
"this");
2181 static PyObject *swig_this =
nullptr;
2183 SWIGRUNTIME PyObject *
2186 if (swig_this ==
nullptr)
2187 swig_this = _SWIG_This();
2194 #if PY_VERSION_HEX>=0x03000000
2195 #define SWIG_PYTHON_SLOW_GETSET_THIS
2198 SWIGRUNTIME SwigPyObject *
2199 SWIG_Python_GetSwigThis(PyObject *pyobj)
2203 if (SwigPyObject_Check(pyobj))
2204 return (SwigPyObject *) pyobj;
2206 #ifdef SWIGPYTHON_BUILTIN
2208 # ifdef PyWeakref_CheckProxy
2209 if (PyWeakref_CheckProxy(pyobj)) {
2210 pyobj = PyWeakref_GET_OBJECT(pyobj);
2211 if (pyobj && SwigPyObject_Check(pyobj))
2212 return (SwigPyObject*) pyobj;
2220 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2221 if (PyInstance_Check(pyobj)) {
2222 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2224 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2225 if (dictptr !=
nullptr) {
2226 PyObject *dict = *dictptr;
2227 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2229 #ifdef PyWeakref_CheckProxy
2230 if (PyWeakref_CheckProxy(pyobj)) {
2231 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2232 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2235 obj = PyObject_GetAttr(pyobj,SWIG_This());
2239 if (PyErr_Occurred()) PyErr_Clear();
2245 obj = PyObject_GetAttr(pyobj,SWIG_This());
2249 if (PyErr_Occurred()) PyErr_Clear();
2253 if (obj && !SwigPyObject_Check(obj)) {
2256 return SWIG_Python_GetSwigThis(obj);
2258 return (SwigPyObject *)obj;
2265 SWIG_Python_AcquirePtr(PyObject *obj,
int own) {
2266 if (own == SWIG_POINTER_OWN) {
2267 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2269 int oldown = sobj->own;
2280 SWIG_Python_ConvertPtrAndOwn(PyObject *obj,
void **ptr, swig_type_info *ty,
int flags,
int *own) {
2286 if (obj == Py_None) {
2294 sobj = SWIG_Python_GetSwigThis(obj);
2298 void *vptr = sobj->ptr;
2300 swig_type_info *to = sobj->ty;
2303 if (ptr) *ptr = vptr;
2306 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2308 sobj = (SwigPyObject *)sobj->next;
2312 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2313 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2316 *own = *own | SWIG_CAST_NEW_MEMORY;
2323 if (ptr) *ptr = vptr;
2329 *own = *own | sobj->own;
2330 if (flags & SWIG_POINTER_DISOWN) {
2335 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2336 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2337 if (data && !data->implicitconv) {
2338 PyObject *klass = data->klass;
2341 data->implicitconv = 1;
2342 impconv = SWIG_Python_CallFunctor(klass, obj);
2343 data->implicitconv = 0;
2344 if (PyErr_Occurred()) {
2349 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2352 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2353 if (SWIG_IsOK(res)) {
2358 res = SWIG_AddCast(res);
2359 res = SWIG_AddNewMask(res);
2361 res = SWIG_AddCast(res);
2377 SWIG_Python_ConvertFunctionPtr(PyObject *obj,
void **ptr, swig_type_info *ty) {
2378 if (!PyCFunction_Check(obj)) {
2379 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2384 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2385 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2387 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2391 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2394 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2409 SWIG_Python_ConvertPacked(PyObject *obj,
void *ptr,
size_t sz, swig_type_info *ty) {
2410 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2411 if (!to)
return SWIG_ERROR;
2415 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2416 if (!tc)
return SWIG_ERROR;
2431 SWIGRUNTIME PyObject*
2432 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2434 #if (PY_VERSION_HEX >= 0x02020000)
2436 PyObject *newraw = data->newraw;
2438 inst = PyObject_Call(newraw, data->newargs,
nullptr);
2440 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2441 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2442 if (dictptr !=
nullptr) {
2443 PyObject *dict = *dictptr;
2444 if (dict ==
nullptr) {
2445 dict = PyDict_New();
2447 PyDict_SetItem(dict, SWIG_This(), swig_this);
2451 PyObject *key = SWIG_This();
2452 PyObject_SetAttr(inst, key, swig_this);
2456 #if PY_VERSION_HEX >= 0x03000000
2457 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2458 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2459 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2461 PyObject *dict = PyDict_New();
2462 PyDict_SetItem(dict, SWIG_This(), swig_this);
2463 inst = PyInstance_NewRaw(data->newargs, dict);
2469 #if (PY_VERSION_HEX >= 0x02010000)
2471 PyObject *dict = PyDict_New();
2472 PyDict_SetItem(dict, SWIG_This(), swig_this);
2473 inst = PyInstance_NewRaw(data->newargs, dict);
2475 return (PyObject *) inst;
2477 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2478 if (inst ==
nullptr) {
2481 inst->in_class = (PyClassObject *)data->newargs;
2482 Py_INCREF(inst->in_class);
2483 inst->in_dict = PyDict_New();
2484 if (inst->in_dict ==
nullptr) {
2488 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2489 inst->in_weakreflist =
nullptr;
2491 #ifdef Py_TPFLAGS_GC
2492 PyObject_GC_Init(inst);
2494 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2495 return (PyObject *) inst;
2501 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2504 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2505 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2506 if (dictptr !=
nullptr) {
2508 if (dict ==
nullptr) {
2509 dict = PyDict_New();
2512 PyDict_SetItem(dict, SWIG_This(), swig_this);
2516 dict = PyObject_GetAttrString(inst, (
char*)
"__dict__");
2517 PyDict_SetItem(dict, SWIG_This(), swig_this);
2522 SWIGINTERN PyObject *
2523 SWIG_Python_InitShadowInstance(PyObject *args) {
2525 if (!SWIG_Python_UnpackTuple(args,(
char*)
"swiginit", 2, 2, obj)) {
2528 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2530 SwigPyObject_append((PyObject*) sthis, obj[1]);
2532 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2534 return SWIG_Py_Void();
2540 SWIGRUNTIME PyObject *
2541 SWIG_Python_NewPointerObj(PyObject *
self,
void *ptr, swig_type_info *type,
int flags) {
2542 SwigPyClientData *clientdata;
2547 return SWIG_Py_Void();
2549 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2550 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2551 if (clientdata && clientdata->pytype) {
2552 SwigPyObject *newobj;
2553 if (flags & SWIG_BUILTIN_TP_INIT) {
2554 newobj = (SwigPyObject*)
self;
2556 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2557 while (newobj->next)
2558 newobj = (SwigPyObject *) newobj->next;
2559 newobj->next = next_self;
2560 newobj = (SwigPyObject *)next_self;
2563 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2570 #ifdef SWIGPYTHON_BUILTIN
2573 return (PyObject*) newobj;
2575 return SWIG_Py_Void();
2578 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2580 robj = SwigPyObject_New(ptr, type, own);
2581 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2582 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2593 SWIGRUNTIMEINLINE PyObject *
2594 SWIG_Python_NewPackedObj(
void *ptr,
size_t sz, swig_type_info *type) {
2595 return ptr ? SwigPyPacked_New((
void *) ptr, sz, type) : SWIG_Py_Void();
2602 #ifdef SWIG_LINK_RUNTIME
2603 void *SWIG_ReturnGlobalTypeList(
void *);
2606 SWIGRUNTIME swig_module_info *
2607 SWIG_Python_GetModule(
void) {
2608 static void *type_pointer = (
void *)0;
2610 if (!type_pointer) {
2611 #ifdef SWIG_LINK_RUNTIME
2612 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2614 # ifdef SWIGPY_USE_CAPSULE
2615 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2617 type_pointer = PyCObject_Import((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION,
2618 (
char*)
"type_pointer" SWIG_TYPE_TABLE_NAME);
2620 if (PyErr_Occurred()) {
2622 type_pointer = (
void *)0;
2626 return (swig_module_info *) type_pointer;
2629 #if PY_MAJOR_VERSION < 2
2633 PyModule_AddObject(PyObject *m,
char *name, PyObject *o)
2636 if (!PyModule_Check(m)) {
2637 PyErr_SetString(PyExc_TypeError,
2638 "PyModule_AddObject() needs module as first arg");
2642 PyErr_SetString(PyExc_TypeError,
2643 "PyModule_AddObject() needs non-nullptr value");
2647 dict = PyModule_GetDict(m);
2648 if (dict ==
nullptr) {
2650 PyErr_Format(PyExc_SystemError,
"module '%s' has no __dict__",
2651 PyModule_GetName(m));
2654 if (PyDict_SetItemString(dict, name, o))
2662 #ifdef SWIGPY_USE_CAPSULE
2663 SWIG_Python_DestroyModule(PyObject *obj)
2665 SWIG_Python_DestroyModule(
void *vptr)
2668 #ifdef SWIGPY_USE_CAPSULE
2669 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2671 swig_module_info *swig_module = (swig_module_info *) vptr;
2673 swig_type_info **types = swig_module->types;
2675 for (i =0; i < swig_module->size; ++i) {
2676 swig_type_info *ty = types[i];
2678 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2679 if (data) SwigPyClientData_Del(data);
2682 Py_DECREF(SWIG_This());
2683 swig_this =
nullptr;
2687 SWIG_Python_SetModule(swig_module_info *swig_module) {
2688 #if PY_VERSION_HEX >= 0x03000000
2690 PyObject *module = PyImport_AddModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION);
2692 static PyMethodDef swig_empty_runtime_method_table[] = { {
nullptr,
nullptr, 0,
nullptr} };
2693 PyObject *module = Py_InitModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2695 #ifdef SWIGPY_USE_CAPSULE
2696 PyObject *pointer = PyCapsule_New((
void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2697 if (pointer && module) {
2698 PyModule_AddObject(module, (
char*)
"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2700 Py_XDECREF(pointer);
2703 PyObject *pointer = PyCObject_FromVoidPtr((
void *) swig_module, SWIG_Python_DestroyModule);
2704 if (pointer && module) {
2705 PyModule_AddObject(module, (
char*)
"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2707 Py_XDECREF(pointer);
2713 SWIGRUNTIME PyObject *
2714 SWIG_Python_TypeCache(
void) {
2715 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2719 SWIGRUNTIME swig_type_info *
2720 SWIG_Python_TypeQuery(
const char *type)
2722 PyObject *cache = SWIG_Python_TypeCache();
2723 PyObject *key = SWIG_Python_str_FromChar(type);
2724 PyObject *obj = PyDict_GetItem(cache, key);
2725 swig_type_info *descriptor;
2727 #ifdef SWIGPY_USE_CAPSULE
2728 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj,
nullptr);
2730 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2733 swig_module_info *swig_module = SWIG_Python_GetModule();
2734 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2736 #ifdef SWIGPY_USE_CAPSULE
2737 obj = PyCapsule_New((
void*) descriptor,
nullptr,
nullptr);
2739 obj = PyCObject_FromVoidPtr(descriptor,
nullptr);
2741 PyDict_SetItem(cache, key, obj);
2752 #define SWIG_POINTER_EXCEPTION 0
2753 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2754 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2757 SWIG_Python_AddErrMesg(
const char* mesg,
int infront)
2759 if (PyErr_Occurred()) {
2761 PyObject *value = 0;
2762 PyObject *traceback = 0;
2763 PyErr_Fetch(&type, &value, &traceback);
2766 PyObject *old_str = PyObject_Str(value);
2770 PyErr_Format(type,
"%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2772 PyErr_Format(type,
"%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2774 SWIG_Python_str_DelForPy3(tmp);
2784 SWIG_Python_ArgFail(
int argnum)
2786 if (PyErr_Occurred()) {
2789 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
2790 return SWIG_Python_AddErrMesg(mesg, 1);
2796 SWIGRUNTIMEINLINE
const char *
2797 SwigPyObject_GetDesc(PyObject *
self)
2799 SwigPyObject *v = (SwigPyObject *)
self;
2800 swig_type_info *ty = v ? v->ty : 0;
2801 return ty ? ty->str : (
char*)
"";
2805 SWIG_Python_TypeError(
const char *type, PyObject *obj)
2808 #if defined(SWIG_COBJECT_TYPES)
2809 if (obj && SwigPyObject_Check(obj)) {
2810 const char *otype = (
const char *) SwigPyObject_GetDesc(obj);
2812 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
2819 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2821 PyObject *str = PyObject_Str(obj);
2822 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2824 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
2826 SWIG_Python_str_DelForPy3(cstr);
2828 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
2835 PyErr_Format(PyExc_TypeError,
"a '%s' is expected", type);
2837 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
2844 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty,
int SWIGUNUSEDPARM(argnum),
int flags) {
2846 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2848 #if SWIG_POINTER_EXCEPTION
2850 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2851 SWIG_Python_ArgFail(argnum);
2859 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2860 PyTypeObject *tp = obj->ob_type;
2862 PyObject *encoded_name;
2866 #ifdef Py_USING_UNICODE
2867 if (PyString_Check(name)) {
2868 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name),
nullptr,
nullptr);
2871 }
else if (!PyUnicode_Check(name))
2873 if (!PyString_Check(name))
2876 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2883 if (PyType_Ready(tp) < 0)
2888 descr = _PyType_Lookup(tp, name);
2890 if (descr !=
nullptr)
2891 f = descr->ob_type->tp_descr_set;
2893 if (PyString_Check(name)) {
2894 encoded_name = name;
2897 encoded_name = PyUnicode_AsUTF8String(name);
2899 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2900 Py_DECREF(encoded_name);
2902 res = f(descr, obj, value);
2923 #ifdef SWIG_MODULE_CLIENTDATA_TYPE
2925 SWIGRUNTIMEINLINE swig_type_info *
2926 SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata,
const char *name) {
2927 swig_module_info *module = SWIG_GetModule(clientdata);
2928 return SWIG_TypeQueryModule(module, module, name);
2931 SWIGRUNTIMEINLINE swig_type_info *
2932 SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata,
const char *name) {
2933 swig_module_info *module = SWIG_GetModule(clientdata);
2934 return SWIG_MangledTypeQueryModule(module, module, name);
2939 SWIGRUNTIMEINLINE swig_type_info *
2940 SWIG_TypeQuery(
const char *name) {
2941 swig_module_info *module = SWIG_GetModule(
nullptr);
2942 return SWIG_TypeQueryModule(module, module, name);
2945 SWIGRUNTIMEINLINE swig_type_info *
2946 SWIG_MangledTypeQuery(
const char *name) {
2947 swig_module_info *module = SWIG_GetModule(
nullptr);
2948 return SWIG_MangledTypeQueryModule(module, module, name);