port to NetBSD

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

diff --git a/src/Moof/Dispatcher.cc b/src/Moof/Dispatcher.cc
index fa7b3281818ca6a06a4f07753638c4509209d04a..320746485199d227a77dbb4624015969e8bc09b2 100644 (file)
--- a/src/Moof/Dispatcher.cc
+++ b/src/Moof/Dispatcher.cc
@@ -34,18 +34,17 @@
 namespace Mf {
 
 
-Notification::~Notification() {}
-
-
-class Dispatcher::DispatcherImpl
+class Dispatcher::Impl
 {
-public:
-       DispatcherImpl() : id(1) {}
+       friend class Dispatcher;
+
+       Impl() :
+               mId(1) {}
 
-       Dispatcher::Handler getNewHandlerID()
+       Dispatcher::Handler getNewHandler()
        {
-               id += 4;
-               return (Dispatcher::Handler)id;
+               mId += 2;
+               return (Dispatcher::Handler)mId;
        }
 
        typedef std::pair<Dispatcher::Handler,Dispatcher::Function>     Callback;
@@ -55,82 +54,96 @@ public:
        typedef std::multimap<Dispatcher::Handler,std::string>          HandlerLookup;
        typedef HandlerLookup::iterator                                                         HandlerIter;
 
-       unsigned long long      id;
 
-       CallbackLookup          callbacks;
-       HandlerLookup           handlers;
+       inline Handler addHandler(const std::string& message,
+                       const Function& callback, Handler id)
+       {
+               mCallbacks.insert(std::make_pair(message, std::make_pair(id, callback)));
+               mHandlers.insert(std::make_pair(id, message));
+
+               return id;
+       }
+
+       inline void removeHandler(Handler id)
+       {
+               std::pair<HandlerIter,HandlerIter> matching(mHandlers.equal_range(id));
+
+               for (HandlerIter it = matching.first; it != matching.second; ++it)
+               {
+                       CallbackIter first = mCallbacks.find((*it).second);
+                       CallbackIter last = mCallbacks.end();
+
+                       for (CallbackIter jt = first; jt != last; ++jt)
+                       {
+                               if ((*jt).second.first == id)
+                               {
+                                       mCallbacks.erase(jt);
+                                       break;
+                               }
+                       }
+               }
+
+               mHandlers.erase(id);
+       }
+
+       void dispatch(const std::string& message, const Notification* param)
+       {
+               std::pair<CallbackIter,CallbackIter>
+                       callbacks(mCallbacks.equal_range(message));
+
+               for (CallbackIter it = callbacks.first; it != callbacks.second; ++it)
+               {
+                       Function callback = (*it).second.second;
+                       callback(param);
+               }
+       }
+
+
+       unsigned long   mId;
+
+       CallbackLookup  mCallbacks;
+       HandlerLookup   mHandlers;
 };
 
 
 Dispatcher::Dispatcher() :
-       impl_(new Dispatcher::DispatcherImpl) {}
+       mImpl(new Dispatcher::Impl) {}
+
+Dispatcher::~Dispatcher() {}
 
 
-// TODO these methods are ugly
+Dispatcher& Dispatcher::getInstance()
+{
+       static Dispatcher dispatcher;
+       return dispatcher;
+}
+
 
 Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
                const Function& callback)
 {
-       return addHandler(message, callback, impl_->getNewHandlerID());
+       return addHandler(message, callback, mImpl->getNewHandler());
 }
 
 Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
                const Function& callback, Handler id)
 {
-       std::pair<std::string,Dispatcher::DispatcherImpl::Callback>
-               callbackPair(message, Dispatcher::DispatcherImpl::Callback(id, callback));
-
-       std::pair<Handler,std::string> handlerPair(id, message);
-
-       impl_->callbacks.insert(callbackPair);
-       impl_->handlers.insert(handlerPair);
-
-       return id;
+       // pass through
+       return mImpl->addHandler(message, callback, id);
 }
 
 
 void Dispatcher::removeHandler(Handler id)
 {
-       std::pair<Dispatcher::DispatcherImpl::HandlerIter,Dispatcher::DispatcherImpl::HandlerIter>
-               handlers(impl_->handlers.equal_range(id));
-
-       Dispatcher::DispatcherImpl::HandlerIter i;
-       for (i = handlers.first; i != handlers.second; i++)
-       {
-               Dispatcher::DispatcherImpl::CallbackIter it = impl_->callbacks.find((*i).second);
-               Dispatcher::DispatcherImpl::CallbackIter last = impl_->callbacks.end();
-
-               Dispatcher::DispatcherImpl::CallbackIter j;
-               for (j = it; j != last; j++)
-               {
-                       if (((*j).second).first == id)
-                       {
-                               impl_->callbacks.erase(j);
-                               break;
-                       }
-               }
-       }
-       
-       impl_->handlers.erase(id);
+       // pass through
+       return mImpl->removeHandler(id);
 }
 
 
-void Dispatcher::dispatch(const std::string& message)
+void Dispatcher::dispatch(const std::string& message, const Notification* param)
 {
-       dispatch(message, Notification());
-}
-
-void Dispatcher::dispatch(const std::string& message, const Notification& param)
-{
-       std::pair<Dispatcher::DispatcherImpl::CallbackIter,Dispatcher::DispatcherImpl::CallbackIter>
-               callbacks(impl_->callbacks.equal_range(message));
-
-       Dispatcher::DispatcherImpl::CallbackIter i;
-       for (i = callbacks.first; i != callbacks.second; i++)
-       {
-               Function callback = ((*i).second).second;
-               callback(param);
-       }
+       // pass through
+       mImpl->dispatch(message, param);
 }