From 092a7df675c5f9d8924dc1758a8b321ee605ba3b Mon Sep 17 00:00:00 2001
From: Nav <nav@navnav.me>
Date: Fri, 20 Aug 2021 22:53:31 +0100
Subject: [PATCH] Updated TargetControllerConsole to use template method for
 triggering events for the TargetController.

---
 .../Events/RemoveBreakpointOnTarget.hpp       |   3 +
 .../Events/ReportTargetControllerState.hpp    |   3 +
 .../Events/ResumeTargetExecution.hpp          |   3 +
 .../Events/RetrieveMemoryFromTarget.hpp       |   3 +
 .../Events/RetrieveRegistersFromTarget.hpp    |   3 +
 .../Events/RetrieveTargetPinStates.hpp        |   3 +
 .../Events/SetBreakpointOnTarget.hpp          |   3 +
 .../Events/SetProgramCounterOnTarget.hpp      |   3 +
 src/EventManager/Events/SetTargetPinState.hpp |   3 +
 .../Events/StepTargetExecution.hpp            |   3 +
 .../Events/StopTargetExecution.hpp            |   3 +
 .../Events/WriteMemoryToTarget.hpp            |   3 +
 .../Events/WriteRegistersToTarget.hpp         |   3 +
 .../TargetControllerConsole.cpp               | 145 ++----------------
 14 files changed, 54 insertions(+), 130 deletions(-)

diff --git a/src/EventManager/Events/RemoveBreakpointOnTarget.hpp b/src/EventManager/Events/RemoveBreakpointOnTarget.hpp
index 3e1adc8e..e82f1b57 100644
--- a/src/EventManager/Events/RemoveBreakpointOnTarget.hpp
+++ b/src/EventManager/Events/RemoveBreakpointOnTarget.hpp
@@ -4,6 +4,7 @@
 #include <string>
 
 #include "Event.hpp"
