在我试图用我的C ++编写Python代码的过程中，事情变得越来越复杂。
基本上，我希望能够在HTTP调用收到响应后分配一个回调函数，并且我希望能够从C ++或Python中执行此操作。
换句话说，我希望能够从C ++中调用它：
http.get_asyc("www.google.ca", [&](int a) { std::cout << "response recieved: " << a << std::endl; });
这来自Python：
def f(r):
print str.format('response recieved: {}', r)
http.get_async('www.google.ca', f)
我已经设置了demo on Coliru，可以准确显示我要完成的任务。这是我得到的代码和错误：
#include <boost/python.hpp>
#include <boost/function.hpp>
struct http_manager
{
void get_async(std::string url, boost::function<void(int)> on_response)
{
if (on_response)
{
on_response(42);
}
}
} http;
BOOST_PYTHON_MODULE(example)
{
boost::python::class_<http_manager>("HttpManager", boost::python::no_init)
.def("get_async", &http_manager::get_async);
boost::python::scope().attr("http") = boost::ref(http);
}
import example
def f(r):
print r
example.http.get_async('www.google.ca', f)
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
Boost.Python.ArgumentError: Python argument types in
HttpManager.get_async(HttpManager, str, function)
did not match C++ signature:
get_async(http_manager {lvalue}, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::function<void (int)>)
我不确定为什么function没有自动转换为boost::function。
之前我问了一个vaguely similar question，得到了一个惊人的答案。我也想知道在那里给出的答案中的类似方法是否也适用于这个用例。
非常感谢您的支持！
答案 0 :(得分：3)
当调用通过Boost.Python公开的函数时，Boost.Python将查询其注册表，以根据所需的C ++类型为每个调用者的参数找到合适的from-Python转换器。如果找到一个知道如何从Python对象转换为C ++对象的转换器，那么它将使用转换器来构造C ++对象。如果找不到合适的转换器，则Boost.Python将引发ArgumentError异常。
注册了from-Python转换器：
int和std::string boost::python::class<T>公开的类型。默认情况下，生成的Python类将包含T C ++对象的嵌入式实例，并使用嵌入式实例注册Python类的Python和Python转换器并键入T。 / LI>
boost::python::converter::registry::push_back() 测试可转换性和构造对象的步骤分为两个不同的步骤。由于没有为boost::function<void(int)>注册from-Python转换器，Boost.Python将引发ArgumentError异常。尽管boost::function<void(int)>可以构造boost::function<void(int)>，Boost.Python不会尝试构造boost::python::object对象。
要解决此问题，请考虑使用填充函数将boost::function<void(int)>的构造推迟到boost::python::object通过Boost.Python图层之后：
void http_manager_get_async_aux(
http_manager& self, std::string url, boost::python::object on_response)
{
return self.get_async(url, on_response);
}
...
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
python::class_<http_manager>("HttpManager", python::no_init)
.def("get_async", &http_manager_get_async_aux);
...
}
这是一个完整的示例demonstrating这种方法：
#include <boost/python.hpp>
#include <boost/function.hpp>
struct http_manager
{
void get_async(std::string url, boost::function<void(int)> on_response)
{
if (on_response)
{
on_response(42);
}
}
} http;
void http_manager_get_async_aux(
http_manager& self, std::string url, boost::python::object on_response)
{
return self.get_async(url, on_response);
}
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
python::class_<http_manager>("HttpManager", python::no_init)
.def("get_async", &http_manager_get_async_aux);
python::scope().attr("http") = boost::ref(http);
}
交互式使用：
>>> import example
>>> result = 0
>>> def f(r):
... global result
... result = r
...
>>> assert(result == 0)
>>> example.http.get_async('www.google.com', f)
>>> assert(result == 42)
>>> try:
... example.http.get_async('www.google.com', 42)
... assert(False)
... except TypeError:
... pass
...
另一种方法是为boost::function<void(int)>显式注册from-Python转换器。这样做的好处是，通过Boost.Python公开的所有函数都可以使用转换器（例如，不需要为每个函数编写填充程序）。但是，需要为每种C ++类型注册转换。以下示例demonstrating明确为boost::function<void(int)>和boost::function<void(std::string)>注册了自定义转换器：
#include <boost/python.hpp>
#include <boost/function.hpp>
struct http_manager
{
void get_async(std::string url, boost::function<void(int)> on_response)
{
if (on_response)
{
on_response(42);
}
}
} http;
/// @brief Type that allows for registration of conversions from
/// python iterable types.
struct function_converter
{
/// @note Registers converter from a python callable type to the
/// provided type.
template <typename FunctionSig>
function_converter&
from_python()
{
boost::python::converter::registry::push_back(
&function_converter::convertible,
&function_converter::construct<FunctionSig>,
boost::python::type_id<boost::function<FunctionSig>>());
// Support chaining.
return *this;
}
/// @brief Check if PyObject is callable.
static void* convertible(PyObject* object)
{
return PyCallable_Check(object) ? object : NULL;
}
/// @brief Convert callable PyObject to a C++ boost::function.
template <typename FunctionSig>
static void construct(
PyObject* object,
boost::python::converter::rvalue_from_python_stage1_data* data)
{
namespace python = boost::python;
// Object is a borrowed reference, so create a handle indicting it is
// borrowed for proper reference counting.
python::handle<> handle(python::borrowed(object));
// Obtain a handle to the memory block that the converter has allocated
// for the C++ type.
typedef boost::function<FunctionSig> functor_type;
typedef python::converter::rvalue_from_python_storage<functor_type>
storage_type;
void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
// Allocate the C++ type into the converter's memory block, and assign
// its handle to the converter's convertible variable.
new (storage) functor_type(python::object(handle));
data->convertible = storage;
}
};
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
python::class_<http_manager>("HttpManager", python::no_init)
.def("get_async", &http_manager::get_async);
python::scope().attr("http") = boost::ref(http);
// Enable conversions for boost::function.
function_converter()
.from_python<void(int)>()
// Chaining is supported, so the following would enable
// another conversion.
.from_python<void(std::string)>()
;
}
答案 1 :(得分：2)
一种解决方案是添加重载功能：
void get_async(std::string url, boost::python::object obj)
{
if (PyCallable_Check(obj.ptr()))
get_async(url, static_cast<boost::function<void(int)>>(obj));
}
然后公开这个特定的过载：
.def("get_async", static_cast<void (http_manager::*)(std::string, boost::python::object)>(&http_manager::get_async))
或者如果你不想用python东西污染你的主类，那么你可以创建一个包装类。事情看起来也更清洁了：
struct http_manager_wrapper : http_manager
{
void get_async(std::string url, boost::python::object obj)
{
if (PyCallable_Check(obj.ptr()))
http_manager::get_async(url, obj);
}
} http_wrapper;
BOOST_PYTHON_MODULE(example)
{
boost::python::class_<http_manager_wrapper>("HttpManager", boost::python::no_init)
.def("get_async", &http_manager_wrapper::get_async);
boost::python::scope().attr("http") = boost::ref(http_wrapper);
}
更新：另一种选择是使用python callable来增强函数转换器。这将解决单身人士问题，并且不会要求对主班级进行更改。
struct http_manager
{
void get_async(std::string url, boost::function<void(int)> on_response)
{
if (on_response)
{
on_response(42);
}
}
} http;
struct BoostFunc_from_Python_Callable
{
BoostFunc_from_Python_Callable()
{
boost::python::converter::registry::push_back(&convertible, &construct, boost::python::type_id< boost::function< void(int) > >());
}
static void* convertible(PyObject* obj_ptr)
{
if (!PyCallable_Check(obj_ptr))
return 0;
return obj_ptr;
}
static void construct(PyObject* obj_ptr, boost::python::converter::rvalue_from_python_stage1_data* data)
{
boost::python::object callable(boost::python::handle<>(boost::python::borrowed(obj_ptr)));
void* storage = ((boost::python::converter::rvalue_from_python_storage< boost::function< void(int) > >*) data)->storage.bytes;
new (storage)boost::function< void(int) >(callable);
data->convertible = storage;
}
};
BOOST_PYTHON_MODULE(example)
{
// Register function converter
BoostFunc_from_Python_Callable();
boost::python::class_<http_manager>("HttpManager", boost::python::no_init)
.def("get_async", &http_manager::get_async);
boost::python::scope().attr("http") = boost::ref(http);
}