#ifndef CPP_EVENT_HEADER
#define CPP_EVENT_HEADER

#include <map>
	typedef  int CppEventHandler;

	template <typename RT,typename PT>
	class EventHandlerBase1 {public: virtual RT Execute(PT p) = 0; };

	template <typename ListenerT,typename RT,typename PT>
	class EventHandler1 : public EventHandlerBase1<RT,PT>
	{
		typedef RT (ListenerT::*PtrMember)(PT);
		ListenerT* m_object;
		PtrMember m_member;
	public:
		EventHandler1(ListenerT* object, PtrMember member): m_object(object), m_member(member){}
		RT Execute(PT p) {	return (m_object->*m_member)(p);}	
	};

	template <typename RT,typename PT>
	class CppEvent1
	{
		typedef std::map<int,EventHandlerBase1<RT,PT> *> HandlersMap;
		HandlersMap m_handlers;
		int m_count;

	public:
		CppEvent1(): m_count(0) {}
		virtual ~CppEvent1()
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)	delete (it->second);
		}

		template <typename ListenerT>
		CppEventHandler Add(ListenerT* object,RT (ListenerT::*member)(PT))
		{
			typedef RT (ListenerT::*PtrMember)(PT);	
			m_handlers[m_count] = (new EventHandler1<ListenerT,RT,PT>(object,member));
			m_count++;	
			return m_count-1;
		}

		bool Remove(CppEventHandler id)
		{
			HandlersMap::iterator it = m_handlers.find(id);

			if(it == m_handlers.end()) return false;

			delete it->second;
			m_handlers.erase(it);				
			return true;
		}

		RT Execute(PT p)
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)
			{
				it->second->Execute(p);
			}

			return true;
		}
	};

	// do the same for delegates with 2 peters
	template <typename RT,typename PT,typename PT1>
	class EventHandlerBase2
	{
	public:
		virtual RT Execute(PT p,PT1 p1) = 0;
	};

	template <typename ListenerT,typename RT,typename PT,typename PT1>
	class EventHandler2 : public EventHandlerBase2<RT, PT, PT1>
	{
		typedef RT (ListenerT::*PtrMember)(PT,PT1);
		ListenerT* m_object;
		PtrMember m_member;

	public:

		EventHandler2(ListenerT* object, PtrMember member): m_object(object), m_member(member){}

		RT Execute(PT p,PT1 p1)
		{
			return (m_object->*m_member)(p,p1);		
		}	
	};

	template <typename RT,typename PT,typename PT1>
	class CppEvent2
	{
		typedef std::map<int,EventHandlerBase2<RT,PT,PT1> *> HandlersMap;
		HandlersMap m_handlers;
		int m_count;

	public:
		CppEvent2(): m_count(0) {}
		virtual ~CppEvent2()
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)	delete (it->second);
		}


		template <typename ListenerT>
		CppEventHandler Add(ListenerT* object,RT (ListenerT::*member)(PT,PT1))
		{
			typedef RT (ListenerT::*PtrMember)(PT,PT1);	
			m_handlers[m_count] = (new EventHandler2<ListenerT,RT,PT,PT1>(object,member));
			m_count++;	
			return m_count-1;
		}

		bool Remove(CppEventHandler id)
		{
			HandlersMap::iterator it = m_handlers.find(id);

			if(it == m_handlers.end()) return false;

			delete it->second;
			m_handlers.erase(it);
			return true;
		}

		RT Execute(PT p,PT1 p1)
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)
			{
				it->second->Execute(p,p1);
			}

			return true;
		}
	};

	// do the same for delegates with 3 peters
	template <typename RT,typename PT,typename PT1,typename PT2>
	class EventHandlerBase3
	{
	public:
		virtual RT Execute(PT p,PT1 p1,PT2 p2) = 0;
	};

	template <typename ListenerT,typename RT,typename PT,typename PT1,typename PT2>
	class EventHandler3 : public EventHandlerBase3<RT,PT,PT1,PT2>
	{
		typedef RT (ListenerT::*PtrMember)(PT,PT1,PT2);
		ListenerT* m_object;
		PtrMember m_member;

	public:

		EventHandler3(ListenerT* object, PtrMember member): m_object(object), m_member(member){}

		RT Execute(PT p,PT1 p1,PT2 p2)
		{
			return (m_object->*m_member)(p,p1,p2);		
		}	
	};

	template <typename RT,typename PT,typename PT1,typename PT2>
	class CppEvent3
	{
		typedef std::map<int,EventHandlerBase3<RT,PT,PT1,PT2> *> HandlersMap;
		HandlersMap m_handlers;
		int m_count;

	public:
		CppEvent3(): m_count(0) {}
		virtual ~CppEvent3()
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)	delete (it->second);
		}


		template <typename ListenerT>
		CppEventHandler Add(ListenerT* object,RT (ListenerT::*member)(PT,PT1,PT2))
		{
			typedef RT (ListenerT::*PtrMember)(PT,PT1,PT2);	
			m_handlers[m_count] = (new EventHandler3<ListenerT,RT,PT,PT1,PT2>(object,member));
			m_count++;	
			return m_count-1;
		}

		bool Remove(CppEventHandler id)
		{
			HandlersMap::iterator it = m_handlers.find(id);

			if(it == m_handlers.end()) return false;

			delete it->second;
			m_handlers.erase(it);
			return true;
		}

		RT Execute(PT p,PT1 p1,PT2 p2)
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)
			{
				it->second->Execute(p,p1,p2);
			}

			return true;
		}
	};




	// do the same for delegates with 4 peters
	template <typename RT,typename PT0,typename PT1,typename PT2,typename PT3>
	class EventHandlerBase4
	{
	public:
		virtual RT Execute(PT0 p,PT1 p1,PT2 p2,PT3 p3) = 0;
	};

	template <typename ListenerT,typename RT,typename PT0,typename PT1,typename PT2,typename PT3>
	class EventHandler4 : public EventHandlerBase4<RT,PT0,PT1,PT2,PT3>
	{
		typedef RT (ListenerT::*PtrMember)(PT0,PT1,PT2);
		ListenerT* m_object;
		PtrMember m_member;

	public:

		EventHandler4(ListenerT* object, PtrMember member): m_object(object), m_member(member){}

		RT Execute(PT0 p,PT1 p1,PT2 p2,PT3 p3)
		{
			return (m_object->*m_member)(p,p1,p2,p3);		
		}	
	};

	template <typename RT,typename PT0,typename PT1,typename PT2,typename PT3>
	class CppEvent4
	{
		typedef std::map<int,EventHandlerBase4<RT,PT0,PT1,PT2,PT3> *> HandlersMap;
		HandlersMap m_handlers;
		int m_count;

	public:
		CppEvent4(): m_count(0) {}
		virtual ~CppEvent4()
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)	delete (it->second);
		}



		template <typename ListenerT>
		CppEventHandler Add(ListenerT* object,RT (ListenerT::*member)(PT0,PT1,PT2,PT3))
		{
			typedef RT (ListenerT::*PtrMember)(PT0,PT1,PT2,PT3);	
			m_handlers[m_count] = (new EventHandler4<ListenerT,RT,PT0,PT1,PT2,PT3>(object,member));
			m_count++;	
			return m_count-1;
		}

		bool Remove(CppEventHandler id)
		{
			HandlersMap::iterator it = m_handlers.find(id);

			if(it == m_handlers.end()) return false;

			delete it->second;
			m_handlers.erase(it);
			return true;
		}

		RT Execute(PT0 p,PT1 p1,PT2 p2,PT3 p3)
		{
			HandlersMap::iterator it = m_handlers.begin();
			for(; it != m_handlers.end(); it++)
			{
				it->second->Execute(p,p1,p2,p3);
			}

			return true;
		}
	};
#endif