Tidied structure of all classes within the entire code base

Also some other small bits of tidying

src/EventManager/EventListener.cpp

@@ -1,5 +1,7 @@
 #include "EventListener.hpp"
 
+#include "src/Logger/Logger.hpp"
+
 using namespace Bloom;
 using namespace Bloom::Events;
 
@@ -7,11 +9,6 @@ std::set<Events::EventType> EventListener::getRegisteredEventTypes() {
     return this->registeredEventTypes.getValue();
 }
 
-void EventListener::clearAllCallbacks() {
-    auto lock = this->eventTypeToCallbacksMapping.acquireLock();
-    this->eventTypeToCallbacksMapping.getReference().clear();
-}
-
 void EventListener::registerEvent(SharedGenericEventPointer event) {
     Logger::debug("Event \"" + event->getName() + "\" (" + std::to_string(event->id)
         + ") registered for listener " + this->name);
@@ -26,45 +23,6 @@ void EventListener::registerEvent(SharedGenericEventPointer event) {
     }
 }
 
-std::vector<SharedGenericEventPointer> EventListener::getEvents() {
-    auto queueLock = this->eventQueueByEventType.acquireLock();
-    auto& eventQueueByType = this->eventQueueByEventType.getReference();
-    std::vector<SharedGenericEventPointer> output;
-
-    for (auto& eventQueue: eventQueueByType) {
-        if (!eventQueue.second.empty()) {
-            output.push_back(std::move(eventQueue.second.front()));
-            eventQueue.second.pop();
-        }
-    }
-
-    std::sort(output.begin(), output.end(), [](const SharedGenericEventPointer& a, const SharedGenericEventPointer& b) {
-        return a->id < b->id;
-    });
-
-    return output;
-}
-
-void EventListener::dispatchEvent(const SharedGenericEventPointer& event) {
-    Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ").");
-    // Dispatch the event to all registered handlers
-    auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
-    auto& callbacks = this->eventTypeToCallbacksMapping.getReference().find(event->getType())->second;
-    mappingLock.unlock();
-
-    for (auto& callback : callbacks) {
-        callback(*(event.get()));
-    }
-}
-
-void EventListener::dispatchCurrentEvents() {
-    auto events = this->getEvents();
-
-    for (auto const& event: events) {
-        dispatchEvent(event);
-    }
-}
-
 void EventListener::waitAndDispatch(int msTimeout) {
     auto queueLock = this->eventQueueByEventType.acquireLock();
     auto& eventQueueByType = this->eventQueueByEventType.getReference();
@@ -95,3 +53,47 @@ void EventListener::waitAndDispatch(int msTimeout) {
 
     this->dispatchCurrentEvents();
 }
+
+void EventListener::dispatchEvent(const SharedGenericEventPointer& event) {
+    Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ").");
+    // Dispatch the event to all registered handlers
+    auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock();
+    auto& callbacks = this->eventTypeToCallbacksMapping.getReference().find(event->getType())->second;
+    mappingLock.unlock();
+
+    for (auto& callback : callbacks) {
+        callback(*(event.get()));
+    }
+}
+
+void EventListener::dispatchCurrentEvents() {
+    auto events = this->getEvents();
+
+    for (auto const& event: events) {
+        dispatchEvent(event);
+    }
+}
+
+std::vector<SharedGenericEventPointer> EventListener::getEvents() {
+    auto queueLock = this->eventQueueByEventType.acquireLock();
+    auto& eventQueueByType = this->eventQueueByEventType.getReference();
+    std::vector<SharedGenericEventPointer> output;
+
+    for (auto& eventQueue: eventQueueByType) {
+        if (!eventQueue.second.empty()) {
+            output.push_back(std::move(eventQueue.second.front()));
+            eventQueue.second.pop();
+        }
+    }
+
+    std::sort(output.begin(), output.end(), [](const SharedGenericEventPointer& a, const SharedGenericEventPointer& b) {
+        return a->id < b->id;
+    });
+
+    return output;
+}
+
+void EventListener::clearAllCallbacks() {
+    auto lock = this->eventTypeToCallbacksMapping.acquireLock();
+    this->eventTypeToCallbacksMapping.getReference().clear();
+}

src/EventManager/EventListener.hpp

@@ -14,7 +14,6 @@
 #include <set>
 
 #include "src/EventManager/Events/Events.hpp"
-#include "src/Logger/Logger.hpp"
 #include "src/Helpers/SyncSafe.hpp"
 #include "src/Helpers/EventNotifier.hpp"
 
