Replaced ReportTargetControllerState event with TC command and renamed TargetControllerStateReported event

src/TargetController/Commands/CommandTypes.hpp

@@ -7,6 +7,7 @@ namespace Bloom::TargetController::Commands
     enum class CommandType: std::uint8_t
     {
         GENERIC,
+        GET_TARGET_CONTROLLER_STATE,
         STOP_TARGET_EXECUTION,
         RESUME_TARGET_EXECUTION,
         RESET_TARGET,

src/TargetController/TargetControllerComponent.cpp

@@ -92,6 +92,10 @@ namespace Bloom::TargetController
         this->shutdown();
     }
 
+    TargetControllerState TargetControllerComponent::getState() {
+        return TargetControllerComponent::state;
+    }
+
     void TargetControllerComponent::registerCommand(std::unique_ptr<Command> command) {
         auto commandQueueLock = TargetControllerComponent::commandQueue.acquireLock();
         TargetControllerComponent::commandQueue.getValue().push(std::move(command));
@@ -149,10 +153,6 @@ namespace Bloom::TargetController
         TargetControllerComponent::checkUdevRules();
 
         // Register event handlers
-        this->eventListener->registerCallbackForEventType<Events::ReportTargetControllerState>(
-            std::bind(&TargetControllerComponent::onStateReportRequest, this, std::placeholders::_1)
-        );
-
         this->eventListener->registerCallbackForEventType<Events::ShutdownTargetController>(
             std::bind(&TargetControllerComponent::onShutdownTargetControllerEvent, this, std::placeholders::_1)
         );
@@ -400,8 +400,8 @@ namespace Bloom::TargetController
         this->registerDescriptorsByMemoryType.clear();
         this->registerAddressRangeByMemoryType.clear();
 
-        this->state = TargetControllerState::SUSPENDED;
-        EventManager::triggerEvent(std::make_shared<TargetControllerStateReported>(this->state));
+        TargetControllerComponent::state = TargetControllerState::SUSPENDED;
+        EventManager::triggerEvent(std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state));
 
         Logger::debug("TargetController suspended");
     }
@@ -478,9 +478,9 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onRetrieveStackPointerEvent, this, std::placeholders::_1)
         );
 
-        this->state = TargetControllerState::ACTIVE;
+        TargetControllerComponent::state = TargetControllerState::ACTIVE;
         EventManager::triggerEvent(
-            std::make_shared<TargetControllerStateReported>(this->state)
+            std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state)
         );
 
         if (this->target->getState() != TargetState::RUNNING) {
@@ -692,12 +692,6 @@ namespace Bloom::TargetController
         this->shutdown();
     }
 
-    void TargetControllerComponent::onStateReportRequest(const Events::ReportTargetControllerState& event) {
-        auto stateEvent = std::make_shared<Events::TargetControllerStateReported>(this->state);
-        stateEvent->correlationId = event.id;
-        EventManager::triggerEvent(stateEvent);
-    }
-
     void TargetControllerComponent::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) {
         auto targetDescriptorExtracted = std::make_shared<TargetDescriptorExtracted>();
         targetDescriptorExtracted->targetDescriptor = this->getTargetDescriptor();
@@ -707,7 +701,7 @@ namespace Bloom::TargetController
     }
 
     void TargetControllerComponent::onDebugSessionStartedEvent(const Events::DebugSessionStarted&) {
-        if (this->state == TargetControllerState::SUSPENDED) {
+        if (TargetControllerComponent::state == TargetControllerState::SUSPENDED) {
             Logger::debug("Waking TargetController");
 
             this->resume();

src/TargetController/TargetControllerComponent.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <memory>
 #include <queue>
 #include <condition_variable>
@@ -43,6 +44,8 @@
 
 namespace Bloom::TargetController
 {
+    static_assert(std::atomic<TargetControllerState>::is_always_lock_free);
+
     /**
      * The TargetController possesses full control of the debugging target and the debug tool.
      *
@@ -65,6 +68,8 @@ namespace Bloom::TargetController
          */
         void run();
 
+        static TargetControllerState getState();
+
         static void registerCommand(std::unique_ptr<Commands::Command> command);
 
         static std::optional<std::unique_ptr<Responses::Response>> waitForResponse(
@@ -88,7 +93,7 @@ namespace Bloom::TargetController
          * The TC starts off in a suspended state. TargetControllerComponent::resume() is invoked from the startup
          * routine.
          */
-        TargetControllerState state = TargetControllerState::SUSPENDED;
+        static inline std::atomic<TargetControllerState> state = TargetControllerState::SUSPENDED;
 
         ProjectConfig projectConfig;
         EnvironmentConfig environmentConfig;
@@ -265,13 +270,6 @@ namespace Bloom::TargetController
          */
         void onShutdownTargetControllerEvent(const Events::ShutdownTargetController& event);
 
-        /**
-         * Reports the current state of the TargetController.
-         *
-         * @param event
-         */
-        void onStateReportRequest(const Events::ReportTargetControllerState& event);
-
         /**
          * Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event.
          *

src/TargetController/TargetControllerConsole.cpp

@@ -2,6 +2,8 @@
 
 #include "src/EventManager/Events/Events.hpp"
 
+#include "TargetControllerComponent.hpp"
+
 // Commands
 #include "Commands/StopTargetExecution.hpp"
 #include "Commands/ResumeTargetExecution.hpp"
@@ -30,9 +32,7 @@ namespace Bloom::TargetController
     {}
 
     TargetControllerState TargetControllerConsole::getTargetControllerState() {
-        return this->triggerTargetControllerEventAndWaitForResponse(
-            std::make_shared<ReportTargetControllerState>()
-        )->state;
+        return TargetControllerComponent::getState();
     }
 
     bool TargetControllerConsole::isTargetControllerInService() noexcept {