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;
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() {}
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);
}