#ifndef __FFPYTHON_H_

#define __FFPYTHON_H_

#include <Python.h>

#include <structmember.h>

#include <string>

#include <sstream>

#include <vector>

#include <list>

#include <set>

#include <map>

#include <stdexcept>

using namespace std;

#ifdef _WIN32

#define SAFE_SPRINTF _snprintf_s

#else

#define SAFE_SPRINTF snprintf

#endif

//! 获取python异常信息

struct pyops_t

{

static int traceback(string& ret_)

{

PyObject* err = PyErr_Occurred();

if (err != NULL) {

PyObject *ptype = NULL, *pvalue = NULL, *ptraceback = NULL;

PyObject *pyth_module = NULL, *pyth_func = NULL;

PyErr_Fetch(&ptype, &pvalue, &ptraceback);

if (pvalue)

{

if (true == PyList_Check(pvalue))

{

int n = PyList_Size(pvalue);

for (int i = 0; i < n; ++i)

{

PyObject *pystr = PyObject_Str(PyList_GetItem(pvalue, i));

ret_ += PyString_AsString(pystr);

ret_ += "\n";

Py_DECREF(pystr);

}

}

if (true == PyTuple_Check(pvalue))

{

int n = PyTuple_Size(pvalue);

for (int i = 0; i < n; ++i)

{

PyObject* tmp_str = PyTuple_GetItem(pvalue, i);

if (true == PyTuple_Check(tmp_str))

{

int m = PyTuple_Size(tmp_str);

for (int j = 0; j < m; ++j)

{

PyObject *pystr = PyObject_Str(PyTuple_GetItem(tmp_str, j));

ret_ += PyString_AsString(pystr);

ret_ += ",";

Py_DECREF(pystr);

}

}

else

{

PyObject *pystr = PyObject_Str(tmp_str);

ret_ += PyString_AsString(pystr);

Py_DECREF(pystr);

}

ret_ += "\n";

}

}

else

{

PyObject *pystr = PyObject_Str(pvalue);

if (pystr)

{

ret_ += PyString_AsString(pystr);

ret_ += "\n";

Py_DECREF(pystr);

}

}

}

/* See if we can get a full traceback */

PyObject *module_name = PyString_FromString("traceback");

pyth_module = PyImport_Import(module_name);

Py_DECREF(module_name);

if (pyth_module && ptype && pvalue && ptraceback)

{

pyth_func = PyObject_GetAttrString(pyth_module, "format_exception");

if (pyth_func && PyCallable_Check(pyth_func)) {

PyObject *pyth_val = PyObject_CallFunctionObjArgs(pyth_func, ptype, pvalue, ptraceback, NULL);

if (pyth_val && true == PyList_Check(pyth_val))

{

int n = PyList_Size(pyth_val);

for (int i = 0; i < n; ++i)

{

PyObject* tmp_str = PyList_GetItem(pyth_val, i);

PyObject *pystr = PyObject_Str(tmp_str);

if (pystr)

{

ret_ += PyString_AsString(pystr);

Py_DECREF(pystr);

}

ret_ += "\n";

}

}

Py_XDECREF(pyth_val);

}

}

Py_XDECREF(pyth_func);

Py_XDECREF(pyth_module);

Py_XDECREF(ptype);

Py_XDECREF(pvalue);

Py_XDECREF(ptraceback);

PyErr_Clear();

return 0;

}

return -1;

}

};

struct cpp_void_t{};

//! 用于抽取类型、类型对应的引用

template<typename T>

struct type_ref_traits_t;

//! 用于python 可选参数

template<typename T>

struct pyoption_t

{

typedef typename type_ref_traits_t<T>::value_t value_t;

pyoption_t():m_set_flag(false){}

bool is_set() const { return m_set_flag;}

void set() { m_set_flag = true;}

value_t& value() { return m_value;}

const value_t& value() const{ return m_value;}

const value_t& value(const value_t& default_)

{

if (is_set())

return m_value;

else

return default_;

}

bool m_set_flag;

value_t m_value;

};

//! 用于判断是否是可选参数

template<typename T>

struct pyoption_traits_t;

