#include <map>
-#include "Dispatcher.hh"
+#include "Dispatch.hh"
namespace Mf {
-class Dispatcher::Impl
+class Dispatch::Impl
{
- friend class Dispatcher;
+public:
Impl() :
- mId(1) {}
+ mId(0) {}
- Dispatcher::Handler getNewHandler()
+ Dispatch::Handler getNewHandler()
{
- mId += 2;
- return (Dispatcher::Handler)mId;
+ ++mId;
+ //return Dispatch::Handler(this, mId);
+ Dispatch::Handler handler(this, mId);
+ return handler;
}
- typedef std::pair<Dispatcher::Handler,Dispatcher::Function> Callback;
- typedef std::multimap<std::string,Callback> CallbackLookup;
- typedef CallbackLookup::iterator CallbackIter;
+ typedef std::pair<unsigned,Dispatch::Function> Callback;
+ typedef std::multimap<std::string,Callback> CallbackLookup;
+ typedef CallbackLookup::iterator CallbackIter;
- typedef std::multimap<Dispatcher::Handler,std::string> HandlerLookup;
- typedef HandlerLookup::iterator HandlerIter;
+ typedef std::multimap<unsigned,std::string> HandlerLookup;
+ typedef HandlerLookup::iterator HandlerIter;
- inline Handler addHandler(const std::string& message,
- const Function& callback, Handler id)
+ inline Handler addHandler(const std::string& event,
+ const Function& callback, Handler handler)
{
- mCallbacks.insert(std::make_pair(message, std::make_pair(id, callback)));
- mHandlers.insert(std::make_pair(id, message));
+ mCallbacks.insert(std::make_pair(event,
+ std::make_pair(handler.getId(), callback)));
+ mHandlers.insert(std::make_pair(handler.getId(), event));
- return id;
+ return handler;
}
- inline void removeHandler(Handler id)
+ inline void removeHandler(unsigned id)
{
std::pair<HandlerIter,HandlerIter> matching(mHandlers.equal_range(id));
mHandlers.erase(id);
}
- void dispatch(const std::string& message, const Notification* param)
+ void dispatch(const std::string& event, const Message* message)
{
std::pair<CallbackIter,CallbackIter>
- callbacks(mCallbacks.equal_range(message));
+ callbacks(mCallbacks.equal_range(event));
for (CallbackIter it = callbacks.first; it != callbacks.second; ++it)
{
Function callback = (*it).second.second;
- callback(param);
+ callback(message);
}
}
- unsigned long mId;
+ unsigned mId;
CallbackLookup mCallbacks;
HandlerLookup mHandlers;
};
-Dispatcher::Dispatcher() :
- mImpl(new Dispatcher::Impl) {}
+Dispatch::Handler::~Handler()
+{
+ if (mId)
+ {
+ mDispatch->removeHandler(mId);
+ }
+}
+
+
+Dispatch::Dispatch() :
+ mImpl(new Dispatch::Impl) {}
-Dispatcher::~Dispatcher() {}
+Dispatch::~Dispatch() {}
-Dispatcher& Dispatcher::getInstance()
+Dispatch& Dispatch::getInstance()
{
- static Dispatcher dispatcher;
- return dispatcher;
+ static Dispatch dispatch;
+ return dispatch;
}
-Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
+Dispatch::Handler Dispatch::addHandler(const std::string& event,
const Function& callback)
{
- return addHandler(message, callback, mImpl->getNewHandler());
+ return addHandler(event, callback, mImpl->getNewHandler());
}
-Dispatcher::Handler Dispatcher::addHandler(const std::string& message,
- const Function& callback, Handler id)
+Dispatch::Handler Dispatch::addHandler(const std::string& event,
+ const Function& callback, Handler handler)
{
// pass through
- return mImpl->addHandler(message, callback, id);
+ return mImpl->addHandler(event, callback, handler);
}
-void Dispatcher::removeHandler(Handler id)
+void Dispatch::removeHandler(unsigned id)
{
// pass through
return mImpl->removeHandler(id);
}
-void Dispatcher::dispatch(const std::string& message, const Notification* param)
+void Dispatch::dispatch(const std::string& event, const Message* message)
{
// pass through
- mImpl->dispatch(message, param);
+ mImpl->dispatch(event, message);
}