Replaced RetrieveRegistersFromTarget event with TC command

src/EventManager/Events/Event.hpp

@@ -26,8 +26,6 @@ namespace Bloom::Events
         SHUTDOWN_APPLICATION,
         DEBUG_SERVER_THREAD_STATE_CHANGED,
         SHUTDOWN_DEBUG_SERVER,
-        RETRIEVE_REGISTERS_FROM_TARGET,
-        REGISTERS_RETRIEVED_FROM_TARGET,
         WRITE_REGISTERS_TO_TARGET,
         REGISTERS_WRITTEN_TO_TARGET,
         TARGET_EXECUTION_RESUMED,

src/EventManager/Events/Events.hpp

@@ -13,8 +13,6 @@
 #include "ShutdownApplication.hpp"
 #include "DebugServerThreadStateChanged.hpp"
 #include "ShutdownDebugServer.hpp"
-#include "RetrieveRegistersFromTarget.hpp"
-#include "RegistersRetrievedFromTarget.hpp"
 #include "WriteRegistersToTarget.hpp"
 #include "RegistersWrittenToTarget.hpp"
 #include "TargetExecutionResumed.hpp"

src/EventManager/Events/RegistersRetrievedFromTarget.hpp

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Event.hpp"
-#include "src/Targets/TargetRegister.hpp"
-
-namespace Bloom::Events
-{
-    class RegistersRetrievedFromTarget: public Event
-    {
-    public:
-        static constexpr EventType type = EventType::REGISTERS_RETRIEVED_FROM_TARGET;
-        static inline const std::string name = "RegistersRetrievedFromTarget";
-        Targets::TargetRegisters registers;
-
-        [[nodiscard]] EventType getType() const override {
-            return RegistersRetrievedFromTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return RegistersRetrievedFromTarget::name;
-        }
-    };
-}

src/EventManager/Events/RetrieveRegistersFromTarget.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Event.hpp"
-#include "RegistersRetrievedFromTarget.hpp"
-#include "src/Targets/TargetRegister.hpp"
-
-namespace Bloom::Events
-{
-    class RetrieveRegistersFromTarget: public Event
-    {
-    public:
-        using TargetControllerResponseType = RegistersRetrievedFromTarget;
-
-        static constexpr EventType type = EventType::RETRIEVE_REGISTERS_FROM_TARGET;
-        static inline const std::string name = "RetrieveRegistersFromTarget";
-        Targets::TargetRegisterDescriptors descriptors;
-
-        [[nodiscard]] EventType getType() const override {
-            return RetrieveRegistersFromTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return RetrieveRegistersFromTarget::name;
-        }
-    };
-}

src/TargetController/Commands/CommandTypes.hpp

@@ -10,5 +10,6 @@ namespace Bloom::TargetController::Commands
         STOP_TARGET_EXECUTION,
         RESUME_TARGET_EXECUTION,
         RESET_TARGET,
+        READ_TARGET_REGISTERS,
     };
 }

src/TargetController/Commands/ReadTargetRegisters.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <optional>
+
+#include "Command.hpp"
+#include "src/TargetController/Responses/TargetRegistersRead.hpp"
+
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::TargetController::Commands
+{
+    class ReadTargetRegisters: public Command
+    {
+    public:
+        using SuccessResponseType = Responses::TargetRegistersRead;
+
+        static constexpr CommandType type = CommandType::READ_TARGET_REGISTERS;
+        static inline const std::string name = "ReadTargetRegisters";
+
+        Targets::TargetRegisterDescriptors descriptors;
+
+        explicit ReadTargetRegisters(const Targets::TargetRegisterDescriptors& descriptors)
+            : descriptors(descriptors)
+        {};
+
+        [[nodiscard]] CommandType getType() const override {
+            return ReadTargetRegisters::type;
+        }
+    };
+}

src/TargetController/Responses/ResponseTypes.hpp

