线程之间的通信(communication between threads)

 Boost.Python只接受指向函数的指针和指向成员函数的指针。 所以我们需要做的是将我们的callable转换为函数指针。 这里的关键思想是 
 
 
 
 没有捕获的lambda可以转换为函数指针（通过巫术 ） 
 
 
 函数指针的解释方式与Python中的成员函数相同：第一个参数是self 
 
 
 所以在你的情况下，我们需要做的是生成这个lambda： 
 
+[](gui_button_t* self) {
    self->on_pressed();
}
 
 你已经可以在Boost.Python中使用它了，因为这是一个非常正常的函数指针。 但是，我们需要一个适用于任何可调用成员的解决方案。 当你可以支持任何东西时，为什么只支持boost::function ？ 
 
 我们将从@ Columbo的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可以不捕获，我们必须将callable作为模板参数： 
 
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));
 
 演示演示成员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);
 
 这样可行，但您必须为要设置的每个仿函数添加更多个案。 如果每个类只有一个类似仿函数的对象，可能不是什么大问题，甚至可以编写更高阶的函数来为给定的属性名称生成特定的类似setattr的函数。 但是如果你有倍数，它将比简单的set_on_pressed解决方案稳定地变得更糟。 
 
 
 如果C ++ 14不可用，我们必须只显式指定make_pointer的返回类型。 我们需要一些方便的类型特征。 concat ： 
 
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演示 。 

Boost.Python only accepts pointers to functions and pointers to member functions. So what we need to do is convert our callable into a function pointer. The key ideas here are that 
 
 
 
a lambda that has no capture can be converted to a function pointer (via sorcery)
 
 
function pointers are interpreted the same way as member functions in Python: the first argument is self
 
 
So in your case, what we need to do is generate this lambda:
 
+[](gui_button_t* self) {
    self->on_pressed();
}
 
You can already use that as-is with Boost.Python, since that is a perfectly normal pointer to function. However, we want a solution that will work for any callable member. Why just support boost::function when you can support anything? 
 
We'll start with @Columbo's closure_traits, but additionally adding a way to pull out the argument list;
 
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...>;                                        \
};
 
Then we'll write a wrapper for any callable member. Since our lambda can take NO capture, we have to take the callable as a template parameter:
 
template <typename CLS, typename F, F CLS::*callable>
class wrap { ... };
 
I will use C++14's auto return type deduction to save some typing. We make a top-level make_pointer() static member function that just forwards to a helper member function that additionally takes the arguments. The full wrap looks like:
 
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...);
        };
    }
};
 
Which we can use to wrap your button:
 
void (*f)(gui_button_t*) = wrap<gui_button_t, 
                                decltype(gui_button_t::on_pressed),
                                &gui_button_t::on_pressed
                                >::make_pointer();
 
That's a little verbose and repetitive, so let's just make a macro (sigh):
 
#define WRAP_MEM(CLS, MEM) wrap<CLS, decltype(CLS::MEM), &CLS::MEM>::make_pointer()
 
So we get:
 
void (*f)(gui_button_t*) = WRAP_MEM(gui_button_t, on_pressed);

f(some_button); // calls some_button->on_pressed()
 
Since this gives us a pointer to function, we can use this directly with the normal Boost.Python API:
 
class_<gui_button_t>("GuiButton", init<>())
    .def("on_pressed", WRAP_MEM(gui_button_t, on_pressed));
 
Demo demonstrating function pointers to a member std::function and a member struct with an operator(). 
 
 
The above gets you the ability to expose a callable. If you want to additionally be able to do assignment, i.e.:
 
button = GuiButton()
button.on_pressed = callback_function
button.on_pressed()
 
We'll need to do something else. You can't expose operator= in a meaningful way in Python, so to support the above functionality, you'd have to override __setattr__ instead. Now, if you were open to:
 
button.set_on_pressed(callback_function)
 
we could extend the above wrap solution to add a setter, whose implementation would be, in the vein of the above:
 
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()
 
Which you could then expose via:
 
.def("set_on_pressed", SET_MEM(button, on_pressed))
 
However, if you insist on supporting direct-assignment, then you would need to additionally expose something like:
 
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);
 
That would work, but you'd have to add more cases for each functor you want to set. If you only have one functor-like object per class, probably not a big deal, and can even write a higher order function to product a specific setattr-like function for a given attribute name. But if you have multiples, it's going to steadily get worse than the simple set_on_pressed solution. 
 
 
If C++14 is not available, we'll have to just explicitly specify the return type of make_pointer. We'll need a few handy type traits. concat:
 
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...>;
};
 
And then something to turn a return type and a typelist into a function pointer:
 
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;
 
And then within wrap, we can just define a result type as:
 
using R = make_fn_ptr_t<
                typename closure_traits<F>::result_type,
                concat_t<
                    typelist<CLS*>,
                    typename closure_traits<F>::args
                    >
                >;
 
and use that instead of auto. C++11 Demo.