Re: [Boost-users] [RFC] Signals bound to phoenix functions

Subject: Re: [Boost-users] [RFC] Signals bound to phoenix functions
From: Stephan Menzel (stephan.menzel_at_[hidden])
Date: 2010-06-24 09:41:15

Hi Thomas,

On Thu, Jun 24, 2010 at 11:20 AM, Thomas Heller
<thom.heller_at_[hidden]> wrote:
> The correct answer is:
> post, m_signal_callback() and m_iosrv.wrap need to be
> lazy expressions.
> To achieve that for the first two, you can have a phoenix::function wrapper,
> for the last one, you can use phoenix::bind (which can be used for the first
> two as well).

I went for a lazy expression in the meantime, with moderate success.
It works for void() handlers, but as soon as multiple parameters kick
in the originally bound method appears to need additional binding.

I'll have a sample attached.

Here's the lazy function

template <bool CallingBack>
struct slot_wrap_impl {
        public:
                slot_wrap_impl(Queue<CallingBack> &n_q) : m_q(n_q) {};

                template <typename SlotSignature>
                struct result {
                        typedef void type;
                };

                template <typename SlotSignature>
                typename result<SlotSignature>::type
operator()(SlotSignature n_method) const {
                        using boost::phoenix::if_;
                        using boost::phoenix::switch_;
                        using boost::phoenix::case_;
                        using boost::phoenix::default_;
                        using boost::phoenix::bind;

                        std::cout << "binding post...\n";
                        m_q.post(n_method);        // X
                        std::cout << "post bound" << std::endl;
                        /*
                        if (CallingBack) {
                                m_q.callback();
                        };
                        */
                };
        private:
                Queue<CallingBack>   &m_q;
};

I call this in my connector using:

  boost::phoenix::function<slot_wrap_impl<CallingBack> > f(*this);
  boost::signals2::connection ret = n_signal.connect(f(n_method));
  return ret;

I think I'm finally on my way to get it. Everything is executed the
way it should be.
The main problem that remains is:

Why is the lazy function unable to call post() with something
different than function<void()> as an argument? The calling party
already uses bind on the function and the lazy function should only
see void() no matter what comes in.

If I could solve this, the problem would be gone. I tried to determine
arity and then use placeholders but I doubt this is ever going to
compile, let alone work.

Does any of this make sense or am I fooled by an accidentally working
but broken thing?

Cheers,
Stephan