Replaced RetrieveMemoryFromTarget event with TC command

src/EventManager/Events/Event.hpp

@@ -29,8 +29,6 @@ namespace Bloom::Events
         REGISTERS_WRITTEN_TO_TARGET,
         TARGET_EXECUTION_RESUMED,
         TARGET_EXECUTION_STOPPED,
-        RETRIEVE_MEMORY_FROM_TARGET,
-        MEMORY_RETRIEVED_FROM_TARGET,
         WRITE_MEMORY_TO_TARGET,
         MEMORY_WRITTEN_TO_TARGET,
         SET_BREAKPOINT_ON_TARGET,

src/EventManager/Events/Events.hpp

@@ -16,8 +16,6 @@
 #include "RegistersWrittenToTarget.hpp"
 #include "TargetExecutionResumed.hpp"
 #include "TargetExecutionStopped.hpp"
-#include "RetrieveMemoryFromTarget.hpp"
-#include "MemoryRetrievedFromTarget.hpp"
 #include "WriteMemoryToTarget.hpp"
 #include "MemoryWrittenToTarget.hpp"
 #include "SetBreakpointOnTarget.hpp"

src/EventManager/Events/MemoryRetrievedFromTarget.hpp

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

src/EventManager/Events/RetrieveMemoryFromTarget.hpp

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-#include "Event.hpp"
-#include "MemoryRetrievedFromTarget.hpp"
-#include "src/Targets/TargetMemory.hpp"
-
-namespace Bloom::Events
-{
-    class RetrieveMemoryFromTarget: public Event
-    {
-    public:
-        using TargetControllerResponseType = MemoryRetrievedFromTarget;
-
-        static constexpr EventType type = EventType::RETRIEVE_MEMORY_FROM_TARGET;
-        static inline const std::string name = "RetrieveMemoryFromTarget";
-        Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;
-        std::uint32_t startAddress = 0;
-        std::uint32_t bytes = 0;
-        std::set<Targets::TargetMemoryAddressRange> excludedAddressRanges;
-
-        [[nodiscard]] EventType getType() const override {
-            return RetrieveMemoryFromTarget::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return RetrieveMemoryFromTarget::name;
-        }
-    };
-}

src/TargetController/Commands/CommandTypes.hpp

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

src/TargetController/Commands/ReadTargetMemory.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <optional>
+
+#include "Command.hpp"
+#include "src/TargetController/Responses/TargetMemoryRead.hpp"
+
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::TargetController::Commands
+{
+    class ReadTargetMemory: public Command
+    {
+    public:
+        using SuccessResponseType = Responses::TargetMemoryRead;
+
+        static constexpr CommandType type = CommandType::READ_TARGET_MEMORY;
+        static inline const std::string name = "ReadTargetMemory";
+
+        Targets::TargetMemoryType memoryType;
+        std::uint32_t startAddress;
+        std::uint32_t bytes;
+        std::set<Targets::TargetMemoryAddressRange> excludedAddressRanges;
+
+        explicit ReadTargetMemory(
+            Targets::TargetMemoryType memoryType,
+            std::uint32_t startAddress,
+            std::uint32_t bytes,
+            const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges
+        )
+            : memoryType(memoryType)
+            , startAddress(startAddress)
+            , bytes(bytes)
+            , excludedAddressRanges(excludedAddressRanges)
+        {};
+
+        [[nodiscard]] CommandType getType() const override {
+            return ReadTargetMemory::type;
+        }
+    };
+}

src/TargetController/Responses/ResponseTypes.hpp

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

src/TargetController/Responses/TargetMemoryRead.hpp

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

src/TargetController/TargetControllerComponent.cpp

@@ -27,9 +27,11 @@ namespace Bloom::TargetController
     using Commands::ResetTarget;
     using Commands::ReadTargetRegisters;
     using Commands::WriteTargetRegisters;
+    using Commands::ReadTargetMemory;
 
     using Responses::Response;
     using Responses::TargetRegistersRead;
+    using Responses::TargetMemoryRead;
 
     TargetControllerComponent::TargetControllerComponent(
         const ProjectConfig& projectConfig,
@@ -379,11 +381,11 @@ namespace Bloom::TargetController
         this->deregisterCommandHandler(ResetTarget::type);
         this->deregisterCommandHandler(ReadTargetRegisters::type);
         this->deregisterCommandHandler(WriteTargetRegisters::type);
+        this->deregisterCommandHandler(ReadTargetMemory::type);
 
         this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
         this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
         this->eventListener->deregisterCallbacksForEventType<Events::StepTargetExecution>();
-        this->eventListener->deregisterCallbacksForEventType<Events::RetrieveMemoryFromTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::WriteMemoryToTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::SetBreakpointOnTarget>();
         this->eventListener->deregisterCallbacksForEventType<Events::RemoveBreakpointOnTarget>();
@@ -428,6 +430,10 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::handleWriteTargetRegisters, this, std::placeholders::_1)
         );
 
+        this->registerCommandHandler<ReadTargetMemory>(
+            std::bind(&TargetControllerComponent::handleReadTargetMemory, this, std::placeholders::_1)
+        );
+
         this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
             std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
         );
