Replaced WriteRegistersToTarget event with TC command

src/TargetController/Commands/CommandTypes.hpp

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

src/TargetController/Commands/WriteTargetRegisters.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <optional>
+
+#include "Command.hpp"
+
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::TargetController::Commands
+{
+    class WriteTargetRegisters: public Command
+    {
+    public:
+        static constexpr CommandType type = CommandType::WRITE_TARGET_REGISTERS;
+        static inline const std::string name = "WriteTargetRegisters";
+
+        Targets::TargetRegisters registers;
+
+        explicit WriteTargetRegisters(const Targets::TargetRegisters& registers)
+            : registers(registers)
+        {};
+
+        [[nodiscard]] CommandType getType() const override {
+            return WriteTargetRegisters::type;
+        }
+    };
+}

src/TargetController/TargetControllerComponent.cpp

@@ -26,6 +26,7 @@ namespace Bloom::TargetController
     using Commands::ResumeTargetExecution;
     using Commands::ResetTarget;
     using Commands::ReadTargetRegisters;
+    using Commands::WriteTargetRegisters;
 
     using Responses::Response;
     using Responses::TargetRegistersRead;
@@ -377,11 +378,11 @@ namespace Bloom::TargetController
         this->deregisterCommandHandler(ResumeTargetExecution::type);
         this->deregisterCommandHandler(ResetTarget::type);
         this->deregisterCommandHandler(ReadTargetRegisters::type);
+        this->deregisterCommandHandler(WriteTargetRegisters::type);
 
         this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
         this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
         this->eventListener->deregisterCallbacksForEventType<Events::StepTargetExecution>();
-        this->eventListener->deregisterCallbacksForEventType<Events::WriteRegistersToTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::RetrieveMemoryFromTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::WriteMemoryToTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::SetBreakpointOnTarget>();
@@ -423,6 +424,10 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::handleReadTargetRegisters, this, std::placeholders::_1)
         );
 
+        this->registerCommandHandler<WriteTargetRegisters>(
+            std::bind(&TargetControllerComponent::handleWriteTargetRegisters, this, std::placeholders::_1)
+        );
+
         this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
             std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
         );
@@ -435,10 +440,6 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onStepTargetExecutionEvent, this, std::placeholders::_1)
         );
 
-        this->eventListener->registerCallbackForEventType<Events::WriteRegistersToTarget>(
-            std::bind(&TargetControllerComponent::onWriteRegistersEvent, this, std::placeholders::_1)
-        );
-
         this->eventListener->registerCallbackForEventType<Events::RetrieveMemoryFromTarget>(
             std::bind(&TargetControllerComponent::onReadMemoryEvent, this, std::placeholders::_1)
         );
@@ -771,6 +772,17 @@ namespace Bloom::TargetController
         return std::make_unique<TargetRegistersRead>(this->target->readRegisters(command.descriptors));
     }
 
+    std::unique_ptr<Response> TargetControllerComponent::handleWriteTargetRegisters(WriteTargetRegisters& command) {
+        this->target->writeRegisters(command.registers);
+
+        auto registersWrittenEvent = std::make_shared<Events::RegistersWrittenToTarget>();
+        registersWrittenEvent->registers = command.registers;
+
+        EventManager::triggerEvent(registersWrittenEvent);
+
+        return std::make_unique<Response>();
+    }
+
     void TargetControllerComponent::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
         try {
             if (this->target->getState() != TargetState::STOPPED) {
@@ -795,22 +807,6 @@ namespace Bloom::TargetController
         }
     }
 
-    void TargetControllerComponent::onWriteRegistersEvent(const Events::WriteRegistersToTarget& event) {
-        try {
-            this->target->writeRegisters(event.registers);
-
-            auto registersWrittenEvent = std::make_shared<Events::RegistersWrittenToTarget>();
-            registersWrittenEvent->correlationId = event.id;
-            registersWrittenEvent->registers = event.registers;
-
-            EventManager::triggerEvent(registersWrittenEvent);
-
-        } catch (const TargetOperationFailure& exception) {
-            Logger::error("Failed to write registers to target - " + exception.getMessage());
-            this->emitErrorEvent(event.id, exception.getMessage());
-        }
-    }
-
     void TargetControllerComponent::onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event) {
         try {
             auto memoryReadEvent = std::make_shared<Events::MemoryRetrievedFromTarget>();

src/TargetController/TargetControllerComponent.hpp

@@ -21,6 +21,7 @@
 #include "Commands/ResumeTargetExecution.hpp"
 #include "Commands/ResetTarget.hpp"
 #include "Commands/ReadTargetRegisters.hpp"
+#include "Commands/WriteTargetRegisters.hpp"
 
 // Responses
 #include "Responses/Response.hpp"
@@ -296,6 +297,7 @@ namespace Bloom::TargetController
         std::unique_ptr<Responses::TargetRegistersRead> handleReadTargetRegisters(
             Commands::ReadTargetRegisters& command
         );
+        std::unique_ptr<Responses::Response> handleWriteTargetRegisters(Commands::WriteTargetRegisters& command);
 
         /**
          * Will attempt to step execution on the target and emit a TargetExecutionResumed event.
@@ -304,13 +306,6 @@ namespace Bloom::TargetController
          */
         void onStepTargetExecutionEvent(const Events::StepTargetExecution& event);
 
-        /**
-         * Will attempt to write the specified register values and emit a RegistersWrittenToTarget event.
-         *
-         * @param event
-         */
-        void onWriteRegistersEvent(const Events::WriteRegistersToTarget& event);
-
         /**
          * Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event.
          *

src/TargetController/TargetControllerConsole.cpp

@@ -7,6 +7,7 @@
 #include "Commands/ResumeTargetExecution.hpp"
 #include "Commands/ResetTarget.hpp"
 #include "Commands/ReadTargetRegisters.hpp"
+#include "Commands/WriteTargetRegisters.hpp"
 
 #include "src/Logger/Logger.hpp"
 
@@ -20,6 +21,7 @@ namespace Bloom::TargetController
     using Commands::ResumeTargetExecution;
     using Commands::ResetTarget;
     using Commands::ReadTargetRegisters;
+    using Commands::WriteTargetRegisters;
 
     TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
         : eventListener(eventListener)
@@ -84,10 +86,10 @@ namespace Bloom::TargetController
     }
 
     void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
-        auto event = std::make_shared<WriteRegistersToTarget>();
-        event->registers = std::move(registers);
-
-        this->triggerTargetControllerEventAndWaitForResponse(event);
+        this->commandManager.sendCommandAndWaitForResponse(
+            std::make_unique<WriteTargetRegisters>(registers),
+            this->defaultTimeout
+        );
     }
 
     TargetMemoryBuffer TargetControllerConsole::readMemory(