@@ -8,5 +8,6 @@ namespace Bloom::TargetController::Responses
     {
         GENERIC,
         ERROR,
+        TARGET_REGISTERS_READ,
     };
 }

src/TargetController/Responses/TargetRegistersRead.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Response.hpp"
+
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::TargetController::Responses
+{
+    class TargetRegistersRead: public Response
+    {
+    public:
+        static constexpr ResponseType type = ResponseType::TARGET_REGISTERS_READ;
+
+        Targets::TargetRegisters registers;
+
+        TargetRegistersRead(const Targets::TargetRegisters& registers)
+            : registers(registers)
+        {}
+
+        [[nodiscard]] ResponseType getType() const override {
+            return TargetRegistersRead::type;
+        }
+    };
+}

src/TargetController/TargetControllerComponent.cpp

@@ -25,8 +25,10 @@ namespace Bloom::TargetController
     using Commands::StopTargetExecution;
     using Commands::ResumeTargetExecution;
     using Commands::ResetTarget;
+    using Commands::ReadTargetRegisters;
 
     using Responses::Response;
+    using Responses::TargetRegistersRead;
 
     TargetControllerComponent::TargetControllerComponent(
         const ProjectConfig& projectConfig,
@@ -374,11 +376,11 @@ namespace Bloom::TargetController
         this->deregisterCommandHandler(StopTargetExecution::type);
         this->deregisterCommandHandler(ResumeTargetExecution::type);
         this->deregisterCommandHandler(ResetTarget::type);
+        this->deregisterCommandHandler(ReadTargetRegisters::type);
 
         this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
         this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
         this->eventListener->deregisterCallbacksForEventType<Events::StepTargetExecution>();
-        this->eventListener->deregisterCallbacksForEventType<Events::RetrieveRegistersFromTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::WriteRegistersToTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::RetrieveMemoryFromTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::WriteMemoryToTarget>();
@@ -417,6 +419,10 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::handleResetTarget, this, std::placeholders::_1)
         );
 
+        this->registerCommandHandler<ReadTargetRegisters>(
+            std::bind(&TargetControllerComponent::handleReadTargetRegisters, this, std::placeholders::_1)
+        );
+
         this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
             std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
         );
@@ -429,10 +435,6 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onStepTargetExecutionEvent, this, std::placeholders::_1)
         );
 
-        this->eventListener->registerCallbackForEventType<Events::RetrieveRegistersFromTarget>(
-            std::bind(&TargetControllerComponent::onReadRegistersEvent, this, std::placeholders::_1)
-        );
-
         this->eventListener->registerCallbackForEventType<Events::WriteRegistersToTarget>(
             std::bind(&TargetControllerComponent::onWriteRegistersEvent, this, std::placeholders::_1)
         );
@@ -741,7 +743,7 @@ namespace Bloom::TargetController
         return std::make_unique<Response>();
     }
 
