1 files changed, 100 insertions, 0 deletions

diff --git a/src/Event.cpp b/src/Event.cpp
new file mode 100644
index 0000000..ff16178
--- /dev/null
+++ b/src/Event.cpp
@@ -0,0 +1,100 @@
+#include "Event.hpp"
+#include <easylogging++.h>
+
+std::queue <Event> EventAgregator::eventsToHandle;
+std::mutex EventAgregator::queueMutex;
+bool EventAgregator::isStarted = false;
+std::vector<EventListener*> EventAgregator::listeners;
+std::mutex EventAgregator::listenersMutex;
+
+EventListener::EventListener() {
+    EventAgregator::RegisterListener(*this);
+}
+
+EventListener::~EventListener() {
+    EventAgregator::UnregisterListener(*this);
+}
+
+void EventListener::PushEvent(Event event) {
+    eventsMutex.lock();
+    events.push(event);
+    eventsMutex.unlock();
+}
+
+bool EventListener::IsEventsQueueIsNotEmpty() {
+    eventsMutex.lock();
+    bool value = !events.empty();
+    eventsMutex.unlock();
+    return value;
+}
+
+
+void EventListener::RegisterHandler(EventType type, EventListener::HandlerFunc handler) {
+	handlers[type] = handler;
+}
+
+void EventListener::HandleEvent() {
+    eventsMutex.lock();
+    if (events.empty()) {
+        eventsMutex.unlock();
+        return;
+    }
+    Event event = events.front();
+    events.pop();
+    eventsMutex.unlock();
+    auto function = handlers[event.type];
+    function(event.data);
+}
+
+
+
+void EventAgregator::RegisterListener(EventListener &listener) {
+    listenersMutex.lock();
+    LOG(WARNING)<<"Registered handler "<<&listener;
+    listeners.push_back(&listener);
+    listenersMutex.unlock();
+}
+
+void EventAgregator::UnregisterListener(EventListener &listener) {
+    listenersMutex.lock();
+    LOG(WARNING)<<"Unregistered handler "<<&listener;
+    listeners.erase(std::find(listeners.begin(), listeners.end(), &listener));
+    listenersMutex.unlock();
+}
+
+void EventAgregator::PushEvent(EventType type, EventData data) {
+    Event event;
+    event.type = type;
+    event.data = data;
+    eventsToHandle.push(event);
+    if (!isStarted) {
+        isStarted = true;
+        std::thread(&EventAgregator::EventHandlingLoop).detach();
+    }
+}
+
+void EventAgregator::EventHandlingLoop() {
+    while (true) {
+        queueMutex.lock();
+        if (!eventsToHandle.empty()) {
+            auto queue = eventsToHandle;
+            while (!eventsToHandle.empty())
+                eventsToHandle.pop();
+            queueMutex.unlock();
+
+            while (!queue.empty()) {
+                auto event = queue.front();
+                listenersMutex.lock();
+                for (auto& listener : listeners) {
+                    LOG(ERROR)<<"Listener notified about event";
+                    listener->PushEvent(event);
+                }
+                listenersMutex.unlock();
+                queue.pop();
+            }
+
+            queueMutex.lock();
+        }
+        queueMutex.unlock();
+    }
+}