Beautifully broken

src/EventBroker.h

@@ -23,19 +23,22 @@ class BaseEventRelay
 friend class EventBroker;
 
 protected:
-	BaseEventRelay(std::string typeName)
-		: m_TypeName(typeName), m_Broker(nullptr) { }
+	BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
+		: m_ContextTypeName(contextTypeName)
+		, m_EventTypeName(eventTypeName)
+		, m_Broker(nullptr) { }
 	~BaseEventRelay();
 
 public:
-	virtual bool Receive(const Event &event) = 0;
+	virtual bool Receive(std::shared_ptr<Event> event) = 0;
 
 protected:
-	std::string m_TypeName;
+	std::string m_ContextTypeName;
+	std::string m_EventTypeName;
 	EventBroker* m_Broker;
 };
 
-template <typename EventType>
+template <typename ContextType, typename EventType>
 class EventRelay : public BaseEventRelay
 {
 public:
@@ -43,24 +46,24 @@ public:
 
 	EventRelay()
 		: m_Callback(nullptr)
-		, BaseEventRelay(typeid(EventType).name()) { }
+		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) { }
 	EventRelay(CallbackType callback) 
 		: m_Callback(callback)
-		, BaseEventRelay(typeid(EventType).name()) { }
+		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) { }
 
 protected:
-	bool Receive(const Event &event) override;
+	bool Receive(std::shared_ptr<Event> event) override;
 
 private:
 	CallbackType m_Callback;
 };
 
-template <typename EventType>
-bool EventRelay<EventType>::Receive(const Event &event)
+template <typename ContextType, typename EventType>
+bool EventRelay<ContextType, EventType>::Receive(std::shared_ptr<Event> event)
 {
 	if (m_Callback != nullptr)
 	{
-		return m_Callback(static_cast<const EventType&>(event));
+		return m_Callback(static_cast<const EventType&>(*event.get()));
 	}
 	else
 	{
@@ -70,27 +73,66 @@ bool EventRelay<EventType>::Receive(const Event &event)
 
 class EventBroker
 {
-template <typename EventType> friend class EventRelay;
+template <typename ContextType, typename EventType> friend class EventRelay;
 
 public:
+	EventBroker()
+	{
+		m_EventQueueRead = std::make_shared<EventQueue_t>();
+		m_EventQueueWrite = std::make_shared<EventQueue_t>();
+	}
+
+	void Subscribe(BaseEventRelay &relay);
 	template <typename EventType>
 	void Publish(const EventType &event);
-	void Subscribe(BaseEventRelay &relay);
+	// Process all events no matter the context.
+	/*void Process()
+	{
+
+	}*/
+	/*
+		Process all events in a given context.
+		Returns: Number of events processed
+	*/
+	template <typename ContextType>
+	int Process();
+	int Process(std::string contextTypeName);
+	void Clear();
 	void Unsubscribe(BaseEventRelay &relay);
 
 private:
-	std::unordered_multimap<std::string, BaseEventRelay*> m_Subscribers;
+	typedef std::string ContextTypeName_t; // typeid(ContextType).name()
+	typedef std::string EventTypeName_t; // typeid(EventType).name()
+
+	typedef std::unordered_map<EventTypeName_t, BaseEventRelay*> EventRelays_t;
+	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextSubscribers_t;
+	ContextSubscribers_t m_ContextSubscribers;
+
+	typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
+	std::shared_ptr<EventQueue_t> m_EventQueueRead;
+	std::shared_ptr<EventQueue_t> m_EventQueueWrite;
 };
 
 
 template <typename EventType>
 void EventBroker::Publish(const EventType &event)
 {
-	auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
+	/*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
 	for (auto it = itpair.first; it != itpair.second; ++it)
 	{
 		it->second->Receive(event);
-	}
+	}*/
+
+	m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<Event>(new EventType(event))));
 }
 
+template <typename ContextType>
+int EventBroker::Process()
+{
+	const std::string contextTypeName = typeid(ContextType).name();
+	return Process(contextTypeName);
+}
+
+
+
 #endif // MessageRelay_h__