Consider something like this:
typedef std::tr1::function CapsuleFunc;
class worker_thread_queue;
class forwarder {
worker_thread_queue* queue;
const NotifyFunc f;
public:
forwarder (worker_thread_queue* queue, const NotifyFunc f)
: queue(queue), f(f) {}
void operator() (uint32_t extended_ID, State_t newstate, State_t oldstate);
};
class worker_thread_queue {
// doesn't really work, just for illustration
public:
worker_thread_queue()
{
// really, would create a thread and thread-safe FIFO
}
// Calling submit will put f in a queue, and that queue is processed by the
// worker thread. It removes each item in FIFO order and executes them.
void submit (const CapsuleFunc& f) { /* but it's just an example */ }
// Calling wrap will return another function that when executed will call submit(f) on
this instance.
NotifyFunc wrap (const NotifyFunc& f)
{
forwarder x (this, f);
return x;
}
};
void forwarder::operator() (uint32_t extended_ID, State_t newstate, State_t oldstate)
{
CapsuleFunc x= std::tr1::bind (f, extended_ID, newstate, oldstate);
queue->submit (x);
}
// later...
worker_thread_queue work_queue;
work_queue.wrap(&foo);
Presuming a compiler that doesn't have Lambda functions supported, is there some nicer way
to acheive the effect shown by 'wrap'?
Given a function object f and a object q, I want to create a new function object that when
invoked will bind its arguments and call q->submit with the bound-up form.
I've seen forwarders throughout Boost; is there a publicly available one that I can use?
Or some kind of "delayed apply" that can be called like bind, with the thing to be built
up? I recall there is a full heavy duty library for lazy evaluation but don't recall its
name. But I'm also wondering if there is a specific (lighter weight or already being used
within the Boost libraries I'm already using) mechanism for this.
—John
