057c2d5dd1
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@5417 626c5289-ae23-0410-ae9c-e8d60b6d4f22
1007 lines
48 KiB
OpenEdge ABL
1007 lines
48 KiB
OpenEdge ABL
//
|
|
// SWIG typemaps for std::pair
|
|
// Luigi Ballabio
|
|
// July 2003
|
|
//
|
|
// Python implementation
|
|
|
|
%include std_common.i
|
|
%include exception.i
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
// std::pair
|
|
//
|
|
// See std_vector.i for the rationale of typemap application
|
|
// ------------------------------------------------------------------------
|
|
|
|
%{
|
|
#include <utility>
|
|
%}
|
|
|
|
// exported class
|
|
|
|
namespace std {
|
|
|
|
template<class T, class U> struct pair {
|
|
%typemap(in) pair<T,U> (std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
T* x;
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = std::make_pair(x,y);
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1) {
|
|
$1 = *p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(in) const pair<T,U>& (std::pair<T,U> temp,
|
|
std::pair<T,U>* p),
|
|
const pair<T,U>* (std::pair<T,U> temp,
|
|
std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
T* x;
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
temp = std::make_pair(x,y);
|
|
$1 = &temp;
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1) {
|
|
$1 = p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(out) pair<T,U> {
|
|
$result = PyTuple_New(2);
|
|
T* x = new T($1.first);
|
|
U* y = new U($1.second);
|
|
PyTuple_SetItem($result,0,
|
|
SWIG_NewPointerObj((void *) x,
|
|
$descriptor(T *), 1));
|
|
PyTuple_SetItem($result,1,
|
|
SWIG_NewPointerObj((void *) y,
|
|
$descriptor(U *), 1));
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
T* x;
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
|
|
const pair<T,U>* {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
T* x;
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
T first;
|
|
U second;
|
|
};
|
|
|
|
|
|
// specializations for built-ins
|
|
|
|
%define specialize_std_pair_on_first(T,CHECK,CONVERT_FROM,CONVERT_TO)
|
|
template<class U> struct pair<T,U> {
|
|
%typemap(in) pair<T,U> (std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK(first) &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = std::make_pair(CONVERT_FROM(first),y);
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1) {
|
|
$1 = *p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(in) const pair<T,U>& (std::pair<T,U> temp,
|
|
std::pair<T,U>* p),
|
|
const pair<T,U>* (std::pair<T,U> temp,
|
|
std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK(first) &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
temp = std::make_pair(CONVERT_FROM(first),y);
|
|
$1 = &temp;
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1) {
|
|
$1 = p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(out) pair<T,U> {
|
|
$result = PyTuple_New(2);
|
|
U* y = new U($1.second);
|
|
PyTuple_SetItem($result,0,CONVERT_TO($1.first));
|
|
PyTuple_SetItem($result,1,
|
|
SWIG_NewPointerObj((void *) y,
|
|
$descriptor(U *), 1));
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK(first) &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
|
|
const pair<T,U>* {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
U* y;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK(first) &&
|
|
SWIG_ConvertPtr(second,(void **) &y,
|
|
$descriptor(U *),0) != -1) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
T first;
|
|
U second;
|
|
};
|
|
%enddef
|
|
|
|
%define specialize_std_pair_on_second(U,CHECK,CONVERT_FROM,CONVERT_TO)
|
|
template<class T> struct pair<T,U> {
|
|
%typemap(in) pair<T,U> (std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
T* x;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
CHECK(second)) {
|
|
$1 = std::make_pair(x,CONVERT_FROM(second));
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1) {
|
|
$1 = *p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(in) const pair<T,U>& (std::pair<T,U> temp,
|
|
std::pair<T,U>* p),
|
|
const pair<T,U>* (std::pair<T,U> temp,
|
|
std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
T* x;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
CHECK(second)) {
|
|
temp = std::make_pair(x,CONVERT_FROM(second));
|
|
$1 = &temp;
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1) {
|
|
$1 = p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(out) pair<T,U> {
|
|
$result = PyTuple_New(2);
|
|
T* x = new T($1.first);
|
|
PyTuple_SetItem($result,0,
|
|
SWIG_NewPointerObj((void *) x,
|
|
$descriptor(T *), 1));
|
|
PyTuple_SetItem($result,1,CONVERT_TO($1.second));
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
T* x;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
CHECK(second)) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
|
|
const pair<T,U>* {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
T* x;
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (SWIG_ConvertPtr(first,(void **) &x,
|
|
$descriptor(T *),0) != -1 &&
|
|
CHECK(second)) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
T first;
|
|
U second;
|
|
};
|
|
%enddef
|
|
|
|
%define specialize_std_pair_on_both(T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO,
|
|
U,CHECK_U,CONVERT_U_FROM,CONVERT_U_TO)
|
|
template<> struct pair<T,U> {
|
|
%typemap(in) pair<T,U> (std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK_T(first) && CHECK_U(second)) {
|
|
$1 = std::make_pair(CONVERT_T_FROM(first),
|
|
CONVERT_U_FROM(second));
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1) {
|
|
$1 = *p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(in) const pair<T,U>& (std::pair<T,U> temp,
|
|
std::pair<T,U>* p),
|
|
const pair<T,U>* (std::pair<T,U> temp,
|
|
std::pair<T,U>* p) {
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK_T(first) && CHECK_U(second)) {
|
|
temp = std::make_pair(CONVERT_T_FROM(first),
|
|
CONVERT_U_FROM(second));
|
|
$1 = &temp;
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
} else {
|
|
Py_DECREF(first);
|
|
Py_DECREF(second);
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
} else if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1) {
|
|
$1 = p;
|
|
} else {
|
|
SWIG_exception(SWIG_TypeError,
|
|
"pair<" #T "," #U "> expected");
|
|
}
|
|
}
|
|
%typemap(out) pair<T,U> {
|
|
$result = PyTuple_New(2);
|
|
PyTuple_SetItem($result,0,CONVERT_T_TO($1.first));
|
|
PyTuple_SetItem($result,1,CONVERT_U_TO($1.second));
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) pair<T,U> {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK_T(first) && CHECK_U(second)) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$&1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
%typecheck(SWIG_TYPECHECK_PAIR) const pair<T,U>&,
|
|
const pair<T,U>* {
|
|
/* native sequence? */
|
|
if (PyTuple_Check($input)) {
|
|
if (PyTuple_Size($input) != 2) {
|
|
/* not a pair anyway */
|
|
$1 = 0;
|
|
} else {
|
|
PyObject* first = PySequence_GetItem($input,0);
|
|
PyObject* second = PySequence_GetItem($input,1);
|
|
if (CHECK_T(first) && CHECK_U(second)) {
|
|
$1 = 1;
|
|
} else {
|
|
$1 = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* wrapped pair? */
|
|
std::pair<T,U >* p;
|
|
if (SWIG_ConvertPtr($input,(void **) &p,
|
|
$1_descriptor,0) != -1)
|
|
$1 = 1;
|
|
else
|
|
$1 = 0;
|
|
}
|
|
}
|
|
T first;
|
|
U second;
|
|
};
|
|
%enddef
|
|
|
|
specialize_std_pair_on_first(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_first(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_first(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_first(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_first(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_first(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_first(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,
|
|
PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_first(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_first(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_first(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
|
|
specialize_std_pair_on_second(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_second(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_second(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_second(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_second(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_second(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_second(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,
|
|
PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_second(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_second(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_second(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
bool,PyInt_Check,
|
|
PyInt_AsLong,SwigInt_FromBool);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
long,PyLong_Check,
|
|
PyLong_AsLong,PyLong_FromLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
unsigned int,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
unsigned short,PyInt_Check,
|
|
PyInt_AsLong,PyInt_FromLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
unsigned long,PyLong_Check,
|
|
PyLong_AsUnsignedLong,PyLong_FromUnsignedLong);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
double,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
float,SwigNumber_Check,
|
|
SwigNumber_AsDouble,PyFloat_FromDouble);
|
|
specialize_std_pair_on_both(std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString,
|
|
std::string,PyString_Check,
|
|
SwigString_AsString,SwigString_FromString);
|
|
|
|
}
|