destroyed global classes; view hierarchy instead

[chaz/yoink] / src / Moof / Dispatch.cc

diff --git a/src/Moof/Dispatch.cc b/src/Moof/Dispatch.cc
index 52f28f88327e2591378819308cb3a832c44e1512..83fecae279fac9b336928531fa0b4c67a885d326 100644 (file)
--- a/src/Moof/Dispatch.cc
+++ b/src/Moof/Dispatch.cc
@@ -21,46 +21,45 @@ class Dispatch::Impl
 {
 public:
 
-       Impl() :
+       Impl(Dispatch* dispatch) :
+               mDispatch(dispatch),
                mId(0) {}
 
-       Dispatch::Handler getNewHandler()
+       Dispatch::Handle getNewHandle()
        {
                ++mId;
-               //return Dispatch::Handler(this, mId);
-               Dispatch::Handler handler(this, mId);
-               return handler;
+               Dispatch::Handle handle(mDispatch->mImpl, mId);
+               return handle;
        }
 
        typedef std::pair<unsigned,Dispatch::Function>  Callback;
        typedef std::multimap<std::string,Callback>             CallbackLookup;
-       typedef CallbackLookup::iterator                                CallbackIter;
+       typedef CallbackLookup::iterator                                CallbackIt;
 
-       typedef std::multimap<unsigned,std::string>             HandlerLookup;
-       typedef HandlerLookup::iterator                                 HandlerIter;
+       typedef std::multimap<unsigned,std::string>             HandleLookup;
+       typedef HandleLookup::iterator                                  HandleIt;
 
 
-       inline Handler addHandler(const std::string& event,
-                                                         const Function& callback, Handler handler)
+       inline Handle addTarget(const std::string& event,
+                                                       const Function& callback, Handle handle)
        {
                mCallbacks.insert(std::make_pair(event,
-                                                 std::make_pair(handler.getId(), callback)));
-               mHandlers.insert(std::make_pair(handler.getId(), event));
+                                                 std::make_pair(handle.getId(), callback)));
+               mHandles.insert(std::make_pair(handle.getId(), event));
 
-               return handler;
+               return handle;
        }
 
-       inline void removeHandler(unsigned id)
+       inline void removeTarget(unsigned id)
        {
-               std::pair<HandlerIter,HandlerIter>
-                       matching(mHandlers.equal_range(id));
+               std::pair<HandleIt,HandleIt> matching(mHandles.equal_range(id));
 
-               for (HandlerIter it = matching.first; it != matching.second; ++it)
+               for (HandleIt it = matching.first; it != matching.second; ++it)
                {
-                       CallbackIter first = mCallbacks.find((*it).second);
-                       CallbackIter last = mCallbacks.end();
+                       CallbackIt first = mCallbacks.find((*it).second);
+                       CallbackIt last = mCallbacks.end();
 
-                       for (CallbackIter jt = first; jt != last; ++jt)
+                       for (CallbackIt jt = first; jt != last; ++jt)
                        {
                                if ((*jt).second.first == id)
                                {
@@ -70,16 +69,15 @@ public:
                        }
                }
 
-               mHandlers.erase(id);
+               mHandles.erase(id);
        }
 
        void dispatch(const std::string& event, const Message* message)
        {
-               std::pair<CallbackIter,CallbackIter>
+               std::pair<CallbackIt,CallbackIt>
                        callbacks(mCallbacks.equal_range(event));
 
-               for (CallbackIter it = callbacks.first; it != callbacks.second;
-                               ++it)
+               for (CallbackIt it = callbacks.first; it != callbacks.second; ++it)
                {
                        Function callback = (*it).second.second;
                        callback(message);
@@ -87,45 +85,49 @@ public:
        }
 
 
+       Dispatch*               mDispatch;
+
        unsigned                mId;
 
        CallbackLookup  mCallbacks;
-       HandlerLookup   mHandlers;
+       HandleLookup    mHandles;
 };
 
 
-Dispatch::Handler::~Handler()
+void Dispatch::Handle::clear()
 {
-       if (mId)
+       boost::shared_ptr<Impl> dispatch;
+       if (mId && (dispatch = mDispatch.lock()))
        {
-               mDispatch->removeHandler(mId);
+               dispatch->removeTarget(mId);
+               mId = 0;
        }
 }
 
 
 Dispatch::Dispatch() :
-       mImpl(new Dispatch::Impl) {}
+       mImpl(new Dispatch::Impl(this)) {}
 
 
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-                                                                          const Function& callback)
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+                                                                        const Function& callback)
 {
-       return addHandler(event, callback, mImpl->getNewHandler());
+       return addTarget(event, callback, mImpl->getNewHandle());
 }
 
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-                                                                          const Function& callback,
-                                                                          Handler handler)
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+                                                                        const Function& callback,
+                                                                        Handle handle)
 {
        // pass through
-       return mImpl->addHandler(event, callback, handler);
+       return mImpl->addTarget(event, callback, handle);
 }
 
 
-void Dispatch::removeHandler(unsigned id)
+void Dispatch::removeTarget(unsigned id)
 {
        // pass through
-       return mImpl->removeHandler(id);
+       return mImpl->removeTarget(id);
 }
 
 
@@ -136,5 +138,12 @@ void Dispatch::dispatch(const std::string& event, const Message* message)
 }
 
 
+Dispatch& Dispatch::global()
+{
+       static Dispatch dispatch;
+       return dispatch;
+}
+
+
 } // namespace Mf