python - Boost.Python 和 Boost.Function

Question

我想包装一个 boost::function 类成员，以便可以按以下方式使用它:

using namespace boost;
using namespace boost::python;

struct gui_button_t
{
    function<void()> on_pressed;
};

class_<gui_button_t>("GuiButton", init<>())
    .def("on_pressed", &gui_button_t::on_pressed);

然后在 Python 中:

def callback_function():
    print 'button has been pressed'

button = GuiButton()
button.on_pressed = callback_function
button.on_pressed() # function should be callable from C++ or Python

但是，尝试这样做会产生大量关于类模板参数等的错误。

我进行了一些搜索，但未能找到我一直在寻找的答案。以下文章有点接近，但没有直接触及主题。

http://bfroehle.com/2011/07/18/boost-python-and-boost-function-ii/

我在这里做错了什么？我需要做什么才能获得此功能所需的界面？

非常感谢。

Answer 1

Boost.Python 只接受指向函数的指针和指向成员函数的指针。所以我们需要做的是将我们的可调用对象转换为函数指针。这里的关键思想是

1. 没有捕获的 lambda 可以转换为函数指针(通过 sorcery )
2. 函数指针的解释方式与 Python 中的成员函数相同:第一个参数是 self

所以在你的情况下，我们需要做的是生成这个 lambda:

+[](gui_button_t* self) {
    self->on_pressed();
}

您已经可以在 Boost.Python 中按原样使用它，因为它是一个完全正常的函数指针。但是，我们想要一个适用于任何 可调用成员的解决方案。当您可以支持任何东西时，为什么只是支持boost::function？

我们将从 @Columbo's closure_traits 开始，但另外添加了一种提取参数列表的方法；

template <typename...> struct typelist { };

template <typename C, typename R, typename... Args>                        \
struct closure_traits<R (C::*) (Args... REM_CTOR var) cv>                  \
{                                                                          \
    using arity = std::integral_constant<std::size_t, sizeof...(Args) >;   \
    using is_variadic = std::integral_constant<bool, is_var>;              \
    using is_const    = std::is_const<int cv>;                             \
                                                                           \
    using result_type = R;                                                 \
                                                                           \
    template <std::size_t i>                                               \
    using arg = typename std::tuple_element<i, std::tuple<Args...>>::type; \
                                                                           \
    using args = typelist<Args...>;                                        \
};

然后我们将为任何可调用成员编写一个包装器。由于我们的 lambda 不能捕获，我们必须将可调用对象作为模板参数:

template <typename CLS, typename F, F CLS::*callable>
class wrap { ... };

我将使用 C++14 的 auto 返回类型推导来节省一些输入。我们制作了一个顶级 make_pointer() 静态成员函数，它只是转发给一个额外接受参数的辅助成员函数。完整的 wrap 看起来像:

template <typename CLS, typename F, F CLS::*callable>
class wrap {
public:
    static auto make_pointer() {
        return make_pointer_impl(typename closure_traits<F>::args{});
    }

private:
    template <typename... Args>
    static auto make_pointer_impl(typelist<Args...> ) {
        // here is our lambda that takes the CLS as the first argument
        // and then the rest of the callable's arguments,
        // and just calls it
        return +[](CLS* self, Args... args) {
            return (self->*callable)(args...);
        };
    }
};

我们可以用它来包装您的按钮:

void (*f)(gui_button_t*) = wrap<gui_button_t, 
                                decltype(gui_button_t::on_pressed),
                                &gui_button_t::on_pressed
                                >::make_pointer();

这有点冗长和重复，所以让我们做一个宏吧(叹气):

#define WRAP_MEM(CLS, MEM) wrap<CLS, decltype(CLS::MEM), &CLS::MEM>::make_pointer()

所以我们得到:

void (*f)(gui_button_t*) = WRAP_MEM(gui_button_t, on_pressed);

f(some_button); // calls some_button->on_pressed()

因为这给了我们一个指向函数的指针，我们可以直接将它与普通的 Boost.Python API 一起使用:

class_<gui_button_t>("GuiButton", init<>())
    .def("on_pressed", WRAP_MEM(gui_button_t, on_pressed));

Demo演示指向成员 std::function 和带有 operator() 的成员 struct 的函数指针。

---

以上内容让您能够公开一个可调用对象。如果您还想能够进行分配，即:

button = GuiButton()
button.on_pressed = callback_function
button.on_pressed()

我们还需要做点别的。您不能在 Python 中以有意义的方式公开 operator=，因此要支持上述功能，您必须改写 __setattr__。现在，如果您愿意:

button.set_on_pressed(callback_function)

我们可以扩展上面的 wrap 解决方案来添加一个 setter，其实现将按照上面的思路:

static auto set_callable() {
    return make_setter_impl(
        typelist<typename closure_traits<F>::result_type>{},
        typename closure_traits<F>::args{});
}

template <typename R, typename... Args>
static auto make_setter_impl(typelist<R>, typelist<Args...> ) {
    return +[](CLS* self, py::object cb) {
        (self->*callable) = [cb](Args... args) {
            return py::extract<R>(
                cb(args...))();
        };
    };
}

// need a separate overload just for void
template <typename... Args>
static auto make_setter_impl(typelist<void>, typelist<Args...> ) {
    return +[](CLS* self, py::object cb) {
        (self->*callable) = [cb](Args... args) {
            cb(args...);
        };
    };
}

#define SET_MEM(CLS, MEM) wrap<CLS, decltype(CLS::MEM), &CLS::MEM>::set_callable()

然后您可以通过以下方式公开:

.def("set_on_pressed", SET_MEM(button, on_pressed))

但是，如果您坚持支持直接赋值，那么您将需要另外暴露如下内容:

static void setattr(py::object obj, std::string attr, py::object val)
{
     if (attr == "on_pressed") {
         button& b = py::extract<button&>(obj);
         SET_MEM(button, on_pressed)(&b, val);
     }
     else {
         py::str attr_str(attr);
         if (PyObject_GenericSetAttr(obj.ptr(), attr_str.ptr(), val.ptr()) {
             py::throw_error_already_set();
         }
     }
}


.def("__setattr__", &button::setattr);

这可行，但您必须为每个要设置的仿函数添加更多的 case。如果每个类只有一个类似仿函数的对象，可能没什么大不了的，甚至可以编写一个高阶函数来为给定的属性名称生成一个特定的类似 setattr 的函数。但是如果你有多个，它会逐渐变得比简单的 set_on_pressed 解决方案更糟糕。

---

如果 C++14 不可用，我们将不得不明确指定 make_pointer 的返回类型。我们需要一些方便的类型特征。 连接:

template <typename T1, typename T2>
struct concat;

template <typename T1, typename T2>
using concat_t = typename concat<T1, T2>::type;

template <typename... A1, typename... A2>
struct concat<typelist<A1...>, typelist<A2...>> {
    using type = typelist<A1..., A2...>;
};

然后将返回类型和 typelist 转换为函数指针:

template <typename R, typename T>
struct make_fn_ptr;

template <typename R, typename... Args>
struct make_fn_ptr<R, typelist<Args...>> {
    using type = R(*)(Args...);
};

template <typename R, typename T>
using make_fn_ptr_t = typename make_fn_ptr<R, T>::type;

然后在 wrap 中，我们可以将结果类型定义为:

using R = make_fn_ptr_t<
                typename closure_traits<F>::result_type,
                concat_t<
                    typelist<CLS*>,
                    typename closure_traits<F>::args
                    >
                >;

并使用它代替 auto。 C++11 Demo .