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;
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 it;
- for (it = handlers.first; it != handlers.second; ++it)
- {
- Dispatcher::DispatcherImpl::CallbackIter first = impl_->callbacks.find((*it).second);
- Dispatcher::DispatcherImpl::CallbackIter last = impl_->callbacks.end();
-
- Dispatcher::DispatcherImpl::CallbackIter jt;
- for (jt = first; jt != last; ++jt)
- {
- if (((*jt).second).first == id)
- {
- impl_->callbacks.erase(jt);
- 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 it;
- for (it = callbacks.first; it != callbacks.second; ++it)
- {
- Function callback = ((*it).second).second;
- callback(param);
- }
+ // pass through
+ mImpl->dispatch(message, param);
}