minor refactoring and state progress

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

diff --git a/src/Moof/Dispatcher.cc b/src/Moof/Dispatcher.cc
index 369d4515ffe401aa75b8956cdecedb93638475ed..320746485199d227a77dbb4624015969e8bc09b2 100644 (file)
--- a/src/Moof/Dispatcher.cc
+++ b/src/Moof/Dispatcher.cc
@@ -34,15 +34,17 @@
 namespace Mf {
 
 
-struct Dispatcher::Impl
+class Dispatcher::Impl
 {
+       friend class Dispatcher;
+
        Impl() :
-               id(1) {}
+               mId(1) {}
 
        Dispatcher::Handler getNewHandler()
        {
-               id += 2;
-               return (Dispatcher::Handler)id;
+               mId += 2;
+               return (Dispatcher::Handler)mId;
        }
 
        typedef std::pair<Dispatcher::Handler,Dispatcher::Function>     Callback;
@@ -56,43 +58,56 @@ struct Dispatcher::Impl
        inline Handler addHandler(const std::string& message,
                        const Function& callback, Handler id)
        {
-               callbacks.insert(std::make_pair(message, std::make_pair(id, callback)));
-               handlers.insert(std::make_pair(id, message));
+               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(handlers.equal_range(id));
+               std::pair<HandlerIter,HandlerIter> matching(mHandlers.equal_range(id));
 
                for (HandlerIter it = matching.first; it != matching.second; ++it)
                {
-                       CallbackIter first = callbacks.find((*it).second);
-                       CallbackIter last = callbacks.end();
+                       CallbackIter first = mCallbacks.find((*it).second);
+                       CallbackIter last = mCallbacks.end();
 
                        for (CallbackIter jt = first; jt != last; ++jt)
                        {
                                if ((*jt).second.first == id)
                                {
-                                       callbacks.erase(jt);
+                                       mCallbacks.erase(jt);
                                        break;
                                }
                        }
                }
 
-               handlers.erase(id);
+               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   id;
 
-       CallbackLookup  callbacks;
-       HandlerLookup   handlers;
+       unsigned long   mId;
+
+       CallbackLookup  mCallbacks;
+       HandlerLookup   mHandlers;
 };
 
 
 Dispatcher::Dispatcher() :
-       impl_(new Dispatcher::Impl) {}
+       mImpl(new Dispatcher::Impl) {}
 
 Dispatcher::~Dispatcher() {}
 
@@ -107,34 +122,28 @@ Dispatcher& Dispatcher::getInstance()
 Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
                const Function& callback)
 {
-       return addHandler(message, callback, impl_->getNewHandler());
+       return addHandler(message, callback, mImpl->getNewHandler());
 }
 
 Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
                const Function& callback, Handler id)
 {
        // pass through
-       return impl_->addHandler(message, callback, id);
+       return mImpl->addHandler(message, callback, id);
 }
 
 
 void Dispatcher::removeHandler(Handler id)
 {
        // pass through
-       return impl_->removeHandler(id);
+       return mImpl->removeHandler(id);
 }
 
 
 void Dispatcher::dispatch(const std::string& message, const Notification* param)
 {
-       std::pair<Impl::CallbackIter,Impl::CallbackIter>
-               callbacks(impl_->callbacks.equal_range(message));
-
-       for (Impl::CallbackIter it = callbacks.first; it != callbacks.second; ++it)
-       {
-               Function callback = (*it).second.second;
-               callback(param);
-       }
+       // pass through
+       mImpl->dispatch(message, param);
 }