I have some code that implements an asynchronous worker model where a
client calls some function to request an asynchronous operation and
passes a callback function, whose type is determined by a template
parameter. e.g.
class worker
{
template<class Handler>
void async_do_work(Handler h)
{
...
}
};
class client
{
void start_work();
void work_finished(boost::system::error_code ec, size_t bytes_transferred);
};
However there are many classes implementing async_do_work but which do
the work in a different way. For this I use a boost::variant for each type and use a boost::static_visitor to delegate to the
appropriate async_do_work method. This uses code such as the
following:
void client::start_work()
{
apply_visitor(
bind(do_work_visitor(), _1,
protect(bind(&client::work_finished, this, _1, _2)))
, work_variant_);
}
So from async_do_work's point of view, it receives a function with 2
arguments.
How async_do_work operates internally should be separated from the
client. It may not even use another thread, or it may combine the
efforts of multiple threads to achieve the result. So because of
that, I want async_do_work to intercept the callback before it gets
posted back to the original caller. To do this, I tried the
following in the implementation of worker:
class worker
{
public:
template<class Handler>
void async_do_work(Handler h)
{
//impl supports the same basic interface as worker
impl->async_do_work(
bind(&worker::intercept_handler<Handler>, this, h, _1, _2));
}
private:
template<class Handler>
void intercept_handler(Handler real_handler,
boost::system::error_code ec, size_t bytes_transferred)
{
//do whatever is necessary and then call the real handler.
real_handler(ec, bytes_transferred);
}
};
However this doesn't work. I've also tried protect(bind in the
async_do_work function and that doesn't work either. Is it supposed
to be possible to nest binds arbitrarily deep or is this just a
limitation? Or am I just doing it wrong?
Regards