@@ -440,10 +446,6 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onStepTargetExecutionEvent, this, std::placeholders::_1)
         );
 
-        this->eventListener->registerCallbackForEventType<Events::RetrieveMemoryFromTarget>(
-            std::bind(&TargetControllerComponent::onReadMemoryEvent, this, std::placeholders::_1)
-        );
-
         this->eventListener->registerCallbackForEventType<Events::WriteMemoryToTarget>(
             std::bind(&TargetControllerComponent::onWriteMemoryEvent, this, std::placeholders::_1)
         );
@@ -783,6 +785,15 @@ namespace Bloom::TargetController
         return std::make_unique<Response>();
     }
 
+    std::unique_ptr<TargetMemoryRead> TargetControllerComponent::handleReadTargetMemory(ReadTargetMemory& command) {
+        return std::make_unique<TargetMemoryRead>(this->target->readMemory(
+            command.memoryType,
+            command.startAddress,
+            command.bytes,
+            command.excludedAddressRanges
+        ));
+    }
+
     void TargetControllerComponent::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
         try {
             if (this->target->getState() != TargetState::STOPPED) {
@@ -807,25 +818,6 @@ namespace Bloom::TargetController
         }
     }
 
-    void TargetControllerComponent::onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event) {
-        try {
-            auto memoryReadEvent = std::make_shared<Events::MemoryRetrievedFromTarget>();
-            memoryReadEvent->correlationId = event.id;
-            memoryReadEvent->data = this->target->readMemory(
-                event.memoryType,
-                event.startAddress,
-                event.bytes,
-                event.excludedAddressRanges
-            );
-
-            EventManager::triggerEvent(memoryReadEvent);
-
-        } catch (const TargetOperationFailure& exception) {
-            Logger::error("Failed to read memory from target - " + exception.getMessage());
-            this->emitErrorEvent(event.id, exception.getMessage());
-        }
-    }
-
     void TargetControllerComponent::onWriteMemoryEvent(const Events::WriteMemoryToTarget& event) {
         try {
             const auto& buffer = event.buffer;

src/TargetController/TargetControllerComponent.hpp

@@ -22,10 +22,12 @@
 #include "Commands/ResetTarget.hpp"
 #include "Commands/ReadTargetRegisters.hpp"
 #include "Commands/WriteTargetRegisters.hpp"
+#include "Commands/ReadTargetMemory.hpp"
 
 // Responses
 #include "Responses/Response.hpp"
 #include "Responses/TargetRegistersRead.hpp"
+#include "Responses/TargetMemoryRead.hpp"
 
 #include "TargetControllerState.hpp"
 
@@ -298,6 +300,7 @@ namespace Bloom::TargetController
             Commands::ReadTargetRegisters& command
         );
         std::unique_ptr<Responses::Response> handleWriteTargetRegisters(Commands::WriteTargetRegisters& command);
+        std::unique_ptr<Responses::TargetMemoryRead> handleReadTargetMemory(Commands::ReadTargetMemory& command);
 
         /**
          * Will attempt to step execution on the target and emit a TargetExecutionResumed event.
@@ -306,13 +309,6 @@ namespace Bloom::TargetController
          */
         void onStepTargetExecutionEvent(const Events::StepTargetExecution& event);
 
-        /**
-         * Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event.
-         *
-         * @param event
-         */
-        void onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event);
-
         /**
          * Will attempt to write memory to the target. On success, a MemoryWrittenToTarget event is emitted.
          *

src/TargetController/TargetControllerConsole.cpp

@@ -8,6 +8,7 @@
 #include "Commands/ResetTarget.hpp"
 #include "Commands/ReadTargetRegisters.hpp"
 #include "Commands/WriteTargetRegisters.hpp"
+#include "Commands/ReadTargetMemory.hpp"
 
 #include "src/Logger/Logger.hpp"
 
@@ -22,6 +23,7 @@ namespace Bloom::TargetController
     using Commands::ResetTarget;
     using Commands::ReadTargetRegisters;
     using Commands::WriteTargetRegisters;
+    using Commands::ReadTargetMemory;
 
     TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
         : eventListener(eventListener)
@@ -98,13 +100,15 @@ namespace Bloom::TargetController
         std::uint32_t bytes,
         const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges
     ) {
-        auto readMemoryEvent = std::make_shared<RetrieveMemoryFromTarget>();
+        return this->commandManager.sendCommandAndWaitForResponse(
-        readMemoryEvent->memoryType = memoryType;
+            std::make_unique<ReadTargetMemory>(
-        readMemoryEvent->startAddress = startAddress;
+                memoryType,
-        readMemoryEvent->bytes = bytes;
+                startAddress,
-        readMemoryEvent->excludedAddressRanges = excludedAddressRanges;
+                bytes,
-
+                excludedAddressRanges
-        return this->triggerTargetControllerEventAndWaitForResponse(readMemoryEvent)->data;
+            ),
+            this->defaultTimeout
+        )->data;
     }
 
     void TargetControllerConsole::writeMemory(