//! pytype_traits_t 封装 PyLong_FromLong 相关的操作，用于为调用python生成参数

template<typename T>

struct pytype_traits_t

{

static PyObject* pyobj_from_cppobj(const char* const val_)

{

return PyString_FromString(val_);

}

/*

static int pyobj_to_cppobj(PyObject *pvalue_, char*& m_ret)

{

if (true == PyString_Check(pvalue_))

{

m_ret = PyString_AsString(pvalue_);

return 0;

}

return -1;

}

*/

static const char* get_typename() { return "string";}

};

//! 用于调用python函数，生成tuple类型的python函数参数的工具类

struct pycall_arg_t

{

pycall_arg_t(int arg_num):

arg_index(0),

pargs_tuple(PyTuple_New(arg_num))

{}

~pycall_arg_t()

{

release();

}

PyObject * get_args() const

{

return pargs_tuple;

}

template<typename T>

pycall_arg_t& add(const T& val_)

{

if (arg_index < PyTuple_Size(pargs_tuple))

{

PyObject* tmp_arg = pytype_traits_t<T>::pyobj_from_cppobj(val_);

PyTuple_SetItem(pargs_tuple, arg_index, tmp_arg);

++arg_index;

}

return *this;

}

void release()

{

if (pargs_tuple)

{

Py_DECREF(pargs_tuple);

pargs_tuple = NULL;

}

}

int arg_index;

PyObject * pargs_tuple;

};

//! 用于调用python函数，获取返回值的工具类

class pytype_tool_t

{

public:

virtual ~pytype_tool_t(){};

virtual int parse_value(PyObject *pvalue_) = 0;

virtual const char* return_type() {return "";}

virtual bool need_release() { return true; }

};

//! 用于调用python函数，获取返回值的工具泛型类

template<typename T>

class pytype_tool_impl_t;

//! 封装调用python函数的C API

struct pycall_t

{

static int call_func(PyObject *pModule, const string& mod_name_, const string& func_name_,

pycall_arg_t& pyarg_, pytype_tool_t& pyret_, string& err_)

{

PyObject *pFunc = PyObject_GetAttrString(pModule, func_name_.c_str());

if (pFunc && PyCallable_Check(pFunc)) {

PyObject *pArgs = pyarg_.get_args();

PyObject *pValue = PyObject_CallObject(pFunc, pArgs);

pyarg_.release();//! 等价于Py_DECREF(pArgs);

if (pValue != NULL) {

if (pyret_.parse_value(pValue))

{

err_ += "value returned is not ";

err_ += pyret_.return_type();

err_ += string(" ") + func_name_ + " in " + mod_name_;

}

if (pyret_.need_release())

Py_DECREF(pValue);

}

}

else

{

err_ += "Cannot find function ";

err_ += func_name_ + " in " + mod_name_ + ",";

}

Py_XDECREF(pFunc);

if (PyErr_Occurred())

{

pyops_t::traceback(err_);

return 0;

}

return 0;

}

static int call_func_obj(PyObject *pFunc, pycall_arg_t& pyarg_, pytype_tool_t& pyret_, string& err_)

{

if (pFunc && PyCallable_Check(pFunc)) {

PyObject *pArgs = pyarg_.get_args();

PyObject *pValue = PyObject_CallObject(pFunc, pArgs);

pyarg_.release();//! 等价于Py_DECREF(pArgs);

if (pValue != NULL) {

if (pyret_.parse_value(pValue))

{

err_ += "value returned is not ";

err_ += pyret_.return_type();

}

if (pyret_.need_release())

Py_DECREF(pValue);

}

}

else

{

err_ += "invalid function";

}

if (PyErr_Occurred())

{

pyops_t::traceback(err_);

return 0;

}

return 0;

}

template<typename T>

static const T& call(const string& mod_name_, const string& func_name_, pycall_arg_t& pyarg_, pytype_tool_impl_t<T>& pyret);

template<typename T>

static const T& call_obj_method(PyObject *pObj, const string& func_name_, pycall_arg_t& pyarg_, pytype_tool_impl_t<T>& pyret);

template<typename T>

static const T& call_lambda(PyObject *pFunc, pycall_arg_t& pyarg_, pytype_tool_impl_t<T>& pyret);

};