-    std::unique_ptr<Responses::Response> TargetControllerComponent::handleResumeTargetExecution(
+    std::unique_ptr<Response> TargetControllerComponent::handleResumeTargetExecution(
         ResumeTargetExecution& command
     ) {
         if (this->target->getState() != TargetState::RUNNING) {
@@ -758,11 +760,17 @@ namespace Bloom::TargetController
         return std::make_unique<Response>();
     }
 
-    std::unique_ptr<Responses::Response> TargetControllerComponent::handleResetTarget(ResetTarget& command) {
+    std::unique_ptr<Response> TargetControllerComponent::handleResetTarget(ResetTarget& command) {
         this->resetTarget();
         return std::make_unique<Response>();
     }
 
+    std::unique_ptr<TargetRegistersRead> TargetControllerComponent::handleReadTargetRegisters(
+        ReadTargetRegisters& command
+    ) {
+        return std::make_unique<TargetRegistersRead>(this->target->readRegisters(command.descriptors));
+    }
+
     void TargetControllerComponent::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
         try {
             if (this->target->getState() != TargetState::STOPPED) {
@@ -787,23 +795,6 @@ namespace Bloom::TargetController
         }
     }
 
-    void TargetControllerComponent::onReadRegistersEvent(const Events::RetrieveRegistersFromTarget& event) {
-        try {
-            auto registers = this->target->readRegisters(event.descriptors);
-
-            if (registers.size() > 0) {
-                auto registersRetrievedEvent = std::make_shared<Events::RegistersRetrievedFromTarget>();
-                registersRetrievedEvent->correlationId = event.id;
-                registersRetrievedEvent->registers = registers;
-                EventManager::triggerEvent(registersRetrievedEvent);
-            }
-
-        } catch (const TargetOperationFailure& exception) {
-            Logger::error("Failed to read registers from target - " + exception.getMessage());
-            this->emitErrorEvent(event.id, exception.getMessage());
-        }
-    }
-
     void TargetControllerComponent::onWriteRegistersEvent(const Events::WriteRegistersToTarget& event) {
         try {
             this->target->writeRegisters(event.registers);

src/TargetController/TargetControllerComponent.hpp

@@ -20,9 +20,11 @@
 #include "Commands/StopTargetExecution.hpp"
 #include "Commands/ResumeTargetExecution.hpp"
 #include "Commands/ResetTarget.hpp"
+#include "Commands/ReadTargetRegisters.hpp"
 
 // Responses
 #include "Responses/Response.hpp"
+#include "Responses/TargetRegistersRead.hpp"
 
 #include "TargetControllerState.hpp"
 
@@ -291,6 +293,9 @@ namespace Bloom::TargetController
         std::unique_ptr<Responses::Response> handleStopTargetExecution(Commands::StopTargetExecution& command);
         std::unique_ptr<Responses::Response> handleResumeTargetExecution(Commands::ResumeTargetExecution& command);
         std::unique_ptr<Responses::Response> handleResetTarget(Commands::ResetTarget& command);
+        std::unique_ptr<Responses::TargetRegistersRead> handleReadTargetRegisters(
+            Commands::ReadTargetRegisters& command
+        );
 
         /**
          * Will attempt to step execution on the target and emit a TargetExecutionResumed event.
@@ -299,13 +304,6 @@ namespace Bloom::TargetController
          */
         void onStepTargetExecutionEvent(const Events::StepTargetExecution& event);
 
-        /**
-         * Will attempt to read the requested registers and emit a RegistersRetrievedFromTarget event.
-         *
-         * @param event
-         */
-        void onReadRegistersEvent(const Events::RetrieveRegistersFromTarget& event);
-
         /**
          * Will attempt to write the specified register values and emit a RegistersWrittenToTarget event.
          *

src/TargetController/TargetControllerConsole.cpp

@@ -6,6 +6,7 @@
 #include "Commands/StopTargetExecution.hpp"
 #include "Commands/ResumeTargetExecution.hpp"
 #include "Commands/ResetTarget.hpp"
+#include "Commands/ReadTargetRegisters.hpp"
 
 #include "src/Logger/Logger.hpp"
 
@@ -18,6 +19,7 @@ namespace Bloom::TargetController
     using Commands::StopTargetExecution;
     using Commands::ResumeTargetExecution;
     using Commands::ResetTarget;
+    using Commands::ReadTargetRegisters;
 
     TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
         : eventListener(eventListener)
@@ -75,10 +77,10 @@ namespace Bloom::TargetController
     }
 
     TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
-        auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
+        return this->commandManager.sendCommandAndWaitForResponse(
-        readRegistersEvent->descriptors = descriptors;
+            std::make_unique<ReadTargetRegisters>(descriptors),
-
+            this->defaultTimeout
-        return this->triggerTargetControllerEventAndWaitForResponse(readRegistersEvent)->registers;
+        )->registers;
     }
 
     void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {