Made EventManager class static

src/Application.cpp

@@ -88,7 +88,7 @@ namespace Bloom
 
     void Application::startup() {
         auto& applicationEventListener = this->applicationEventListener;
-        this->eventManager.registerListener(applicationEventListener);
+        EventManager::registerListener(applicationEventListener);
         applicationEventListener->registerCallbackForEventType<Events::ShutdownApplication>(
             std::bind(&Application::onShutdownApplicationRequest, this, std::placeholders::_1)
         );
@@ -378,7 +378,7 @@ namespace Bloom
 
         auto targetControllerState = this->targetController->getThreadState();
         if (targetControllerState == ThreadState::STARTING || targetControllerState == ThreadState::READY) {
-            this->eventManager.triggerEvent(std::make_shared<Events::ShutdownTargetController>());
+            EventManager::triggerEvent(std::make_shared<Events::ShutdownTargetController>());
             this->applicationEventListener->waitForEvent<Events::TargetControllerThreadStateChanged>(
                 std::chrono::milliseconds(10000)
             );
@@ -422,7 +422,7 @@ namespace Bloom
 
         auto debugServerState = this->debugServer->getThreadState();
         if (debugServerState == ThreadState::STARTING || debugServerState == ThreadState::READY) {
-            this->eventManager.triggerEvent(std::make_shared<Events::ShutdownDebugServer>());
+            EventManager::triggerEvent(std::make_shared<Events::ShutdownDebugServer>());
             this->applicationEventListener->waitForEvent<Events::DebugServerThreadStateChanged>(
                 std::chrono::milliseconds(5000)
             );

src/DebugServers/DebugServer.cpp

@@ -30,7 +30,7 @@ namespace Bloom::DebugServers
         this->setName("DS");
         Logger::info("Starting DebugServer");
 
-        this->eventManager.registerListener(this->eventListener);
+        EventManager::registerListener(this->eventListener);
 
         this->interruptEventNotifier = std::make_shared<EventNotifier>();
         this->eventListener->setInterruptEventNotifier(this->interruptEventNotifier);
@@ -57,7 +57,7 @@ namespace Bloom::DebugServers
         Logger::info("Shutting down DebugServer");
         this->close();
         this->setThreadStateAndEmitEvent(ThreadState::STOPPED);
-        this->eventManager.deregisterListener(this->eventListener->getId());
+        EventManager::deregisterListener(this->eventListener->getId());
     }
 
     void DebugServer::onShutdownDebugServerEvent(const Events::ShutdownDebugServer& event) {

src/DebugServers/DebugServer.hpp

@@ -107,7 +107,7 @@ namespace Bloom::DebugServers
          */
         void setThreadStateAndEmitEvent(ThreadState state) {
             Thread::setThreadState(state);
-            this->eventManager.triggerEvent(
+            EventManager::triggerEvent(
                 std::make_shared<Events::DebugServerThreadStateChanged>(state)
             );
         }

src/DebugServers/GdbRsp/GdbRspDebugServer.cpp

@@ -383,7 +383,7 @@ namespace Bloom::DebugServers::Gdb
 
                 this->clientConnection->accept(this->serverSocketFileDescriptor);
                 Logger::info("Accepted GDP RSP connection from " + this->clientConnection->getIpAddress());
-                this->eventManager.triggerEvent(std::make_shared<Events::DebugSessionStarted>());
+                EventManager::triggerEvent(std::make_shared<Events::DebugSessionStarted>());
 
                 /*
                  * Before proceeding with a new debug session, we must ensure that the TargetController is able to

src/DebugServers/GdbRsp/GdbRspDebugServer.hpp

@@ -190,7 +190,7 @@ namespace Bloom::DebugServers::Gdb
             if (this->clientConnection.has_value()) {
                 this->clientConnection->close();
                 this->clientConnection = std::nullopt;
-                this->eventManager.triggerEvent(std::make_shared<Events::DebugSessionFinished>());
+                EventManager::triggerEvent(std::make_shared<Events::DebugSessionFinished>());
             }
         }
 

src/EventManager/EventManager.hpp

@@ -9,19 +9,13 @@
 namespace Bloom
 {
     /**
-     * The EventManager class provides a method of dispatching events to a set of listeners.
+     * The static EventManager class provides a method of dispatching events to a set of listeners.
-     * A single instance of this class is created in Application class. That instance is then passed by references to
-     * all other components in Bloom, that require the ability to trigger events.
-     *
-     * @TODO: Should this be a static class? As in, all methods and variables declared static. We seem to be
-     *        using it in that way. It would save us from having to pass around that single instance by reference.
-     *        Something to consider.
      */
     class EventManager
     {
     public:
         /**
-         * Registers an EventListener instance with this manager.
+         * Registers an EventListener instance with the manager.
          *
          * All EventListener instances must be registered with the EventManager before any events can
          * be dispatched to them.
@@ -30,7 +24,7 @@ namespace Bloom
          *
          * @param listenerName
          */
-        void registerListener(std::shared_ptr<EventListener> listener);
+        static void registerListener(std::shared_ptr<EventListener> listener);
 
         /**
          * Deregister an EventListener instance.
@@ -38,7 +32,7 @@ namespace Bloom
          * @param listenerId
          *  The ID of the EventListener to deregister. See EventListener::getId();
          */
-        void deregisterListener(size_t listenerId);
+        static void deregisterListener(size_t listenerId);
 
         /**
          * Dispatches an event to all registered listeners, if they have registered an interest in the event type.
@@ -46,7 +40,7 @@ namespace Bloom
          *
          * @param event
          */
-        void triggerEvent(const Events::SharedGenericEventPointer& event);
+        static void triggerEvent(const Events::SharedGenericEventPointer& event);
 
         /**
          * Checks if any registered listener is listening for a particular event type.
@@ -54,7 +48,7 @@ namespace Bloom
          * @param eventType
          * @return
          */
-        bool isEventTypeListenedFor(Events::EventType eventType);
+        static bool isEventTypeListenedFor(Events::EventType eventType);
 
     private:
         /**

src/Insight/InsightWorker/InsightWorker.cpp

@@ -24,7 +24,7 @@ namespace Bloom
 
     void InsightWorker::startup() {
         Logger::debug("Starting InsightWorker thread");
-        this->eventManager.registerListener(this->eventListener);
+        EventManager::registerListener(this->eventListener);
 
         this->eventListener->registerCallbackForEventType<Events::TargetControllerStateReported>(
             std::bind(&InsightWorker::onTargetControllerStateReportedEvent, this, std::placeholders::_1)
@@ -48,7 +48,7 @@ namespace Bloom
 
         QObject::connect(this, &InsightWorker::taskQueued, this, &InsightWorker::executeTasks);
 
-        this->eventManager.triggerEvent(
+        EventManager::triggerEvent(
             std::make_shared<Events::InsightThreadStateChanged>(ThreadState::READY)
         );
 

src/SignalHandler/SignalHandler.cpp

@@ -78,6 +78,6 @@ namespace Bloom
         }
 
         Logger::info("Attempting clean shutdown");
-        this->eventManager.triggerEvent(std::make_shared<Events::ShutdownApplication>());
+        EventManager::triggerEvent(std::make_shared<Events::ShutdownApplication>());
     }
 }

src/TargetController/TargetController.cpp

@@ -73,7 +73,7 @@ namespace Bloom
         Logger::info("Starting TargetController");
         this->setThreadState(ThreadState::STARTING);
         this->blockAllSignalsOnCurrentThread();
-        this->eventManager.registerListener(this->eventListener);
+        EventManager::registerListener(this->eventListener);
 
         // Install Bloom's udev rules if not already installed
         TargetController::checkUdevRules();
@@ -132,7 +132,7 @@ namespace Bloom
 
         try {
             Logger::info("Shutting down TargetController");
-            this->eventManager.deregisterListener(this->eventListener->getId());
+            EventManager::deregisterListener(this->eventListener->getId());
             this->releaseHardware();
 
         } catch (const std::exception& exception) {
@@ -184,9 +184,7 @@ namespace Bloom
         this->registerAddressRangeByMemoryType.clear();
 
         this->state = TargetControllerState::SUSPENDED;
-        this->eventManager.triggerEvent(
+        EventManager::triggerEvent(std::make_shared<TargetControllerStateReported>(this->state));
-            std::make_shared<TargetControllerStateReported>(this->state)
-        );
 
         Logger::debug("TargetController suspended");
     }
@@ -260,7 +258,7 @@ namespace Bloom
         );
 
         this->state = TargetControllerState::ACTIVE;
-        this->eventManager.triggerEvent(
+        EventManager::triggerEvent(
             std::make_shared<TargetControllerStateReported>(this->state)
         );
 
@@ -435,7 +433,7 @@ namespace Bloom
 
             if (newTargetState == TargetState::STOPPED) {
                 Logger::debug("Target state changed - STOPPED");
-                this->eventManager.triggerEvent(std::make_shared<TargetExecutionStopped>(
+                EventManager::triggerEvent(std::make_shared<TargetExecutionStopped>(
                     this->target->getProgramCounter(),
                     TargetBreakCause::UNKNOWN
                 ));
@@ -443,7 +441,7 @@ namespace Bloom
 
             if (newTargetState == TargetState::RUNNING) {
                 Logger::debug("Target state changed - RUNNING");
-                this->eventManager.triggerEvent(std::make_shared<TargetExecutionResumed>());
+                EventManager::triggerEvent(std::make_shared<TargetExecutionResumed>());
             }
         }
     }
@@ -452,7 +450,7 @@ namespace Bloom
         auto errorEvent = std::make_shared<Events::TargetControllerErrorOccurred>();
         errorEvent->correlationId = correlationId;
         errorEvent->errorMessage = errorMessage;
-        this->eventManager.triggerEvent(errorEvent);
+        EventManager::triggerEvent(errorEvent);
     }
 
     Targets::TargetDescriptor& TargetController::getTargetDescriptor() {
@@ -470,7 +468,7 @@ namespace Bloom
     void TargetController::onStateReportRequest(const Events::ReportTargetControllerState& event) {
         auto stateEvent = std::make_shared<Events::TargetControllerStateReported>(this->state);
         stateEvent->correlationId = event.id;
-        this->eventManager.triggerEvent(stateEvent);
+        EventManager::triggerEvent(stateEvent);
     }
 
     void TargetController::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) {
@@ -478,7 +476,7 @@ namespace Bloom
         targetDescriptorExtracted->targetDescriptor = this->getTargetDescriptor();
 
         targetDescriptorExtracted->correlationId = event.id;
-        this->eventManager.triggerEvent(targetDescriptorExtracted);
+        EventManager::triggerEvent(targetDescriptorExtracted);
     }
 
     void TargetController::onDebugSessionStartedEvent(const Events::DebugSessionStarted&) {
@@ -519,7 +517,7 @@ namespace Bloom
         );
 
         executionStoppedEvent->correlationId = event.id;
-        this->eventManager.triggerEvent(executionStoppedEvent);
+        EventManager::triggerEvent(executionStoppedEvent);
     }
 
     void TargetController::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
@@ -538,7 +536,7 @@ namespace Bloom
 
             auto executionResumedEvent = std::make_shared<Events::TargetExecutionResumed>();
             executionResumedEvent->correlationId = event.id;
-            this->eventManager.triggerEvent(executionResumedEvent);
+            EventManager::triggerEvent(executionResumedEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to step execution on target - " + exception.getMessage());
@@ -559,7 +557,7 @@ namespace Bloom
 
             auto executionResumedEvent = std::make_shared<Events::TargetExecutionResumed>();
             executionResumedEvent->correlationId = event.id;
-            this->eventManager.triggerEvent(executionResumedEvent);
+            EventManager::triggerEvent(executionResumedEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to resume execution on target - " + exception.getMessage());
@@ -575,7 +573,7 @@ namespace Bloom
                 auto registersRetrievedEvent = std::make_shared<Events::RegistersRetrievedFromTarget>();
                 registersRetrievedEvent->correlationId = event.id;
                 registersRetrievedEvent->registers = registers;
-                this->eventManager.triggerEvent(registersRetrievedEvent);
+                EventManager::triggerEvent(registersRetrievedEvent);
             }
 
         } catch (const TargetOperationFailure& exception) {
@@ -592,7 +590,7 @@ namespace Bloom
             registersWrittenEvent->correlationId = event.id;
             registersWrittenEvent->registers = event.registers;
 
-            this->eventManager.triggerEvent(registersWrittenEvent);
+            EventManager::triggerEvent(registersWrittenEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to write registers to target - " + exception.getMessage());
@@ -611,7 +609,7 @@ namespace Bloom
                 event.excludedAddressRanges
             );
 
-            this->eventManager.triggerEvent(memoryReadEvent);
+            EventManager::triggerEvent(memoryReadEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to read memory from target - " + exception.getMessage());
@@ -629,9 +627,9 @@ namespace Bloom
 
             auto memoryWrittenEvent = std::make_shared<Events::MemoryWrittenToTarget>();
             memoryWrittenEvent->correlationId = event.id;
-            this->eventManager.triggerEvent(memoryWrittenEvent);
+            EventManager::triggerEvent(memoryWrittenEvent);
 
-            if (this->eventManager.isEventTypeListenedFor(Events::RegistersWrittenToTarget::type)
+            if (EventManager::isEventTypeListenedFor(Events::RegistersWrittenToTarget::type)
                 && this->registerDescriptorsByMemoryType.contains(event.memoryType)
             ) {
                 /*
@@ -665,7 +663,7 @@ namespace Bloom
                         ));
                     }
 
-                    this->eventManager.triggerEvent(registersWrittenEvent);
+                    EventManager::triggerEvent(registersWrittenEvent);
                 }
             }
 
@@ -681,7 +679,7 @@ namespace Bloom
             auto breakpointSetEvent = std::make_shared<Events::BreakpointSetOnTarget>();
             breakpointSetEvent->correlationId = event.id;
 
-            this->eventManager.triggerEvent(breakpointSetEvent);
+            EventManager::triggerEvent(breakpointSetEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to set breakpoint on target - " + exception.getMessage());
@@ -695,7 +693,7 @@ namespace Bloom
             auto breakpointRemovedEvent = std::make_shared<Events::BreakpointRemovedOnTarget>();
             breakpointRemovedEvent->correlationId = event.id;
 
-            this->eventManager.triggerEvent(breakpointRemovedEvent);
+            EventManager::triggerEvent(breakpointRemovedEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to remove breakpoint on target - " + exception.getMessage());
@@ -715,7 +713,7 @@ namespace Bloom
             auto programCounterSetEvent = std::make_shared<Events::ProgramCounterSetOnTarget>();
             programCounterSetEvent->correlationId = event.id;
 
-            this->eventManager.triggerEvent(programCounterSetEvent);
+            EventManager::triggerEvent(programCounterSetEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to set program counter on target - " + exception.getMessage());
@@ -749,7 +747,7 @@ namespace Bloom
             pinStatesRetrieved->variantId = event.variantId;
             pinStatesRetrieved->pinSatesByNumber = this->target->getPinStates(event.variantId);
 
-            this->eventManager.triggerEvent(pinStatesRetrieved);
+            EventManager::triggerEvent(pinStatesRetrieved);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to retrieve target pin states - " + exception.getMessage());
@@ -774,7 +772,7 @@ namespace Bloom
                 {event.pinDescriptor.number, event.pinState}
             };
 
-            this->eventManager.triggerEvent(pinStatesUpdateEvent);
+            EventManager::triggerEvent(pinStatesUpdateEvent);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to set target pin state for pin " + event.pinDescriptor.name + " - "
@@ -795,7 +793,7 @@ namespace Bloom
             stackPointerRetrieved->correlationId = event.id;
             stackPointerRetrieved->stackPointer = this->target->getStackPointer();
 
-            this->eventManager.triggerEvent(stackPointerRetrieved);
+            EventManager::triggerEvent(stackPointerRetrieved);
 
         } catch (const TargetOperationFailure& exception) {
             Logger::error("Failed to retrieve stack pointer value from target - " + exception.getMessage());

src/TargetController/TargetController.hpp

@@ -207,7 +207,7 @@ namespace Bloom
          */
         void setThreadStateAndEmitEvent(ThreadState state) {
             this->setThreadState(state);
-            this->eventManager.triggerEvent(
+            EventManager::triggerEvent(
                 std::make_shared<Events::TargetControllerThreadStateChanged>(state)
             );
         }

src/TargetController/TargetControllerConsole.cpp

@@ -117,7 +117,7 @@ namespace Bloom
         auto requestEvent = std::make_shared<RetrieveTargetPinStates>();
         requestEvent->variantId = variantId;
 
-        this->eventManager.triggerEvent(requestEvent);
+        EventManager::triggerEvent(requestEvent);
     }
 
     Targets::TargetPinStateMappingType TargetControllerConsole::getPinStates(int variantId) {

src/TargetController/TargetControllerConsole.hpp

@@ -207,7 +207,7 @@ namespace Bloom
                 deRegisterEventType = true;
             }
 
-            this->eventManager.triggerEvent(event);
+            EventManager::triggerEvent(event);
 
             auto responseEvent = this->eventListener.waitForEvent<
                 ResponseEventType,