fork(2) download

copy

#include <iostream>
#include <map>
#include <vector>
 
/**
* Receiver
*/
class EBaseReceiver
{
    protected:
        static std::size_t nextId;
};
 
template <typename TEventData>
class Receiver : public EBaseReceiver
{
	friend class EventManager;
    public:
		virtual void onEventReceive( const TEventData& event ) = 0;
        static std::size_t getId() { return ID; }
    private:
         static std::size_t ID;
};
 
/**
* Event
*/
struct BaseEvent
{
    protected:
         static std::size_t nextId;
};
 
template <typename T>
struct Event : public BaseEvent
{
    static std::size_t getId() { return ID; }
	static std::size_t ID;
};
 
/**
* EventManager
*/
class EventManager
{
	private:
 
		typedef std::vector<EBaseReceiver*> 			ReceiverArray;
		typedef std::map<std::size_t, ReceiverArray> 	ImplSubscriberArray;
		ImplSubscriberArray subscribers;
 
	public:
 
		template< class TEvent, template<class> class TReceiver>
		void subscribe( TReceiver<TEvent>* receiver )
		{
    		const std::size_t eventId = TEvent::getId();
    		this->subscribers[eventId].push_back(receiver);
   		}
 
   		template <typename TEvent>
		void emit( const TEvent& event )
		{
			const ReceiverArray& receivers = this->subscribers[TEvent::getId()];
			for( auto& receiver : receivers )
			{
				static_cast<Receiver<TEvent>&>((*receiver)).onEventReceive(event);
			}
		}
};
 
/**
* Test events
*/   
EventManager eventManager;
struct HealthEvent : public Event<HealthEvent>{};
struct DamageEvent : public Event<DamageEvent>{};
 
/**
* Test classes
*/
class DamageSystem : public Receiver<HealthEvent>, public Receiver<DamageEvent>
{
	DamageSystem()
	{
		eventManager.subscribe<HealthEvent>(this);
		eventManager.subscribe<DamageEvent>(this);
	}
 
	void onEventReceive( const HealthEvent& event ) { std::cout << "HealthEvent !" << std::endl; };
	void onEventReceive( const DamageEvent& event ) { std::cout << "DamageEvent !" << std::endl; };
};
 
int main()
{
	DamateSystem system;
	eventManager.emit(DamageEvent());
return 0;
}

prog.cpp: In constructor ‘DamageSystem::DamageSystem()’:
prog.cpp:86:43: error: no matching function for call to ‘EventManager::subscribe(DamageSystem* const)’
   eventManager.subscribe<HealthEvent>(this);
                                           ^
prog.cpp:86:43: note: candidate is:
prog.cpp:55:8: note: template<class TEvent, template<class> class TReceiver> void EventManager::subscribe(TReceiver<TEvent>*)
   void subscribe( TReceiver<TEvent>* receiver )
        ^
prog.cpp:55:8: note:   template argument deduction/substitution failed:
prog.cpp:86:43: note:   can't deduce a template for ‘TReceiver<TEvent>’ from non-template type ‘DamageSystem’
   eventManager.subscribe<HealthEvent>(this);
                                           ^
prog.cpp:87:43: error: no matching function for call to ‘EventManager::subscribe(DamageSystem* const)’
   eventManager.subscribe<DamageEvent>(this);
                                           ^
prog.cpp:87:43: note: candidate is:
prog.cpp:55:8: note: template<class TEvent, template<class> class TReceiver> void EventManager::subscribe(TReceiver<TEvent>*)
   void subscribe( TReceiver<TEvent>* receiver )
        ^
prog.cpp:55:8: note:   template argument deduction/substitution failed:
prog.cpp:87:43: note:   can't deduce a template for ‘TReceiver<TEvent>’ from non-template type ‘DamageSystem’
   eventManager.subscribe<DamageEvent>(this);
                                           ^
prog.cpp: In function ‘int main()’:
prog.cpp:96:2: error: ‘DamateSystem’ was not declared in this scope
  DamateSystem system;
  ^
prog.cpp:96:15: error: expected ‘;’ before ‘system’
  DamateSystem system;
               ^

Standard output is empty