-/*******************************************************************************
-
- 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>
{
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)
{
}
}
- 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);
}
-} // namespace Mf
+Dispatch& Dispatch::global()
+{
+ static Dispatch dispatch;
+ return dispatch;
+}
+
-/** vim: set ts=4 sw=4 tw=80: *************************************************/
+} // namespace Mf
projects / chaz / yoink / blobdiff