@@ -42,41 +41,6 @@ namespace Bloom
      */
     class EventListener
     {
-    private:
-        /**
-         * Human readable name for event listeners.
-         *
-         * TODO: This was useful during development, but may no longer be needed.
-         */
-        std::string name;
-
-        static inline std::atomic<std::size_t> lastId = 0;
-        std::size_t id = ++(EventListener::lastId);
-
-        /**
-         * Holds all events registered to this listener.
-         *
-         * Events are grouped by event type, and removed from their queue just *before* the dispatching to
-         * registered handlers begins.
-         */
-        SyncSafe<std::map<Events::EventType, std::queue<Events::SharedGenericEventPointer>>> eventQueueByEventType;
-        std::condition_variable eventQueueByEventTypeCV;
-
-        /**
-         * A mapping of event types to a vector of callback functions. Events will be dispatched to these
-         * callback functions, during a call to EventListener::dispatchEvent().
-         *
-         * Each callback will be passed a reference to the event (we wrap all registered callbacks in a lambda, where
-         * we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType()
-         * for more)
-         */
-        SyncSafe<std::map<Events::EventType, std::vector<std::function<void(const Events::Event&)>>>> eventTypeToCallbacksMapping;
-        SyncSafe<std::set<Events::EventType>> registeredEventTypes;
-
-        std::shared_ptr<EventNotifier> interruptEventNotifier = nullptr;
-
-        std::vector<Events::SharedGenericEventPointer> getEvents();
-
     public:
         explicit EventListener(std::string name): name(std::move(name)) {};
 
@@ -370,6 +334,41 @@ namespace Bloom
          * Removes all callbacks registered for the event listener.
          */
         void clearAllCallbacks();
+
+    private:
+        /**
+         * Human readable name for event listeners.
+         *
+         * TODO: This was useful during development, but may no longer be needed.
+         */
+        std::string name;
+
+        static inline std::atomic<std::size_t> lastId = 0;
+        std::size_t id = ++(EventListener::lastId);
+
+        /**
+         * Holds all events registered to this listener.
+         *
+         * Events are grouped by event type, and removed from their queue just *before* the dispatching to
+         * registered handlers begins.
+         */
+        SyncSafe<std::map<Events::EventType, std::queue<Events::SharedGenericEventPointer>>> eventQueueByEventType;
+        std::condition_variable eventQueueByEventTypeCV;
+
+        /**
+         * A mapping of event types to a vector of callback functions. Events will be dispatched to these
+         * callback functions, during a call to EventListener::dispatchEvent().
+         *
+         * Each callback will be passed a reference to the event (we wrap all registered callbacks in a lambda, where
+         * we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType()
+         * for more)
+         */
+        SyncSafe<std::map<Events::EventType, std::vector<std::function<void(const Events::Event&)>>>> eventTypeToCallbacksMapping;
+        SyncSafe<std::set<Events::EventType>> registeredEventTypes;
+
+        std::shared_ptr<EventNotifier> interruptEventNotifier = nullptr;
+
+        std::vector<Events::SharedGenericEventPointer> getEvents();
     };
 
     /**

src/EventManager/EventManager.hpp

@@ -19,13 +19,6 @@ namespace Bloom
      */
     class EventManager
     {
-    private:
-        /**
-         * A mapping of listener IDs to registered listeners. Each registered listener is given an interger ID.
-         */
-        std::map<size_t, std::shared_ptr<EventListener>> registeredListeners;
-        std::mutex registerListenerMutex;
-
     public:
         /**
          * Registers an EventListener instance with this manager.
@@ -62,5 +55,12 @@ namespace Bloom
          * @return
          */
         bool isEventTypeListenedFor(Events::EventType eventType);
+
+    private:
+        /**
+         * A mapping of listener IDs to registered listeners. Each registered listener is given an interger ID.
+         */
+        std::map<size_t, std::shared_ptr<EventListener>> registeredListeners;
+        std::mutex registerListenerMutex;
     };
 }

src/EventManager/Events/DebugServerThreadStateChanged.hpp

@@ -9,8 +9,6 @@ namespace Bloom::Events
 {
     class DebugServerThreadStateChanged: public Event
     {
-    private:
-        ThreadState state;
     public:
         static inline EventType type = EventType::DEBUG_SERVER_THREAD_STATE_CHANGED;
         static inline const std::string name = "DebugServerThreadStateChanged";
@@ -28,5 +26,8 @@ namespace Bloom::Events
         [[nodiscard]] ThreadState getState() const {
             return this->state;
         }
+
+    private:
+        ThreadState state;
     };
 }

src/EventManager/Events/Event.hpp

@@ -55,9 +55,6 @@ namespace Bloom::Events
 
     class Event
     {
-    private:
-        static inline std::atomic<int> lastEventId = 0;
-
     public:
         int id = ++(Event::lastEventId);
         QDateTime createdTimestamp = DateTime::currentDateTime();
@@ -73,5 +70,8 @@ namespace Bloom::Events
         [[nodiscard]] virtual EventType getType() const {
             return Event::type;
         }
+
+    private:
+        static inline std::atomic<int> lastEventId = 0;
     };
 }

src/EventManager/Events/InsightThreadStateChanged.hpp

@@ -9,9 +9,6 @@ namespace Bloom::Events
 {
     class InsightThreadStateChanged: public Event
     {
-    private:
-        ThreadState state;
-
     public:
         explicit InsightThreadStateChanged(ThreadState state): state(state) {};
 
@@ -29,5 +26,8 @@ namespace Bloom::Events
         ThreadState getState() const {
             return this->state;
         }
+
+    private:
+        ThreadState state;
     };
 }

src/EventManager/Events/TargetControllerThreadStateChanged.hpp

@@ -9,9 +9,6 @@ namespace Bloom::Events
 {
     class TargetControllerThreadStateChanged: public Event
     {
-    private:
-        ThreadState state;
-
     public:
         static inline EventType type = EventType::TARGET_CONTROLLER_THREAD_STATE_CHANGED;
         static inline const std::string name = "TargetControllerThreadStateChanged";
@@ -29,5 +26,8 @@ namespace Bloom::Events
         ThreadState getState() const {
             return this->state;
         }
+
+    private:
+        ThreadState state;
     };
 }