+#include "BreakpointRemovedOnTarget.hpp"
 #include "src/Targets/TargetBreakpoint.hpp"
 
 namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
     class RemoveBreakpointOnTarget: public Event
     {
     public:
+        using TargetControllerResponseType = BreakpointRemovedOnTarget;
+
         static inline EventType type = EventType::REMOVE_BREAKPOINT_ON_TARGET;
         static inline const std::string name = "RemoveBreakpointOnTarget";
         Targets::TargetBreakpoint breakpoint;
diff --git a/src/EventManager/Events/ReportTargetControllerState.hpp b/src/EventManager/Events/ReportTargetControllerState.hpp
index 32dd56af..5e48b664 100644
--- a/src/EventManager/Events/ReportTargetControllerState.hpp
+++ b/src/EventManager/Events/ReportTargetControllerState.hpp
@@ -3,12 +3,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetControllerStateReported.hpp"
 
 namespace Bloom::Events
 {
     class ReportTargetControllerState: public Event
     {
     public:
+        using TargetControllerResponseType = TargetControllerStateReported;
+
         static inline EventType type = EventType::REPORT_TARGET_CONTROLLER_STATE;
         static inline const std::string name = "ReportTargetControllerState";
 
diff --git a/src/EventManager/Events/ResumeTargetExecution.hpp b/src/EventManager/Events/ResumeTargetExecution.hpp
index 31afb0dd..9faf2ba8 100644
--- a/src/EventManager/Events/ResumeTargetExecution.hpp
+++ b/src/EventManager/Events/ResumeTargetExecution.hpp
@@ -4,12 +4,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetExecutionResumed.hpp"
 
 namespace Bloom::Events
 {
     class ResumeTargetExecution: public Event
     {
     public:
+        using TargetControllerResponseType = TargetExecutionResumed;
+
         static inline EventType type = EventType::RESUME_TARGET_EXECUTION;
         static inline const std::string name = "ResumeTargetExecutionEvent";
         std::optional<std::uint32_t> fromProgramCounter;
diff --git a/src/EventManager/Events/RetrieveMemoryFromTarget.hpp b/src/EventManager/Events/RetrieveMemoryFromTarget.hpp
index a828e7ae..611f0d97 100644
--- a/src/EventManager/Events/RetrieveMemoryFromTarget.hpp
+++ b/src/EventManager/Events/RetrieveMemoryFromTarget.hpp
@@ -4,6 +4,7 @@
 #include <string>
 
 #include "Event.hpp"
+#include "MemoryRetrievedFromTarget.hpp"
 #include "src/Targets/TargetMemory.hpp"
 
 namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
     class RetrieveMemoryFromTarget: public Event
     {
     public:
+        using TargetControllerResponseType = MemoryRetrievedFromTarget;
+
         static inline EventType type = EventType::RETRIEVE_MEMORY_FROM_TARGET;
         static inline const std::string name = "RetrieveMemoryFromTarget";
         Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;
diff --git a/src/EventManager/Events/RetrieveRegistersFromTarget.hpp b/src/EventManager/Events/RetrieveRegistersFromTarget.hpp
index ec819ae5..8cd6fbdb 100644
--- a/src/EventManager/Events/RetrieveRegistersFromTarget.hpp
+++ b/src/EventManager/Events/RetrieveRegistersFromTarget.hpp
@@ -3,6 +3,7 @@
 #include <string>
 
 #include "Event.hpp"
+#include "RegistersRetrievedFromTarget.hpp"
 #include "src/Targets/TargetRegister.hpp"
 
 namespace Bloom::Events
@@ -10,6 +11,8 @@ namespace Bloom::Events
     class RetrieveRegistersFromTarget: public Event
     {
     public:
+        using TargetControllerResponseType = RegistersRetrievedFromTarget;
+
         static inline EventType type = EventType::RETRIEVE_REGISTERS_FROM_TARGET;
         static inline const std::string name = "RetrieveRegistersFromTarget";
         Targets::TargetRegisterDescriptors descriptors;
diff --git a/src/EventManager/Events/RetrieveTargetPinStates.hpp b/src/EventManager/Events/RetrieveTargetPinStates.hpp
index 0f785a4f..59a90eaa 100644
--- a/src/EventManager/Events/RetrieveTargetPinStates.hpp
+++ b/src/EventManager/Events/RetrieveTargetPinStates.hpp
@@ -3,12 +3,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetPinStatesRetrieved.hpp"
 
 namespace Bloom::Events
 {
     class RetrieveTargetPinStates: public Event
     {
     public:
+        using TargetControllerResponseType = TargetPinStatesRetrieved;
+
         static inline EventType type = EventType::RETRIEVE_TARGET_PIN_STATES;
         static inline const std::string name = "RetrieveTargetPinStates";
         int variantId = 0;
diff --git a/src/EventManager/Events/SetBreakpointOnTarget.hpp b/src/EventManager/Events/SetBreakpointOnTarget.hpp
index 46e82f7e..fb3087e1 100644
--- a/src/EventManager/Events/SetBreakpointOnTarget.hpp
+++ b/src/EventManager/Events/SetBreakpointOnTarget.hpp
@@ -4,6 +4,7 @@
 #include <string>
 
 #include "Event.hpp"
+#include "BreakpointSetOnTarget.hpp"
 #include "src/Targets/TargetBreakpoint.hpp"
 
 namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
     class SetBreakpointOnTarget: public Event
     {
     public:
+        using TargetControllerResponseType = BreakpointSetOnTarget;
+
         static inline EventType type = EventType::SET_BREAKPOINT_ON_TARGET;
         static inline const std::string name = "SetBreakpointOnTarget";
         Targets::TargetBreakpoint breakpoint;
diff --git a/src/EventManager/Events/SetProgramCounterOnTarget.hpp b/src/EventManager/Events/SetProgramCounterOnTarget.hpp
index 5ed7fda1..e893a085 100644
--- a/src/EventManager/Events/SetProgramCounterOnTarget.hpp
+++ b/src/EventManager/Events/SetProgramCounterOnTarget.hpp
@@ -4,12 +4,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "ProgramCounterSetOnTarget.hpp"
 
 namespace Bloom::Events
 {
     class SetProgramCounterOnTarget: public Event
     {
     public:
+        using TargetControllerResponseType = ProgramCounterSetOnTarget;
+
         static inline EventType type = EventType::SET_PROGRAM_COUNTER_ON_TARGET;
         static inline const std::string name = "SetProgramCounterOnTarget";
         std::uint32_t address = 0;
diff --git a/src/EventManager/Events/SetTargetPinState.hpp b/src/EventManager/Events/SetTargetPinState.hpp
index 44cb3473..61399e0f 100644
--- a/src/EventManager/Events/SetTargetPinState.hpp
+++ b/src/EventManager/Events/SetTargetPinState.hpp
@@ -3,6 +3,7 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetPinStatesRetrieved.hpp"
 #include "src/Targets/TargetPinDescriptor.hpp"
 
 namespace Bloom::Events
@@ -10,6 +11,8 @@ namespace Bloom::Events
     class SetTargetPinState: public Event
     {
     public:
+        using TargetControllerResponseType = TargetPinStatesRetrieved;
+
         static inline EventType type = EventType::SET_TARGET_PIN_STATE;
         static inline const std::string name = "SetTargetPinState";
         int variantId = 0;
diff --git a/src/EventManager/Events/StepTargetExecution.hpp b/src/EventManager/Events/StepTargetExecution.hpp
index 94d50026..48919995 100644
--- a/src/EventManager/Events/StepTargetExecution.hpp
+++ b/src/EventManager/Events/StepTargetExecution.hpp
@@ -4,12 +4,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetExecutionResumed.hpp"
 
 namespace Bloom::Events
 {
     class StepTargetExecution: public Event
     {
     public:
+        using TargetControllerResponseType = TargetExecutionResumed;
+
         static inline EventType type = EventType::STEP_TARGET_EXECUTION;
         static inline const std::string name = "StepTargetExecution";
         std::optional<std::uint32_t> fromProgramCounter;
diff --git a/src/EventManager/Events/StopTargetExecution.hpp b/src/EventManager/Events/StopTargetExecution.hpp
index a6ec057a..34c96032 100644
--- a/src/EventManager/Events/StopTargetExecution.hpp
+++ b/src/EventManager/Events/StopTargetExecution.hpp
@@ -3,12 +3,15 @@
 #include <string>
 
 #include "Event.hpp"
+#include "TargetExecutionStopped.hpp"
 
 namespace Bloom::Events
 {
     class StopTargetExecution: public Event
     {
     public:
+        using TargetControllerResponseType = TargetExecutionStopped;
+
         static inline EventType type = EventType::STOP_TARGET_EXECUTION;
         static inline const std::string name = "StopTargetExecution";
 
diff --git a/src/EventManager/Events/WriteMemoryToTarget.hpp b/src/EventManager/Events/WriteMemoryToTarget.hpp
index 94c32d32..57e53c75 100644
--- a/src/EventManager/Events/WriteMemoryToTarget.hpp
+++ b/src/EventManager/Events/WriteMemoryToTarget.hpp
@@ -5,6 +5,7 @@
 #include <utility>
 
 #include "Event.hpp"
+#include "MemoryWrittenToTarget.hpp"
 #include "src/Targets/TargetMemory.hpp"
 
 namespace Bloom::Events
@@ -12,6 +13,8 @@ namespace Bloom::Events
     class WriteMemoryToTarget: public Event
     {
     public:
+        using TargetControllerResponseType = MemoryWrittenToTarget;
+
         static inline EventType type = EventType::WRITE_MEMORY_TO_TARGET;
         static inline const std::string name = "WriteMemoryToTarget";
         Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;
diff --git a/src/EventManager/Events/WriteRegistersToTarget.hpp b/src/EventManager/Events/WriteRegistersToTarget.hpp
index a255eec6..c325e381 100644
--- a/src/EventManager/Events/WriteRegistersToTarget.hpp
+++ b/src/EventManager/Events/WriteRegistersToTarget.hpp
@@ -4,6 +4,7 @@
 #include <utility>
 
 #include "Event.hpp"
+#include "RegistersWrittenToTarget.hpp"
 #include "src/Targets/TargetRegister.hpp"
 
 namespace Bloom::Events
@@ -11,6 +12,8 @@ namespace Bloom::Events
     class WriteRegistersToTarget: public Event
     {
     public:
+        using TargetControllerResponseType = RegistersWrittenToTarget;
+
         static inline EventType type = EventType::WRITE_REGISTERS_TO_TARGET;
         static inline const std::string name = "WriteRegistersToTarget";
         Targets::TargetRegisters registers;
diff --git a/src/TargetController/TargetControllerConsole.cpp b/src/TargetController/TargetControllerConsole.cpp
index ea2a51cd..db6b5bdf 100644
--- a/src/TargetController/TargetControllerConsole.cpp
+++ b/src/TargetController/TargetControllerConsole.cpp
@@ -11,53 +11,28 @@ using namespace Bloom::Events;
 using namespace Bloom::Exceptions;
 
 TargetControllerState TargetControllerConsole::getTargetControllerState() {
-    auto getStateEvent = std::make_shared<ReportTargetControllerState>();
-    this->eventManager.triggerEvent(getStateEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        TargetControllerStateReported,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, getStateEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
-
-    auto stateReportedEvent = std::get<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value());
-    return stateReportedEvent->state;
+    return this->triggerTargetControllerEventAndWaitForResponse(
+        std::make_shared<ReportTargetControllerState>()
+    )->state;
 }
 
 bool TargetControllerConsole::isTargetControllerInService() noexcept {
     try {
         return this->getTargetControllerState() == TargetControllerState::ACTIVE;
 
-    } catch (const std::runtime_error&) {
+    } catch (...) {
         return false;
     }
 }
 
 Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
-    auto descriptorExtractedEvent = this->triggerTargetControllerEventAndWaitForResponse(
+    return this->triggerTargetControllerEventAndWaitForResponse(
         std::make_shared<ExtractTargetDescriptor>()
-    );
-    return descriptorExtractedEvent->targetDescriptor;
+    )->targetDescriptor;
 }
 
 void TargetControllerConsole::stopTargetExecution() {
-    auto stopTargetEvent = std::make_shared<StopTargetExecution>();
-    this->eventManager.triggerEvent(stopTargetEvent);
-
-    auto responseEvent = this->eventListener.waitForEvent<
-        TargetExecutionStopped,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, stopTargetEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<TargetExecutionStopped>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(std::make_shared<StopTargetExecution>());
 }
 
 void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -67,17 +42,7 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
         resumeExecutionEvent->fromProgramCounter = fromAddress.value();
     }
 
-    this->eventManager.triggerEvent(resumeExecutionEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        TargetExecutionResumed,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, resumeExecutionEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(resumeExecutionEvent);
 }
 
 void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -87,56 +52,21 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
         stepExecutionEvent->fromProgramCounter = fromAddress.value();
     }
 
-    this->eventManager.triggerEvent(stepExecutionEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        TargetExecutionResumed,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, stepExecutionEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(stepExecutionEvent);
 }
 
 TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
     auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
     readRegistersEvent->descriptors = descriptors;
 
-    this->eventManager.triggerEvent(readRegistersEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        RegistersRetrievedFromTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, readRegistersEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<RegistersRetrievedFromTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
-
-    auto retrievedRegistersEvent = std::get<SharedEventPointer<RegistersRetrievedFromTarget>>(
-        responseEvent.value()
-    );
-    return retrievedRegistersEvent->registers;
+    return this->triggerTargetControllerEventAndWaitForResponse(readRegistersEvent)->registers;
 }
 
 void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
     auto event = std::make_shared<WriteRegistersToTarget>();
     event->registers = std::move(registers);
 
-    this->eventManager.triggerEvent(event);
-    auto responseEvent = this->eventListener.waitForEvent<
-        RegistersWrittenToTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, event->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<RegistersWrittenToTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(event);
 }
 
 TargetMemoryBuffer TargetControllerConsole::readMemory(
@@ -149,22 +79,7 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
     readMemoryEvent->startAddress = startAddress;
     readMemoryEvent->bytes = bytes;
 
-    this->eventManager.triggerEvent(readMemoryEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        MemoryRetrievedFromTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, readMemoryEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<MemoryRetrievedFromTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
-
-    auto retrievedRegistersEvent = std::get<SharedEventPointer<MemoryRetrievedFromTarget>>(
-        responseEvent.value()
-    );
-    return retrievedRegistersEvent->data;
+    return this->triggerTargetControllerEventAndWaitForResponse(readMemoryEvent)->data;
 }
 
 void TargetControllerConsole::writeMemory(
@@ -177,51 +92,21 @@ void TargetControllerConsole::writeMemory(
     writeMemoryEvent->startAddress = startAddress;
     writeMemoryEvent->buffer = buffer;
 
-    this->eventManager.triggerEvent(writeMemoryEvent);
-    auto responseEvent = this->eventListener.waitForEvent<
-        MemoryWrittenToTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, writeMemoryEvent->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<MemoryWrittenToTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(writeMemoryEvent);
 }
 
 void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
     auto event = std::make_shared<SetBreakpointOnTarget>();
     event->breakpoint = breakpoint;
 
-    this->eventManager.triggerEvent(event);
-    auto responseEvent = this->eventListener.waitForEvent<
-        BreakpointSetOnTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, event->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<BreakpointSetOnTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(event);
 }
 
 void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
     auto event = std::make_shared<RemoveBreakpointOnTarget>();
     event->breakpoint = breakpoint;
 
-    this->eventManager.triggerEvent(event);
-    auto responseEvent = this->eventListener.waitForEvent<
-        BreakpointRemovedOnTarget,
-        TargetControllerErrorOccurred
-    >(this->defaultTimeout, event->id);
-
-    if (!responseEvent.has_value()
-        || !std::holds_alternative<SharedEventPointer<BreakpointRemovedOnTarget>>(responseEvent.value())
-    ) {
-        throw Exception("Unexpected response from TargetController");
-    }
+    this->triggerTargetControllerEventAndWaitForResponse(event);
 }
 
 void TargetControllerConsole::requestPinStates(int variantId) {