Replaced WriteRegistersToTarget event with TC command

src/EventManager/Events/Event.hpp

@@ -26,7 +26,6 @@ namespace Bloom::Events
         SHUTDOWN_APPLICATION,
         DEBUG_SERVER_THREAD_STATE_CHANGED,
         SHUTDOWN_DEBUG_SERVER,
-        WRITE_REGISTERS_TO_TARGET,
         REGISTERS_WRITTEN_TO_TARGET,
         TARGET_EXECUTION_RESUMED,
         TARGET_EXECUTION_STOPPED,

src/EventManager/Events/Events.hpp

@@ -13,7 +13,6 @@
 #include "ShutdownApplication.hpp"
 #include "DebugServerThreadStateChanged.hpp"
 #include "ShutdownDebugServer.hpp"
-#include "WriteRegistersToTarget.hpp"
 #include "RegistersWrittenToTarget.hpp"
 #include "TargetExecutionResumed.hpp"
 #include "TargetExecutionStopped.hpp"

src/EventManager/Events/WriteRegistersToTarget.hpp

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <string>
-#include <utility>
-
-#include "Event.hpp"
-#include "RegistersWrittenToTarget.hpp"
-#include "src/Targets/TargetRegister.hpp"
-
-namespace Bloom::Events
-{
-    class WriteRegistersToTarget: public Event
-    {
-    public:
-        using TargetControllerResponseType = RegistersWrittenToTarget;
-
-        static constexpr EventType type = EventType::WRITE_REGISTERS_TO_TARGET;
-        static inline const std::string name = "WriteRegistersToTarget";
-        Targets::TargetRegisters registers;
-
-        WriteRegistersToTarget() = default;
-        explicit WriteRegistersToTarget(Targets::TargetRegisters registers): registers(std::move(registers)) {};
-
-        [[nodiscard]] EventType getType() const override {
-            return WriteRegistersToTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return WriteRegistersToTarget::name;
-        }
-    };
-}

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>();
+        this->commandManager.sendCommandAndWaitForResponse(
-        event->registers = std::move(registers);
+            std::make_unique<WriteTargetRegisters>(registers),
-
+            this->defaultTimeout
-        this->triggerTargetControllerEventAndWaitForResponse(event);
+        );
     }
 
     TargetMemoryBuffer TargetControllerConsole::readMemory(