//! 用于扩展python的工具类，用来解析参数

struct pyext_tool_t;

template<typename T>

struct pyext_return_tool_t;

//! 用于扩展python，生成pyobject类型的返回值给python

template <typename T>

struct pyext_func_traits_t;

//! 用于扩展python，traits出注册给python的函数接口

#ifndef PYCTOR

#define PYCTOR int (*)

#endif

//! 表示void类型，由于void类型不能return，用void_ignore_t适配

template<typename T>

struct void_ignore_t;

template<typename T>

struct void_ignore_t

{

typedef T value_t;

};

template<>

struct void_ignore_t<void>

{

typedef cpp_void_t value_t;

};

#define RET_V typename void_ignore_t<RET>::value_t

//! 记录各个基类和子类的相互关系

struct cpp_to_pyclass_reg_info_t

{

struct inherit_info_t

{

inherit_info_t():pytype_def(NULL){}

PyTypeObject* pytype_def;

string inherit_name;

set<PyTypeObject*> all_child;

};

typedef map<string, inherit_info_t> inherit_info_map_t;

static inherit_info_map_t& get_all_info()

{

static inherit_info_map_t inherit_info;

return inherit_info;

}

static void add(const string& child_, const string& base_, PyTypeObject* def_)

{

inherit_info_t tmp;

tmp.inherit_name = base_;

tmp.pytype_def = def_;

get_all_info()[child_] = tmp;

get_all_info()[base_].all_child.insert(def_);

}

static bool is_instance(PyObject* pysrc, const string& class_)

{

inherit_info_map_t& inherit_info = get_all_info();

inherit_info_t& tmp = inherit_info[class_];

if (tmp.pytype_def && PyObject_TypeCheck(pysrc, tmp.pytype_def))

{

return true;

}

for (set<PyTypeObject*>::iterator it = tmp.all_child.begin(); it != tmp.all_child.end(); ++it)

{

if (*it && PyObject_TypeCheck(pysrc, *it))

{

return true;

}

}

return false;

}

};

//! 记录C++ class 对应到python中的名称、参数信息等,全局

struct static_pytype_info_t

{

string class_name;

string mod_name;

int total_args_num;

PyTypeObject* pytype_def;

};

//! 工具类，用于生成分配python class的接口，包括分配、释放

template<typename T>

struct pyclass_base_info_t

{

struct obj_data_t

{

obj_data_t():obj(NULL){}

PyObject_HEAD;

T* obj;

bool forbid_release;

void disable_auto_release(){ forbid_release = true; }

void release()

{

if (obj)

{

delete obj;

obj = NULL;

}

}

};

static void free_obj(obj_data_t* self)

{

if (false == self->forbid_release && self->obj)

{

self->release();

}

self->ob_type->tp_free((PyObject*)self);

}

static PyObject *alloc_obj(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

obj_data_t *self = (obj_data_t *)type->tp_alloc(type, 0);

return (PyObject *)self;

}

static PyObject *release(PyTypeObject *type, PyObject *args)

{

obj_data_t *self = (obj_data_t *)type;

self->release();

Py_RETURN_TRUE;

}

static static_pytype_info_t pytype_info;

};

template<typename T>

static_pytype_info_t pyclass_base_info_t<T>::pytype_info;

//! 方便生成pyclass 初始化函数

template <typename CLASS_TYPE, typename CTOR>

struct pyclass_ctor_tool_t;

//! used to gen method of py class

template<typename T>

struct pyclass_method_gen_t;

//! 防止出现指针为NULL调用出错

#define NULL_PTR_GUARD(X) if (NULL == X) {PyErr_SetString(PyExc_TypeError, "obj data ptr NULL");return NULL;}

//! 用于生成python 的getter和setter接口，适配于c++ class的成员变量

template <typename CLASS_TYPE, typename RET>

struct pyclass_member_func_gen_t

