Frank Mori Hess wrote:
To have the connection disconnect on the Foo object's destruction, you're
supposed to pass a shared_ptr owning the object (either directly or
indirectly) to slot::track() before connecting the slot. This insures the
object is not destroyed while a slot invocation is in progress (the signal
converts its weak_ptr copy to a shared_ptr while the slot runs), and
disconnects the slot when the tracked weak_ptr expires. It does have the
drawback that you often can't track connections made in the constructor
though, since enable_shared_from_this doesn't work there. I did provide
postconstructible/deconstruct_ptr to support postconstructors, although it
does all add up to a bit more typing.
Thanks for the clarification. This solution forces the use of shared_ptrs and might keep a Foo instance alive a little bit longer. Especially the latter requirement is a no-no for me.
I created my own thread safe signals implementation which requires a "CallbackRequester" to connect a synchronous slot to an asynchronous signal:
class CallbackRequester { virtual void callLater(const boost::function<void()>& callback) = 0; };
The callbackrequester implementation -typically a queue - switches to the thread which the synchronous slot "belongs" to. This is of course very intrusive to the entire design of an application - callbackrequesters implementations need to exist for all threads and be passed around all over the application. However, it made it possible to implement a safe scoped_connection with RAII semantics. User code look something like this:
AsyncSignal<void()> sig;
class Foo{
Foo(boost::weak_ptr<CallbackRequester> req)
: con(sig, boost::bind(&Foo::SomeFunc, this), req) {}
void SomeFunc() { ...}
AsyncSignalConnection con;
};
Johan
