merge conficts fixed

1 files changed, 48 insertions, 32 deletions

diff --git a/mwe/events/include/eventManager.h b/mwe/events/include/eventManager.h
index b8abccc..91bac8c 100644
--- a/mwe/events/include/eventManager.h
+++ b/mwe/events/include/eventManager.h
@@ -1,57 +1,73 @@
 #pragma once
-#include <unordered_map>
-#include <memory>
 #include "event.h"
-#include "keyCodes.h"
 #include "eventHandler.h"
+#include "keyCodes.h"
+#include <memory>
+#include <unordered_map>
 #include <vector>
 // using EventType = std::uint32_t;
 // using EventId = std::uint64_t;
 
 class EventManager {
 public:
-    EventManager(const EventManager&) = delete;
-    const EventManager& operator=(const EventManager&) = delete;
-    static EventManager& getInstance() {
-        static EventManager instance;
-        return instance;
-    }
+	EventManager(const EventManager &) = delete;
+	const EventManager & operator=(const EventManager &) = delete;
+	static EventManager & getInstance() {
+		static EventManager instance;
+		return instance;
+	}
 
-    void shutdown();
-    void subscribe(int eventType, std::unique_ptr<IEventHandlerWrapper>&& handler, int eventId);
-    void unsubscribe(int eventType, const std::string& handlerName, int eventId);
-    void triggerEvent(const Event& event_, int eventId);
-    void queueEvent(std::unique_ptr<Event>&& event_, int eventId);
-    void dispatchEvents();
+	void shutdown();
+	void subscribe(int eventType,
+				   std::unique_ptr<IEventHandlerWrapper> && handler,
+				   int eventId);
+	void unsubscribe(int eventType, const std::string & handlerName,
+					 int eventId);
+	void triggerEvent(const Event & event_, int eventId);
+	void queueEvent(std::unique_ptr<Event> && event_, int eventId);
+	void dispatchEvents();
 
 private:
+<<<<<<< HEAD
     EventManager() = default;
     std::vector<std::pair<std::unique_ptr<Event>, int>> eventsQueue;
     std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> subscribers;
     std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> subscribersByEventId;
+=======
+	EventManager() = default;
+	std::vector<std::pair<std::unique_ptr<Event>, int>> m_eventsQueue;
+	std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>
+		m_subscribers;
+	std::unordered_map<
+		int, std::unordered_map<
+				 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
+		m_subscribersByEventId;
+>>>>>>> b3b762a34e7ccb4a0dcd041a693ac7180af16002
 };
 
-
-template<typename EventType>
-inline void subscribe(const EventHandler<EventType>& callback, int eventId = 0, const bool unsubscribeOnSuccess = false)
-{
-    std::unique_ptr<IEventHandlerWrapper> handler = std::make_unique<EventHandlerWrapper<EventType>>(callback, unsubscribeOnSuccess);
-    EventManager::getInstance().subscribe(EventType::getStaticEventType(), std::move(handler), eventId);
+template <typename EventType>
+inline void subscribe(const EventHandler<EventType> & callback, int eventId = 0,
+					  const bool unsubscribeOnSuccess = false) {
+	std::unique_ptr<IEventHandlerWrapper> handler
+		= std::make_unique<EventHandlerWrapper<EventType>>(
+			callback, unsubscribeOnSuccess);
+	EventManager::getInstance().subscribe(EventType::getStaticEventType(),
+										  std::move(handler), eventId);
 }
 
-template<typename EventType>
-inline void unsubscribe(const EventHandler<EventType>& callback, int eventId = 0)
-{
-    const std::string handlerName = callback.target_type().name();
-    EventManager::getInstance().unsubscribe(EventType::getStaticEventType(), handlerName, eventId);
+template <typename EventType>
+inline void unsubscribe(const EventHandler<EventType> & callback,
+						int eventId = 0) {
+	const std::string handlerName = callback.target_type().name();
+	EventManager::getInstance().unsubscribe(EventType::getStaticEventType(),
+											handlerName, eventId);
 }
 
-inline void triggerEvent(const Event& triggeredEvent, int eventId = 0)
-{
-    EventManager::getInstance().triggerEvent(triggeredEvent, eventId);
+inline void triggerEvent(const Event & triggeredEvent, int eventId = 0) {
+	EventManager::getInstance().triggerEvent(triggeredEvent, eventId);
 }
 
-inline void queueEvent(std::unique_ptr<Event>&& queuedEvent, int eventId = 0)
-{
-    EventManager::getInstance().queueEvent(std::forward<std::unique_ptr<Event>>(queuedEvent), eventId);
+inline void queueEvent(std::unique_ptr<Event> && queuedEvent, int eventId = 0) {
+	EventManager::getInstance().queueEvent(
+		std::forward<std::unique_ptr<Event>>(queuedEvent), eventId);
 }