{

typedef typename pyclass_base_info_t<CLASS_TYPE>::obj_data_t obj_data_t;

typedef RET CLASS_TYPE::* property_ptr_t;

static PyObject *getter_func(obj_data_t *self, void *closure)

{

property_ptr_t property_ptr;

::memcpy(&property_ptr, &closure, sizeof(closure));

NULL_PTR_GUARD(self->obj);

CLASS_TYPE* p = self->obj;

return pytype_traits_t<RET>::pyobj_from_cppobj(p->*property_ptr);

}

static int setter_func(obj_data_t *self, PyObject *value, void *closure)

{

property_ptr_t property_ptr;

::memcpy(&property_ptr, &closure, sizeof(closure));

CLASS_TYPE* p = self->obj;

return pytype_traits_t<RET>::pyobj_to_cppobj(value, p->*property_ptr);

}

};

//! 用于C++ 注册class的工具类，会记录class对应的名称、成员方法、成员变量

class pyclass_regigster_tool_t

{

public:

struct method_info_t

{

PyCFunction func;

string func_name;

string func_real_name;

string doc;

string doc_real;

int args_num;

int option_args_num;

long func_addr;

};

struct property_info_t

{

void* ptr;

string property_name;

string doc;

getter getter_func;

setter setter_func;

};

virtual ~pyclass_regigster_tool_t(){}

typedef PyObject *(*pyobj_alloc_t)(PyTypeObject*, PyObject*, PyObject*);

string class_name;

string class_real_name;

string class_name_with_mod;

string class_reel_name_with_mod;

string inherit_name;

int type_size;

string doc;

int args_num;

int option_args_num;

destructor dector;

initproc init;

pyobj_alloc_t ctor;

//! member functions

PyCFunction delete_func;

vector<method_info_t> methods_info;

//! property

vector<property_info_t> propertys_info;

//! for init module

PyTypeObject pytype_def;

//! method

vector<PyMethodDef> pymethod_def;

//! property

vector<PyGetSetDef> pyproperty_def;

//! 静态类型需要全局记录该类型被注册成神马python 类型

static_pytype_info_t* static_pytype_info;

template<typename FUNC>

pyclass_regigster_tool_t& reg(FUNC f_, const string& func_name_, string doc_ = "")

{

method_info_t tmp;

tmp.func_name = func_name_;

tmp.func_real_name = func_name_ + "_internal_";

tmp.doc = doc_;

tmp.doc_real = "internal use";

tmp.func = (PyCFunction)pyclass_method_gen_t<FUNC>::pymethod;

tmp.args_num = pyclass_method_gen_t<FUNC>::args_num();

tmp.option_args_num = pyclass_method_gen_t<FUNC>::option_args_num();

::memcpy(&tmp.func_addr, &f_, sizeof(f_));

methods_info.push_back(tmp);

return *this;

}

template<typename CLASS_TYPE,typename RET>

pyclass_regigster_tool_t& reg_property(RET CLASS_TYPE::* member_, const string& member_name_, string doc_ = "")

{

property_info_t tmp;

::memcpy(&tmp.ptr, &member_, sizeof(member_));

tmp.property_name = member_name_;

tmp.doc = doc_;

tmp.getter_func = (getter)pyclass_member_func_gen_t<CLASS_TYPE, RET>::getter_func;

tmp.setter_func = (setter)pyclass_member_func_gen_t<CLASS_TYPE, RET>::setter_func;

propertys_info.push_back(tmp);

return *this;

}

};

class ffpython_t

