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

diff --git a/src/Moof/Dispatch.cc b/src/Moof/Dispatch.cc
index 8ad29fd..af0faea 100644
--- a/src/Moof/Dispatch.cc
+++ b/src/Moof/Dispatch.cc
@@ -1,30 +1,13 @@
 
-/*******************************************************************************
-
- Copyright (c) 2009, Charles McGarvey
- All rights reserved.
- 
- Redistribution   and   use  in  source  and  binary  forms,  with  or  without
- modification, are permitted provided that the following conditions are met:
- 
-   * Redistributions  of  source  code  must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-   * Redistributions  in binary form must reproduce the above copyright notice,
-     this  list of conditions and the following disclaimer in the documentation
-     and/or other materials provided with the distribution.
- 
- THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*******************************************************************************/
+/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
+**]  All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
 
 #include <map>
 
@@ -38,45 +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)
 				{
@@ -86,78 +69,81 @@ 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& Dispatch::getInstance()
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+									 const Function& callback)
 {
-	static Dispatch dispatch;
-	return dispatch;
+	return addTarget(event, callback, mImpl->getNewHandle());
 }
 
-
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-		const Function& callback)
+Dispatch::Handle Dispatch::addTarget(const std::string& event,
+									 const Function& callback,
+									 Handle handle)
 {
-	return addHandler(event, callback, mImpl->getNewHandler());
+	// pass through
+	return mImpl->addTarget(event, callback, handle);
 }
 
-Dispatch::Handler Dispatch::addHandler(const std::string& event,
-		const Function& callback, Handler handler)
+
+void Dispatch::removeTarget(unsigned id)
 {
 	// pass through
-	return mImpl->addHandler(event, callback, handler);
+	return mImpl->removeTarget(id);
 }
 
 
-void Dispatch::removeHandler(unsigned id)
+void Dispatch::dispatch(const std::string& event)
 {
 	// pass through
-	return mImpl->removeHandler(id);
+	mImpl->dispatch(event);
 }
 
 
-void Dispatch::dispatch(const std::string& event, const Message* message)
+Dispatch& Dispatch::global()
 {
-	// pass through
-	mImpl->dispatch(event, message);
+	static Dispatch dispatch;
+	return dispatch;
 }
 
 
 } // namespace Mf
 
-/** vim: set ts=4 sw=4 tw=80: *************************************************/
-