Renamed GDB & TargetConrollerConsole read & write register functions/classes to a more generic name.

CMakeLists.txt

@@ -100,8 +100,8 @@ add_executable(Bloom
     src/DebugServers/GdbRsp/CommandPackets/CommandPacket.cpp
     src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.cpp
     src/DebugServers/GdbRsp/CommandPackets/SupportedFeaturesQuery.cpp
-    src/DebugServers/GdbRsp/CommandPackets/ReadGeneralRegisters.cpp
+    src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.cpp
-    src/DebugServers/GdbRsp/CommandPackets/WriteGeneralRegister.cpp
+    src/DebugServers/GdbRsp/CommandPackets/WriteRegister.cpp
     src/DebugServers/GdbRsp/CommandPackets/ContinueExecution.cpp
     src/DebugServers/GdbRsp/CommandPackets/StepExecution.cpp
     src/DebugServers/GdbRsp/CommandPackets/InterruptExecution.cpp

src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.cpp

@@ -24,10 +24,10 @@ std::unique_ptr<CommandPacket> CommandPacketFactory::create(std::vector<unsigned
             return std::make_unique<CommandPackets::SupportedFeaturesQuery>(rawPacket);
 
         } else if (rawPacketString[1] == 'g' || rawPacketString[1] == 'p') {
-            return std::make_unique<CommandPackets::ReadGeneralRegisters>(rawPacket);
+            return std::make_unique<CommandPackets::ReadRegisters>(rawPacket);
 
         } else if (rawPacketString[1] == 'P') {
-            return std::make_unique<CommandPackets::WriteGeneralRegister>(rawPacket);
+            return std::make_unique<CommandPackets::WriteRegister>(rawPacket);
 
         } else if (rawPacketString[1] == 'c') {
             return std::make_unique<CommandPackets::ContinueExecution>(rawPacket);

src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.hpp

@@ -7,8 +7,8 @@
 #include "CommandPacket.hpp"
 #include "InterruptExecution.hpp"
 #include "SupportedFeaturesQuery.hpp"
-#include "ReadGeneralRegisters.hpp"
+#include "ReadRegisters.hpp"
-#include "WriteGeneralRegister.hpp"
+#include "WriteRegister.hpp"
 #include "ReadMemory.hpp"
 #include "WriteMemory.hpp"
 #include "StepExecution.hpp"

src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.cpp

@@ -1,15 +1,15 @@
-#include "ReadGeneralRegisters.hpp"
+#include "ReadRegisters.hpp"
 #include "src/DebugServers/GdbRsp/GdbRspDebugServer.hpp"
 
 using namespace Bloom::DebugServers::Gdb::CommandPackets;
 
-void ReadGeneralRegisters::init() {
+void ReadRegisters::init() {
     if (this->data.size() >= 2 && this->data.front() == 'p') {
         // This command packet is requesting a specific register
         this->registerNumber = static_cast<size_t>(std::stoi(std::string(this->data.begin() + 1, this->data.end())));
     }
 }
 
-void ReadGeneralRegisters::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
+void ReadRegisters::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
     gdbRspDebugServer.handleGdbPacket(*this);
 }

src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.hpp

@@ -7,11 +7,11 @@
 namespace Bloom::DebugServers::Gdb::CommandPackets
 {
     /**
-     * The ReadGeneralRegisters class implements a structure for "g" and "p" command packets. In response to these
+     * The ReadRegisters class implements a structure for "g" and "p" command packets. In response to these
      * packets, the server is expected to send register values for all registers (for "g" packets) or for a single
      * register (for "p" packets).
      */
-    class ReadGeneralRegisters: public CommandPacket
+    class ReadRegisters: public CommandPacket
     {
     private:
         void init();
@@ -26,7 +26,7 @@ namespace Bloom::DebugServers::Gdb::CommandPackets
          */
         std::optional<int> registerNumber;
 
-        explicit ReadGeneralRegisters(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
+        explicit ReadRegisters(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
             init();
         };
 

src/DebugServers/GdbRsp/CommandPackets/WriteRegister.cpp

@@ -1,11 +1,11 @@
-#include "WriteGeneralRegister.hpp"
+#include "WriteRegister.hpp"
 #include "src/DebugServers/GdbRsp/GdbRspDebugServer.hpp"
 #include "src/Exceptions/Exception.hpp"
 
 using namespace Bloom::DebugServers::Gdb::CommandPackets;
 using namespace Bloom::Exceptions;
 
-void WriteGeneralRegister::init() {
+void WriteRegister::init() {
     // The P packet updates a single register
     auto packet = std::string(this->data.begin(), this->data.end());
 
@@ -23,6 +23,6 @@ void WriteGeneralRegister::init() {
     std::reverse(this->registerValue.begin(), this->registerValue.end());
 }
 
-void WriteGeneralRegister::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
+void WriteRegister::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
     gdbRspDebugServer.handleGdbPacket(*this);
 }

src/DebugServers/GdbRsp/CommandPackets/WriteRegister.hpp

@@ -8,10 +8,10 @@
 namespace Bloom::DebugServers::Gdb::CommandPackets
 {
     /**
-     * The WriteGeneralRegisters class implements the structure for "P" packets. Upon receiving this packet,
+     * The WriteRegisters class implements the structure for "P" packets. Upon receiving this packet,
      * server is expected to update a register value to the target.
      */
-    class WriteGeneralRegister: public CommandPacket
+    class WriteRegister: public CommandPacket
     {
     private:
         void init();
@@ -20,7 +20,7 @@ namespace Bloom::DebugServers::Gdb::CommandPackets
         int registerNumber = 0;
         std::vector<unsigned char> registerValue;
 
-        explicit WriteGeneralRegister(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
+        explicit WriteRegister(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
             init();
         };
 

src/DebugServers/GdbRsp/GdbRspDebugServer.cpp

@@ -54,19 +54,20 @@ void GdbRspDebugServer::init() {
     }
 
     if (::setsockopt(
-        socketFileDescriptor,
+            socketFileDescriptor,
-        SOL_SOCKET,
+            SOL_SOCKET,
-        SO_REUSEADDR,
+            SO_REUSEADDR,
-       &this->enableReuseAddressSocketOption,
+            &(this->enableReuseAddressSocketOption),
-        sizeof(this->enableReuseAddressSocketOption)) < 0
+            sizeof(this->enableReuseAddressSocketOption)
+        ) < 0
     ) {
         Logger::error("Failed to set socket SO_REUSEADDR option.");
     }
 
     if (::bind(
-        socketFileDescriptor,
+            socketFileDescriptor,
-        reinterpret_cast<const sockaddr*>(&(this->socketAddress)),
+            reinterpret_cast<const sockaddr*>(&(this->socketAddress)),
-        sizeof(this->socketAddress)
+            sizeof(this->socketAddress)
         ) < 0
     ) {
         throw Exception("Failed to bind address. The selected port number ("
@@ -258,11 +259,12 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::SupportedFeaturesQuery&
     this->clientConnection->writePacket(response);
 }
 
-void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& packet) {
+void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadRegisters& packet) {
-    Logger::debug("Handling ReadGeneralRegisters packet");
+    Logger::debug("Handling ReadRegisters packet");
 
     try {
         auto descriptors = TargetRegisterDescriptors();
+        auto registerNumberToDescriptorMapping = this->getRegisterNumberToDescriptorMapping();
 
         if (packet.registerNumber.has_value()) {
             Logger::debug("Reading register number: " + std::to_string(packet.registerNumber.value()));
@@ -270,14 +272,12 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& pa
 
         } else {
             // Read all descriptors
-            auto descriptorMapping = this->getRegisterNumberToDescriptorMapping();
+            for (auto& descriptor : registerNumberToDescriptorMapping.getMap()) {
-            for (auto& descriptor : descriptorMapping.getMap()) {
                 descriptors.push_back(descriptor.second);
             }
         }
 
-        auto registerSet = this->targetControllerConsole.readGeneralRegisters(descriptors);
+        auto registerSet = this->targetControllerConsole.readRegisters(descriptors);
-        auto registerNumberToDescriptorMapping = this->getRegisterNumberToDescriptorMapping();
 
         /*
          * Remove any registers that are not mapped to GDB register numbers (as we won't know where to place
@@ -332,14 +332,14 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& pa
     }
 }
 
-void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteGeneralRegister& packet) {
+void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteRegister& packet) {
-    Logger::debug("Handling WriteGeneralRegisters packet");
+    Logger::debug("Handling WriteRegister packet");
 
     try {
         auto registerDescriptor = this->getRegisterDescriptorFromNumber(packet.registerNumber);
-        this->targetControllerConsole.writeGeneralRegisters({
+        this->targetControllerConsole.writeRegisters({
-            TargetRegister(registerDescriptor, packet.registerValue)
+                                                         TargetRegister(registerDescriptor, packet.registerValue)
-        });
+                                                     });
         this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
 
     } catch (const Exception& exception) {

src/DebugServers/GdbRsp/GdbRspDebugServer.hpp

@@ -140,10 +140,10 @@ namespace Bloom::DebugServers::Gdb
          *
          * @return
          */
-        virtual BiMap<
+        virtual const BiMap<
             GdbRegisterNumber,
             Targets::TargetRegisterDescriptor
-        > getRegisterNumberToDescriptorMapping() = 0;
+        >& getRegisterNumberToDescriptorMapping() = 0;
 
         /**
          * Obtains the appropriate register descriptor from a register number.
@@ -197,14 +197,14 @@ namespace Bloom::DebugServers::Gdb
          *
          * @param packet
          */
-        virtual void handleGdbPacket(CommandPackets::ReadGeneralRegisters& packet);
+        virtual void handleGdbPacket(CommandPackets::ReadRegisters& packet);
 
         /**
          * Handles the write general register ("P") command packet.
          *
          * @param packet
          */
-        virtual void handleGdbPacket(CommandPackets::WriteGeneralRegister& packet);
+        virtual void handleGdbPacket(CommandPackets::WriteRegister& packet);
 
         /**
          * Handles the continue execution ("c") command packet.

src/TargetController/TargetControllerConsole.cpp

@@ -10,20 +10,20 @@ using namespace Bloom::Events;
 using namespace Bloom::Exceptions;
 
 TargetControllerState TargetControllerConsole::getTargetControllerState() {
-    auto getStateEvent = std::make_shared<Events::ReportTargetControllerState>();
+    auto getStateEvent = std::make_shared<ReportTargetControllerState>();
     this->eventManager.triggerEvent(getStateEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::TargetControllerStateReported,
+        TargetControllerStateReported,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, getStateEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 
-    auto stateReportedEvent = std::get<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value());
+    auto stateReportedEvent = std::get<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value());
     return stateReportedEvent->state;
 }
 
@@ -37,41 +37,41 @@ bool TargetControllerConsole::isTargetControllerInService() noexcept {
 }
 
 Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
-    auto extractEvent = std::make_shared<Events::ExtractTargetDescriptor>();
+    auto extractEvent = std::make_shared<ExtractTargetDescriptor>();
     this->eventManager.triggerEvent(extractEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::TargetDescriptorExtracted,
+        TargetDescriptorExtracted,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, extractEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<TargetDescriptorExtracted>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 
-    auto descriptorExtracted = std::get<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
+    auto descriptorExtracted = std::get<SharedEventPointer<TargetDescriptorExtracted>>(responseEvent.value());
     return descriptorExtracted->targetDescriptor;
 }
 
 void TargetControllerConsole::stopTargetExecution() {
-    auto stopTargetEvent = std::make_shared<Events::StopTargetExecution>();
+    auto stopTargetEvent = std::make_shared<StopTargetExecution>();
     this->eventManager.triggerEvent(stopTargetEvent);
 
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::TargetExecutionStopped,
+        TargetExecutionStopped,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, stopTargetEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<TargetExecutionStopped>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
 void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
-    auto resumeExecutionEvent = std::make_shared<Events::ResumeTargetExecution>();
+    auto resumeExecutionEvent = std::make_shared<ResumeTargetExecution>();
 
     if (fromAddress.has_value()) {
         resumeExecutionEvent->fromProgramCounter = fromAddress.value();
@@ -79,19 +79,19 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
 
     this->eventManager.triggerEvent(resumeExecutionEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::TargetExecutionResumed,
+        TargetExecutionResumed,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, resumeExecutionEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
 void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
-    auto stepExecutionEvent = std::make_shared<Events::StepTargetExecution>();
+    auto stepExecutionEvent = std::make_shared<StepTargetExecution>();
 
     if (fromAddress.has_value()) {
         stepExecutionEvent->fromProgramCounter = fromAddress.value();
@@ -99,51 +99,51 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
 
     this->eventManager.triggerEvent(stepExecutionEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::TargetExecutionResumed,
+        TargetExecutionResumed,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, stepExecutionEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
-TargetRegisters TargetControllerConsole::readGeneralRegisters(TargetRegisterDescriptors descriptors) {
+TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
-    auto readRegistersEvent = std::make_shared<Events::RetrieveRegistersFromTarget>();
+    auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
     readRegistersEvent->descriptors = descriptors;
 
     this->eventManager.triggerEvent(readRegistersEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::RegistersRetrievedFromTarget,
+        RegistersRetrievedFromTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, readRegistersEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<RegistersRetrievedFromTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 
-    auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(
+    auto retrievedRegistersEvent = std::get<SharedEventPointer<RegistersRetrievedFromTarget>>(
         responseEvent.value()
     );
     return retrievedRegistersEvent->registers;
 }
 
-void TargetControllerConsole::writeGeneralRegisters(TargetRegisters registers) {
+void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
-    auto event = std::make_shared<Events::WriteRegistersToTarget>();
+    auto event = std::make_shared<WriteRegistersToTarget>();
-    event->registers = registers;
+    event->registers = std::move(registers);
 
     this->eventManager.triggerEvent(event);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::RegistersWrittenToTarget,
+        RegistersWrittenToTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, event->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<RegistersWrittenToTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
@@ -154,24 +154,24 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
     std::uint32_t startAddress,
     std::uint32_t bytes
 ) {
-    auto readMemoryEvent = std::make_shared<Events::RetrieveMemoryFromTarget>();
+    auto readMemoryEvent = std::make_shared<RetrieveMemoryFromTarget>();
     readMemoryEvent->memoryType = memoryType;
     readMemoryEvent->startAddress = startAddress;
     readMemoryEvent->bytes = bytes;
 
     this->eventManager.triggerEvent(readMemoryEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::MemoryRetrievedFromTarget,
+        MemoryRetrievedFromTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, readMemoryEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<MemoryRetrievedFromTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 
-    auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(
+    auto retrievedRegistersEvent = std::get<SharedEventPointer<MemoryRetrievedFromTarget>>(
         responseEvent.value()
     );
     return retrievedRegistersEvent->data;
@@ -182,67 +182,67 @@ void TargetControllerConsole::writeMemory(
     std::uint32_t startAddress,
     const TargetMemoryBuffer& buffer
 ) {
-    auto writeMemoryEvent = std::make_shared<Events::WriteMemoryToTarget>();
+    auto writeMemoryEvent = std::make_shared<WriteMemoryToTarget>();
     writeMemoryEvent->memoryType = memoryType;
     writeMemoryEvent->startAddress = startAddress;
     writeMemoryEvent->buffer = buffer;
 
     this->eventManager.triggerEvent(writeMemoryEvent);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::MemoryWrittenToTarget,
+        MemoryWrittenToTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, writeMemoryEvent->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<MemoryWrittenToTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
 void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
-    auto event = std::make_shared<Events::SetBreakpointOnTarget>();
+    auto event = std::make_shared<SetBreakpointOnTarget>();
     event->breakpoint = breakpoint;
 
     this->eventManager.triggerEvent(event);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::BreakpointSetOnTarget,
+        BreakpointSetOnTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, event->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<BreakpointSetOnTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
 void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
-    auto event = std::make_shared<Events::RemoveBreakpointOnTarget>();
+    auto event = std::make_shared<RemoveBreakpointOnTarget>();
     event->breakpoint = breakpoint;
 
     this->eventManager.triggerEvent(event);
     auto responseEvent = this->eventListener.waitForEvent<
-        Events::BreakpointRemovedOnTarget,
+        BreakpointRemovedOnTarget,
-        Events::TargetControllerErrorOccurred
+        TargetControllerErrorOccurred
     >(this->defaultTimeout, event->id);
 
     if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
+        || !std::holds_alternative<SharedEventPointer<BreakpointRemovedOnTarget>>(responseEvent.value())
     ) {
         throw Exception("Unexpected response from TargetController");
     }
 }
 
 void TargetControllerConsole::requestPinStates(int variantId) {
-    auto requestEvent = std::make_shared<Events::RetrieveTargetPinStates>();
+    auto requestEvent = std::make_shared<RetrieveTargetPinStates>();
     requestEvent->variantId = variantId;
 
     this->eventManager.triggerEvent(requestEvent);
 }
 
 void TargetControllerConsole::setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState) {
-    auto updateEvent = std::make_shared<Events::SetTargetPinState>();
+    auto updateEvent = std::make_shared<SetTargetPinState>();
     updateEvent->variantId = variantId;
     updateEvent->pinDescriptor = std::move(pinDescriptor);
     updateEvent->pinState = pinState;

src/TargetController/TargetControllerConsole.hpp

@@ -75,14 +75,14 @@ namespace Bloom
          *
          * @return
          */
-        Targets::TargetRegisters readGeneralRegisters(Targets::TargetRegisterDescriptors descriptors);
+        Targets::TargetRegisters readRegisters(const Targets::TargetRegisterDescriptors& descriptors);
 
         /**
          * Requests the TargetController to write register values to the target.
          *
          * @param registers
          */
-        void writeGeneralRegisters(Targets::TargetRegisters registers);
+        void writeRegisters(const Targets::TargetRegisters& registers);
 
         /**
          * Requests the TargetController to read memory from the target.