event

#ifndef ODBCLIB_CORE_EVENT_EVENT_H
#define ODBCLIB_CORE_EVENT_EVENT_H

#include "Event.template"
#include "Event.implement"

#endif

 

#ifndef ODBCLIB_CORE_EVENT_EVENT_TEMPLATE
#define ODBCLIB_CORE_EVENT_EVENT_TEMPLATE

#include <vector>

namespace odbclib
{
	namespace core
	{
		namespace event
		{
			template <typename EventArgType> class EventListener;

			template<typename EventArgType>
			class Event
			{
			public:
				typedef std::vector< EventListener<EventArgType>* > ListenerList;

			public:
				virtual ~Event();
				virtual Event & addListener		(EventListener<EventArgType> &);
				virtual Event & removeListener	(EventListener<EventArgType> &);
				virtual Event & removeListeners	();

				virtual void notifyListeners(EventArgType const&);
			private:
				ListenerList m_listeners;
			};
		}
	}
}

#endif

 

#include "EventListener.template"
#include <algorithm>

namespace odbclib
{
	namespace core
	{
		namespace event
		{
			template<typename T>
			Event<T>::~Event()
			{
				removeListeners();
			}

			template<typename T>
			Event<T> & Event<T>::addListener(EventListener<T> &listener)
			{ 
				m_listeners.push_back(&listener);
				listener.m_events.push_back(this);
				return *this;
			}

			template<typename T>
			Event<T> & Event<T>::removeListener(EventListener<T> &listener)
			{
				m_listeners.erase(
					std::remove(
						m_listeners.begin(),
						m_listeners.end(),
						&listener),
					m_listeners.end());
				listener.m_events.erase(
					std::remove(
						listener.m_events.begin(),
						listener.m_events.end(),
						this),
					listener.m_events.end());
				return *this;
			}

			template<typename T>
			Event<T> & Event<T>::removeListeners()
			{
				ListenerList listeners(m_listeners);
				for(typename ListenerList::iterator iter = listeners.begin();
					iter != listeners.end(); ++iter)
					(*iter)->m_events.erase(
						std::remove(
							(*iter)->m_events.begin(),
							(*iter)->m_events.end(),
							this),
						(*iter)->m_events.end());	
				m_listeners.clear();
				return *this;
			}

			template<typename T>
			void Event<T>::notifyListeners(T const& e)
			{
				ListenerList listeners(m_listeners);
				for(typename ListenerList::iterator iter = listeners.begin();
					iter != listeners.end(); ++iter)
					(*iter)->onEvent(e);
			}
		}
	}
}

 

#ifndef ODBCLIB_CORE_EVENT_EVENTLISTENER_H
#define ODBCLIB_CORE_EVENT_EVENTLISTENER_H

#include "EventListener.template"
#include "EventListener.implement"

#endif

 

#ifndef ODBCILB_CORE_EVENT_EVENTLISTENER_TEMPLATE
#define ODBCILB_CORE_EVENT_EVENTLISTENER_TEMPLATE

#include <vector>

namespace odbclib
{
	namespace core
	{
		namespace event
		{
			template<typename EventArgType> class Event;

			template<typename EventArgType>
			class EventListener
			{
			public:
				typedef std::vector< Event<EventArgType>* > EventList;

				virtual ~EventListener();
				virtual void onEvent(EventArgType const&);

			private:
				EventList m_events;

				friend class Event<EventArgType>;
			};
		}
	}
}

#endif

 

#include "Event.template"

#include <algorithm>

namespace odbclib
{
	namespace core
	{
		namespace event
		{
			template<typename T>
			EventListener<T>::~EventListener()
			{
				EventList events(m_events);
				for(typename EventList::iterator iter = events.begin();
					iter != events.end(); ++iter)
					(*iter)->removeListener(*this);
			}

			template<typename T>
			void EventListener<T>::onEvent(T const& e)
			{
	
			}
		}
	}
}