{

struct reg_info_t

{

reg_info_t():args_num(0),option_args_num(0),func_addr(0){}

int args_num;

int option_args_num;

long func_addr;

PyCFunction func;

string func_name;

string func_impl_name;

string doc;

string doc_impl;

};

public:

ffpython_t()

{

if (!Py_IsInitialized())

Py_Initialize();

}

~ffpython_t()

{

clear_cache_pyobject();

}

static int init_py()

{

Py_Initialize();

return 0;

}

static int final_py()

{

Py_Finalize();

return 0;

}

static int add_path(const string& path_)

{

char buff[1024];

SAFE_SPRINTF(buff, sizeof(buff), "import sys\nif '%s' not in sys.path:\n\tsys.path.append('%s')\n", path_.c_str(), path_.c_str());

PyRun_SimpleString(buff);

return 0;

}

static int run_string(const string& py_)

{

PyRun_SimpleString(py_.c_str());

return 0;

}

static int reload(const string& py_name_)

{

PyObject *pName = NULL, *pModule = NULL;

string err_msg;

pName = PyString_FromString(py_name_.c_str());

pModule = PyImport_Import(pName);

Py_DECREF(pName);

if (NULL == pModule)

{

pyops_t::traceback(err_msg);

throw runtime_error(err_msg.c_str());

return -1;

}

PyObject *pNewMod = PyImport_ReloadModule(pModule);

Py_DECREF(pModule);

if (NULL == pNewMod)

{

pyops_t::traceback(err_msg);

throw runtime_error(err_msg.c_str());

return -1;

}

Py_DECREF(pNewMod);

return 0;

}

static int load(const string& py_name_)

{

PyObject *pName = NULL, *pModule = NULL;

string err_msg;

pName = PyString_FromString(py_name_.c_str());

pModule = PyImport_Import(pName);

Py_DECREF(pName);

if (NULL == pModule)

{

pyops_t::traceback(err_msg);

throw runtime_error(err_msg.c_str());

return -1;

}

Py_DECREF(pModule);

return 0;

}

//! 注册static function，

template<typename T>

ffpython_t& reg(T func_, const string& func_name_, string doc_ = "")

{

reg_info_t tmp;

tmp.args_num = pyext_func_traits_t<T>::args_num();

tmp.option_args_num = pyext_func_traits_t<T>::option_args_num();

tmp.func = (PyCFunction)pyext_func_traits_t<T>::pyfunc;

tmp.func_name= func_name_;

tmp.func_impl_name = func_name_ + "_internal_";

tmp.doc = doc_;

tmp.doc_impl = string("internal use, please call ") + func_name_;

tmp.func_addr= (long)func_;

m_func_info.push_back(tmp);

return *this;

}

//! 注册c++ class

template<typename T, typename CTOR>

pyclass_regigster_tool_t& reg_class(const string& class_name_, string doc_ = "", string inherit_name_ = "")

{

if (pyclass_base_info_t<T>::pytype_info.class_name.empty() == false)

throw runtime_error("this type has been registed");

pyclass_base_info_t<T>::pytype_info.class_name = class_name_;

//pyclass_base_info_t<T>::pytype_info.mod_name = m_mod_name;

pyclass_base_info_t<T>::pytype_info.total_args_num = pyext_func_traits_t<CTOR>::args_num() +

pyext_func_traits_t<CTOR>::option_args_num();

pyclass_regigster_tool_t tmp;

tmp.class_name = class_name_;

tmp.class_real_name = class_name_ + "_internal_";

tmp.inherit_name = inherit_name_;

tmp.doc = doc_;

tmp.dector = (destructor)pyclass_base_info_t<T>::free_obj;

tmp.init = (initproc)pyclass_ctor_tool_t<T, CTOR>::init_obj;

tmp.ctor = pyclass_base_info_t<T>::alloc_obj;

tmp.type_size = sizeof(typename pyclass_base_info_t<T>::obj_data_t);

tmp.args_num = pyext_func_traits_t<CTOR>::args_num();

tmp.option_args_num = pyext_func_traits_t<CTOR>::option_args_num();

tmp.static_pytype_info = &(pyclass_base_info_t<T>::pytype_info);

//! 注册析构函数,python若不调用析构函数,当对象被gc时自动调用

tmp.delete_func = (PyCFunction)pyclass_base_info_t<T>::release;

m_all_pyclass.push_back(tmp);

return m_all_pyclass.back();

}

//! 将需要注册的函数、类型注册到python虚拟机

int init(const string& mod_name_, string doc_ = "")

{

m_mod_name = mod_name_;

m_mod_doc = doc_;

PyObject* m = init_method();

init_pyclass(m);

return 0;

}

//! 调用python函数，最多支持9个参数

template<typename RET>

RET_V call(const string& mod_name_, const string& func_)

{

pycall_arg_t args(0);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1)

{

pycall_arg_t args(1);

args.add(a1);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2)

{

pycall_arg_t args(2);

args.add(a1).add(a2);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3)

{

pycall_arg_t args(3);

args.add(a1).add(a2).add(a3);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4)

{

pycall_arg_t args(4);

args.add(a1).add(a2).add(a3).add(a4);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5)

{

pycall_arg_t args(5);

args.add(a1).add(a2).add(a3).add(a4).add(a5);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6)

{

pycall_arg_t args(6);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6,const ARG7& a7)

{

pycall_arg_t args(7);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8)

{

pycall_arg_t args(8);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8, typename ARG9>

RET_V call(const string& mod_name_, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8, const ARG9& a9)

{

pycall_arg_t args(9);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8).add(a9);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call<RET_V>(mod_name_, func_, args, pyret);

}

//!call python class method begin******************************************************************

template<typename RET>

RET_V obj_call(PyObject* pobj, const string& func_)

{

pycall_arg_t args(0);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1)

{

pycall_arg_t args(1);

args.add(a1);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2)

{

pycall_arg_t args(2);

args.add(a1).add(a2);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3)

{

pycall_arg_t args(3);

args.add(a1).add(a2).add(a3);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4)

{

pycall_arg_t args(4);

args.add(a1).add(a2).add(a3).add(a4);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5)

{

pycall_arg_t args(5);

args.add(a1).add(a2).add(a3).add(a4).add(a5);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6)

{

pycall_arg_t args(6);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6,const ARG7& a7)

{

pycall_arg_t args(7);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8)

{

pycall_arg_t args(8);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8, typename ARG9>

RET_V obj_call(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8, const ARG9& a9)

{

pycall_arg_t args(9);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8).add(a9);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_obj_method<RET_V>(pobj, func_, args, pyret);

}

//!call python class method end******************************************************************

//!call python lambad function begin ############################################################

template<typename RET>

RET_V call_lambda(PyObject* pobj)

{

pycall_arg_t args(0);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1>

RET_V call_lambda(PyObject* pobj, const ARG1& a1)

{

pycall_arg_t args(1);

args.add(a1);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2)

{

pycall_arg_t args(2);

args.add(a1).add(a2);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3)

{

pycall_arg_t args(3);

args.add(a1).add(a2).add(a3);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4)

{

pycall_arg_t args(4);

args.add(a1).add(a2).add(a3).add(a4);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5)

{

pycall_arg_t args(5);

args.add(a1).add(a2).add(a3).add(a4).add(a5);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6)

{

pycall_arg_t args(6);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5,const ARG6& a6,const ARG7& a7)

{

pycall_arg_t args(7);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8>

RET_V call_lambda(PyObject* pobj, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8)

{

pycall_arg_t args(8);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

template<typename RET, typename ARG1, typename ARG2, typename ARG3, typename ARG4, typename ARG5, typename ARG6, typename ARG7,

typename ARG8, typename ARG9>

RET_V call_lambda(PyObject* pobj, const string& func_, const ARG1& a1, const ARG2& a2, const ARG3& a3, const ARG4& a4,

const ARG5& a5, const ARG6& a6, const ARG7& a7, const ARG8& a8, const ARG9& a9)

{

pycall_arg_t args(9);

args.add(a1).add(a2).add(a3).add(a4).add(a5).add(a6).add(a7).add(a8).add(a9);

pytype_tool_impl_t<RET_V> pyret;

return pycall_t::call_lambda<RET_V>(pobj, args, pyret);

}

//!call python lambad function ennd ############################################################

template<typename RET>

RET_V get_global_var(const string& mod_name_, const string& var_name_)

{

PyObject *pName = NULL, *pModule = NULL;

string err_msg;

pName = PyString_FromString(mod_name_.c_str());

pModule = PyImport_Import(pName);

Py_DECREF(pName);

if (NULL == pModule)

{

pyops_t::traceback(err_msg);

throw runtime_error(err_msg.c_str());

}

pytype_tool_impl_t<RET_V> pyret;

PyObject *pvalue = PyObject_GetAttrString(pModule, var_name_.c_str());

Py_DECREF(pModule);

if (!pvalue)

{