Once again, this should have been included in a previous commit, RE renaming compnent state changed events

src/Application.cpp

@@ -54,7 +54,7 @@ int Application::run(const std::vector<std::string>& arguments) {
         }
 
         // Main event loop
-        while (Thread::getState() == ThreadState::READY) {
+        while (Thread::getThreadState() == ThreadState::READY) {
             this->applicationEventListener->waitAndDispatch();
         }
 
@@ -116,7 +116,7 @@ void Application::startup() {
     this->startTargetController();
     this->startDebugServer();
 
-    Thread::setState(ThreadState::READY);
+    Thread::setThreadState(ThreadState::READY);
 }
 
 ApplicationConfig Application::extractConfig() {
@@ -208,18 +208,18 @@ int Application::initProject() {
 }
 
 void Application::shutdown() {
-    auto appState = Thread::getState();
+    auto appState = Thread::getThreadState();
     if (appState == ThreadState::STOPPED || appState == ThreadState::SHUTDOWN_INITIATED) {
         return;
     }
 
-    Thread::setState(ThreadState::SHUTDOWN_INITIATED);
+    Thread::setThreadState(ThreadState::SHUTDOWN_INITIATED);
     Logger::info("Shutting down Bloom");
 
     this->stopDebugServer();
     this->stopTargetController();
 
-    if (this->signalHandler.getState() == ThreadState::READY) {
+    if (this->signalHandler.getThreadState() != ThreadState::STOPPED) {
         // Signal handler is still running
         this->signalHandler.triggerShutdown();
 
@@ -233,7 +233,7 @@ void Application::shutdown() {
         Logger::debug("SignalHandler thread joined");
     }
 
-    Thread::setState(ThreadState::STOPPED);
+    Thread::setThreadState(ThreadState::STOPPED);
 }
 
 void Application::startTargetController() {
@@ -253,7 +253,7 @@ void Application::startTargetController() {
 }
 
 void Application::stopTargetController() {
-    auto targetControllerState = this->targetController.getState();
+    auto targetControllerState = this->targetController.getThreadState();
     if (targetControllerState == ThreadState::STARTING || targetControllerState == ThreadState::READY) {
         this->eventManager.triggerEvent(std::make_shared<Events::ShutdownTargetController>());
         this->applicationEventListener->waitForEvent<Events::TargetControllerThreadStateChanged>(
@@ -299,7 +299,7 @@ void Application::stopDebugServer() {
         return;
     }
 
-    auto debugServerState = this->debugServer->getState();
+    auto debugServerState = this->debugServer->getThreadState();
     if (debugServerState == ThreadState::STARTING || debugServerState == ThreadState::READY) {
         this->eventManager.triggerEvent(std::make_shared<Events::ShutdownDebugServer>());
         this->applicationEventListener->waitForEvent<Events::DebugServerThreadStateChanged>(

src/DebugServers/DebugServer.cpp

@@ -14,7 +14,7 @@ void DebugServer::run() {
 
         Logger::info("DebugServer ready");
 
-        while (this->getState() == ThreadState::READY) {
+        while (this->getThreadState() == ThreadState::READY) {
             this->serve();
             this->eventListener->dispatchCurrentEvents();
         }
@@ -41,21 +41,21 @@ void DebugServer::startup() {
     );
 
     this->init();
-    this->setStateAndEmitEvent(ThreadState::READY);
+    this->setThreadStateAndEmitEvent(ThreadState::READY);
 }
 
 void DebugServer::shutdown() {
-    if (this->getState() == ThreadState::STOPPED || this->getState() == ThreadState::SHUTDOWN_INITIATED) {
+    if (this->getThreadState() == ThreadState::STOPPED || this->getThreadState() == ThreadState::SHUTDOWN_INITIATED) {
         return;
     }
 
-    this->setState(ThreadState::SHUTDOWN_INITIATED);
+    this->setThreadState(ThreadState::SHUTDOWN_INITIATED);
     Logger::info("Shutting down DebugServer");
     this->close();
     this->interruptEventNotifier->close();
-    this->setStateAndEmitEvent(ThreadState::STOPPED);
+    this->setThreadStateAndEmitEvent(ThreadState::STOPPED);
 }
 
 void DebugServer::onShutdownDebugServerEvent(EventPointer<Events::ShutdownDebugServer> event) {
     this->shutdown();
-}
+}

src/DebugServers/DebugServer.hpp

@@ -47,12 +47,12 @@ namespace Bloom::DebugServers
          * @param state
          * @param emitEvent
          */
-        void setStateAndEmitEvent(ThreadState state) {
-            Thread::setState(state);
+        void setThreadStateAndEmitEvent(ThreadState state) {
+            Thread::setThreadState(state);
             this->eventManager.triggerEvent(
                 std::make_shared<Events::DebugServerThreadStateChanged>(state)
             );
-        };
+        }
 
         /**
          * Handles a shutdown request.

src/Helpers/Thread.hpp

@@ -22,7 +22,7 @@ namespace Bloom
         SyncSafe<ThreadState> state = SyncSafe<ThreadState>(ThreadState::UNINITIALISED);
 
     protected:
-        virtual void setState(ThreadState state) {
+        virtual void setThreadState(ThreadState state) {
             this->state.setValue(state);
         };
 
@@ -43,8 +43,8 @@ namespace Bloom
         }
 
     public:
-        virtual ThreadState getState() {
+        virtual ThreadState getThreadState() {
             return this->state.getValue();
         };
     };
-}
+}

src/Insight/Insight.cpp

@@ -1,4 +1,3 @@
-#include <thread>
 #include <typeindex>
 #include <QTimer>
 
@@ -18,7 +17,7 @@ void Insight::run() {
         this->startup();
 
         this->workerThread->start();
-        this->setState(ThreadState::READY);
+        this->setThreadState(ThreadState::READY);
         Logger::info("Insight ready");
         this->application->exec();
 
@@ -36,7 +35,7 @@ void Insight::run() {
 
 void Insight::startup() {
     Logger::info("Starting Insight");
-    this->setState(ThreadState::STARTING);
+    this->setThreadState(ThreadState::STARTING);
     this->eventManager.registerListener(this->eventListener);
 
     this->eventListener->registerCallbackForEventType<ShutdownApplication>(
@@ -97,7 +96,7 @@ void Insight::startup() {
 }
 
 void Insight::shutdown() {
-    if (this->getState() == ThreadState::STOPPED) {
+    if (this->getThreadState() == ThreadState::STOPPED) {
         return;
     }
 
@@ -112,7 +111,7 @@ void Insight::shutdown() {
         this->application->exit(0);
     }
 
-    this->setState(ThreadState::STOPPED);
+    this->setThreadState(ThreadState::STOPPED);
 }
 
 void Insight::onShutdownApplicationEvent(EventPointer<ShutdownApplication>) {

src/Insight/InsightWorker.cpp

@@ -40,7 +40,7 @@ void InsightWorker::startup() {
     this->eventDispatchTimer->start(5);
 
     this->eventManager.triggerEvent(
-        std::make_shared<Events::InsightStateChanged>(ThreadState::READY)
+        std::make_shared<Events::InsightThreadStateChanged>(ThreadState::READY)
     );
 }
 

src/SignalHandler/SignalHandler.cpp

@@ -14,7 +14,7 @@ void SignalHandler::run() {
         int signalNumber = 0;
 
         Logger::debug("SignalHandler ready");
-        while(Thread::getState() == ThreadState::READY) {
+        while(Thread::getThreadState() == ThreadState::READY) {
             if (sigwait(&signalSet, &signalNumber) == 0) {
                 Logger::debug("SIGNAL " + std::to_string(signalNumber) + " received");
                 if (this->handlersMappedBySignalNum.contains(signalNumber)) {
@@ -29,7 +29,7 @@ void SignalHandler::run() {
     }
 
     Logger::debug("SignalHandler shutting down");
-    Thread::setState(ThreadState::STOPPED);
+    Thread::setThreadState(ThreadState::STOPPED);
 }
 
 void SignalHandler::startup() {

src/SignalHandler/SignalHandler.hpp

@@ -50,7 +50,7 @@ namespace Bloom
          * Triggers the shutdown of the SignalHandler thread.
          */
         void triggerShutdown() {
-            this->setState(ThreadState::SHUTDOWN_INITIATED);
+            this->setThreadState(ThreadState::SHUTDOWN_INITIATED);
         };
 
         /**
@@ -61,4 +61,4 @@ namespace Bloom
          */
         void triggerApplicationShutdown();
     };
-}
+}

src/TargetController/TargetController.cpp

@@ -16,7 +16,7 @@ void TargetController::run() {
     try {
         this->startup();
 
-        this->setStateAndEmitEvent(ThreadState::READY);
+        this->setThreadStateAndEmitEvent(ThreadState::READY);
         Logger::debug("TargetController ready and waiting for events.");
 
         while (this->getState() == ThreadState::READY) {
@@ -43,7 +43,7 @@ void TargetController::run() {
 void TargetController::startup() {
     this->setName("TC");
     Logger::info("Starting TargetController");
-    this->setState(ThreadState::STARTING);
+    this->setThreadState(ThreadState::STARTING);
     this->blockAllSignalsOnCurrentThread();
     this->eventManager.registerListener(this->eventListener);
 
@@ -477,7 +477,7 @@ void TargetController::onSetProgramCounterEvent(EventPointer<Events::SetProgramC
 }
 
 // TODO: remove this
-void TargetController::onInsightStateChangedEvent(EventPointer<Events::InsightStateChanged> event) {
+void TargetController::onInsightStateChangedEvent(EventPointer<Events::InsightThreadStateChanged> event) {
     if (event->getState() == ThreadState::READY) {
         /*
          * Insight has just started up.

src/TargetController/TargetController.hpp

@@ -160,12 +160,12 @@ namespace Bloom
          * @param state
          * @param emitEvent
          */
-        void setStateAndEmitEvent(ThreadState state) {
-            this->setState(state);
+        void setThreadStateAndEmitEvent(ThreadState state) {
+            this->setThreadState(state);
             this->eventManager.triggerEvent(
-                std::make_shared<Events::TargetControllerStateChanged>(state)
+                std::make_shared<Events::TargetControllerThreadStateChanged>(state)
             );
-        };
+        }
 
         /**
          * Installs Bloom's udev rules on user's machine. Rules are copied from build/Distribution/Resources/UdevRules