X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FDispatch.cc;h=af0faea390ce4bb17175607cdeb15813ffd93be7;hp=52f28f88327e2591378819308cb3a832c44e1512;hb=c78934a448d0126709fccec3d5a636b3baa87da4;hpb=837bae9f2bf7b25e1d3d2625eeaf39c1d2f48827

diff --git a/src/Moof/Dispatch.cc b/src/Moof/Dispatch.cc
index 52f28f8..af0faea 100644
--- a/src/Moof/Dispatch.cc
+++ b/src/Moof/Dispatch.cc
@@ -21,46 +21,45 @@ class Dispatch::Impl
 {
 public:
 
-	Impl() :
+	Impl(Dispatch* dispatch) :
+		mDispatch(dispatch),
 		mId(0) {}
 
-	Dispatch::Handler getNewHandler()
+	Dispatch::Handle getNewHandle()
 	{
 		++mId;
-		//return Dispatch::Handler(this, mId);
-		Dispatch::Handler handler(this, mId);
-		return handler;
+		Dispatch::Handle handle(mDispatch->mImpl, mId);
+		return handle;
 	}
 
 	typedef std::pair<unsigned,Dispatch::Function>	Callback;
 	typedef std::multimap<std::string,Callback>		CallbackLookup;
-	typedef CallbackLookup::iterator				CallbackIter;
+	typedef CallbackLookup::iterator				CallbackIt;
 
-	typedef std::multimap<unsigned,std::string>		HandlerLookup;
-	typedef HandlerLookup::iterator					HandlerIter;
+	typedef std::multimap<unsigned,std::string>		HandleLookup;
+	typedef HandleLookup::iterator					HandleIt;
 
 
-	inline Handler addHandler(const std::string& event,
-							  const Function& callback, Handler handler)
+	inline Handle addTarget(const std::string& event,
+							const Function& callback, Handle handle)
 	{
 		mCallbacks.insert(std::make_pair(event,
-						  std::make_pair(handler.getId(), callback)));
-		mHandlers.insert(std::make_pair(handler.getId(), event));
+						  std::make_pair(handle.getId(), callback)));
+		mHandles.insert(std::make_pair(handle.getId(), event));
 
-		return handler;
+		return handle;
 	}
 
-	inline void removeHandler(unsigned id)
+	inline void removeTarget(unsigned id)
 	{
-		std::pair<HandlerIter,HandlerIter>
-			matching(mHandlers.equal_range(id));
+		std::pair<HandleIt,HandleIt> matching(mHandles.equal_range(id));
 
-		for (HandlerIter it = matching.first; it != matching.second; ++it)
+		for (HandleIt it = matching.first; it != matching.second; ++it)
 		{
-			CallbackIter first = mCallbacks.find((*it).second);
-			CallbackIter last = mCallbacks.end();
+			CallbackIt first = mCallbacks.find((*it).second);
+			CallbackIt last = mCallbacks.end();
 
-			for (CallbackIter jt = first; jt != last; ++jt)
+			for (CallbackIt jt = first; jt != last; ++jt)
 			{
 				if ((*jt).second.first == id)
 				{
@@ -70,69 +69,79 @@ public:
 			}
 		}
 
-		mHandlers.erase(id);
+		mHandles.erase(id);
 	}
 
-	void dispatch(const std::string& event, const Message* message)
+	void dispatch(const std::string& event)
 	{
-		std::pair<CallbackIter,CallbackIter>
+		std::pair<CallbackIt,CallbackIt>
 			callbacks(mCallbacks.equal_range(event));
 
-		for (CallbackIter it = callbacks.first; it != callbacks.second;
-				++it)
+		for (CallbackIt it = callbacks.first; it != callbacks.second; ++it)
 		{
 			Function callback = (*it).second.second;
-			callback(message);
+			callback();
 		}
 	}
 
 
+	Dispatch*		mDispatch;
+
 	unsigned 		mId;
 
 	CallbackLookup	mCallbacks;
-	HandlerLookup	mHandlers;
+	HandleLookup	mHandles;
 };
 
 
-Dispatch::Handler::~Handler()
+void Dispatch::Handle::clear()
 {
-	if (mId)
+	boost::shared_ptr<Impl> dispatch;
+	if (mId && (dispatch = mDispatch.lock()))
 	{
-		mDispatch->removeHandler(mId);
+		dispatch->removeTarget(mId);
+		mId = 0;
 	}
 }
 
 
 Dispatch::Dispatch() :
-	mImpl(new Dispatch::Impl) {}
+	mImpl(new Dispatch::Impl(this)) {}
 
 
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-									   const Function& callback)
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+									 const Function& callback)
 {
-	return addHandler(event, callback, mImpl->getNewHandler());
+	return addTarget(event, callback, mImpl->getNewHandle());
 }
 
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-									   const Function& callback,
-									   Handler handler)
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+									 const Function& callback,
+									 Handle handle)
 {
 	// pass through
-	return mImpl->addHandler(event, callback, handler);
+	return mImpl->addTarget(event, callback, handle);
 }
 
 
-void Dispatch::removeHandler(unsigned id)
+void Dispatch::removeTarget(unsigned id)
 {
 	// pass through
-	return mImpl->removeHandler(id);
+	return mImpl->removeTarget(id);
 }
 
 
-void Dispatch::dispatch(const std::string& event, const Message* message)
+void Dispatch::dispatch(const std::string& event)
 {
 	// pass through
-	mImpl->dispatch(event, message);
+	mImpl->dispatch(event);
+}
+
+
+Dispatch& Dispatch::global()
+{
+	static Dispatch dispatch;
+	return dispatch;
 }