Better events

src/EventBroker.cpp

@@ -12,50 +12,50 @@ BaseEventRelay::~BaseEventRelay()
 
 void EventBroker::Unsubscribe(BaseEventRelay &relay) // ?
 {
-	/*auto itpair = m_Subscribers.equal_range(relay.m_EventTypeName);
+	auto contextIt = m_ContextRelays.find(relay.m_ContextTypeName);
+	if (contextIt == m_ContextRelays.end())
+		return;
+
+	auto eventRelays = contextIt->second;
+
+	auto itpair = eventRelays.equal_range(relay.m_EventTypeName);
 	for (auto it = itpair.first; it != itpair.second; ++it)
 	{
-	if (it->second == &relay)
+		if (it->second == &relay)
-	{
+		{
-	m_Subscribers.erase(it);
+			eventRelays.erase(it);
-	break;
+			break;
+		}
 	}
-	}*/
 }
 
 void EventBroker::Subscribe(BaseEventRelay &relay)
 {
 	relay.m_Broker = this;
-	m_ContextSubscribers[relay.m_ContextTypeName][relay.m_EventTypeName] = &relay;
+	m_ContextRelays[relay.m_ContextTypeName].insert(std::make_pair(relay.m_EventTypeName, &relay));
 }
 
 int EventBroker::Process(std::string contextTypeName)
 {
-	auto it = m_ContextSubscribers.find(contextTypeName);
+	auto it = m_ContextRelays.find(contextTypeName);
-	if (it == m_ContextSubscribers.end())
+	if (it == m_ContextRelays.end())
 		return 0;
 
-	int eventsProcessed = 0;
-
 	EventRelays_t &relays = it->second;
+
+	int eventsProcessed = 0;
 	for (auto &pair : *m_EventQueueRead)
 	{
 		std::string &eventTypeName = pair.first;
 		std::shared_ptr<Event> event = pair.second;
 
-		/*if (eventTypeName == "struct Events::BindKey")
+		auto itpair = relays.equal_range(eventTypeName);
+		for (auto it2 = itpair.first; it2 != itpair.second; ++it2)
 		{
-			auto bindKey = static_cast<Events::BindKey*>(event.get());
+			auto relay = it2->second;
-			LOG_DEBUG("HsssEJ");
+			relay->Receive(event);
-		}*/
+			eventsProcessed++;
-
+		}
-		auto it2 = relays.find(eventTypeName);
-		if (it2 == relays.end())
-			continue;
-
-		auto relay = it2->second;
-		relay->Receive(event);
-		eventsProcessed++;
 	}
 
 	return eventsProcessed;

src/EventBroker.h

@@ -3,6 +3,7 @@
 
 #include <typeinfo>
 #include <functional>
+#include <map>
 #include <unordered_map>
 #include <list>
 
@@ -30,7 +31,7 @@ protected:
 	~BaseEventRelay();
 
 public:
-	virtual bool Receive(std::shared_ptr<Event> event) = 0;
+	virtual bool Receive(const std::shared_ptr<Event> event) = 0;
 
 protected:
 	std::string m_ContextTypeName;
@@ -52,18 +53,18 @@ public:
 		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) { }
 
 protected:
-	bool Receive(std::shared_ptr<Event> event) override;
+	bool Receive(const std::shared_ptr<Event> event) override;
 
 private:
 	CallbackType m_Callback;
 };
 
 template <typename ContextType, typename EventType>
-bool EventRelay<ContextType, EventType>::Receive(std::shared_ptr<Event> event)
+bool EventRelay<ContextType, EventType>::Receive(const std::shared_ptr<Event> event)
 {
 	if (m_Callback != nullptr)
 	{
-		return m_Callback(static_cast<const EventType&>(*event.get()));
+		return m_Callback(*static_cast<const EventType*>(event.get()));
 	}
 	else
 	{
@@ -99,21 +100,22 @@ public:
 	int Process(std::string contextTypeName);
 	void Clear();
 	void Unsubscribe(BaseEventRelay &relay);
+	template <typename ContextType>
+	void UnsubscribeAll();
 
 private:
 	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_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
-	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextSubscribers_t;
+	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
-	ContextSubscribers_t m_ContextSubscribers;
+	ContextRelays_t m_ContextRelays;
 
 	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)
 {
@@ -123,7 +125,7 @@ void EventBroker::Publish(const EventType &event)
 		it->second->Receive(event);
 	}*/
 
-	m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<Event>(new EventType(event))));
+	m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
 }
 
 template <typename ContextType>
@@ -133,6 +135,15 @@ int EventBroker::Process()
 	return Process(contextTypeName);
 }
 
-
+template <typename ContextType>
+void EventBroker::UnsubscribeAll()
+{
+	const std::string contextTypeName = typeid(ContextType).name();
+	auto contextIt = m_ContextRelays.find(contextTypeName);
+	if (contextIt != m_ContextRelays.end())
+	{
+		m_ContextRelays.erase(contextIt);
+	}
+}
 
 #endif // MessageRelay_h__