doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved away from shared pointers in event handlers - didn't make sense to expose the event management implementation to handlers.

Browse Source 
Also some other bits of tidying.
This commit is contained in:
Nav
2021-06-22 03:06:20 +01:00
parent 139e880646
commit a7df862d36
19 changed files with 193 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
src/TargetController/TargetController.cpp
View File

@@ -68,7 +68,7 @@ void TargetController::startup() {
this->eventManager.registerListener(this->eventListener);
// Install Bloom's udev rules if not already installed
this->checkUdevRules();
TargetController::checkUdevRules();
// Register event handlers
this->eventListener->registerCallbackForEventType<Events::ReportTargetControllerState>(
@@ -303,7 +303,7 @@ void TargetController::acquireHardware() {
break;
}
this->target.reset(promotedTarget.release());
this->target = std::move(promotedTarget);
this->target->postPromotionConfigure();
}
@@ -360,17 +360,17 @@ void TargetController::emitErrorEvent(int correlationId) {
this->eventManager.triggerEvent(errorEvent);
}
void TargetController::onShutdownTargetControllerEvent(EventPointer<Events::ShutdownTargetController>) {
void TargetController::onShutdownTargetControllerEvent(EventRef<Events::ShutdownTargetController>) {
this->shutdown();
}
void TargetController::onStateReportRequest(EventPointer<Events::ReportTargetControllerState> event) {
void TargetController::onStateReportRequest(EventRef<Events::ReportTargetControllerState> event) {
auto stateEvent = std::make_shared<TargetControllerStateReported>(this->state);
stateEvent->correlationId = event->id;
stateEvent->correlationId = event.id;
this->eventManager.triggerEvent(stateEvent);
}
void TargetController::onDebugSessionStartedEvent(EventPointer<Events::DebugSessionStarted>) {
void TargetController::onDebugSessionStartedEvent(EventRef<Events::DebugSessionStarted>) {
if (this->state == TargetControllerState::SUSPENDED) {
Logger::debug("Waking TargetController");
@@ -385,7 +385,7 @@ void TargetController::onDebugSessionStartedEvent(EventPointer<Events::DebugSess
}
}
void TargetController::onDebugSessionFinishedEvent(EventPointer<DebugSessionFinished>) {
void TargetController::onDebugSessionFinishedEvent(EventRef<DebugSessionFinished>) {
if (this->target->getState() != TargetState::RUNNING) {
this->target->run();
this->fireTargetEvents();
@@ -396,7 +396,7 @@ void TargetController::onDebugSessionFinishedEvent(EventPointer<DebugSessionFini
}
}
void TargetController::onExtractTargetDescriptor(EventPointer<Events::ExtractTargetDescriptor> event) {
void TargetController::onExtractTargetDescriptor(EventRef<Events::ExtractTargetDescriptor> event) {
if (!this->cachedTargetDescriptor.has_value()) {
this->cachedTargetDescriptor = this->target->getDescriptor();
}
@@ -404,11 +404,11 @@ void TargetController::onExtractTargetDescriptor(EventPointer<Events::ExtractTar
auto targetDescriptorExtracted = std::make_shared<TargetDescriptorExtracted>();
targetDescriptorExtracted->targetDescriptor = this->cachedTargetDescriptor.value();
targetDescriptorExtracted->correlationId = event->id;
targetDescriptorExtracted->correlationId = event.id;
this->eventManager.triggerEvent(targetDescriptorExtracted);
}
void TargetController::onStopTargetExecutionEvent(EventPointer<Events::StopTargetExecution> event) {
void TargetController::onStopTargetExecutionEvent(EventRef<Events::StopTargetExecution> event) {
if (this->target->getState() != TargetState::STOPPED) {
this->target->stop();
this->lastTargetState = TargetState::STOPPED;
@@ -419,39 +419,39 @@ void TargetController::onStopTargetExecutionEvent(EventPointer<Events::StopTarge
TargetBreakCause::UNKNOWN
);
executionStoppedEvent->correlationId = event->id;
executionStoppedEvent->correlationId = event.id;
this->eventManager.triggerEvent(executionStoppedEvent);
}
void TargetController::onStepTargetExecutionEvent(EventPointer<Events::StepTargetExecution> event) {
void TargetController::onStepTargetExecutionEvent(EventRef<Events::StepTargetExecution> event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
// We can't step the target if it's already running.
throw Exception("Target is already running");
}
if (event->fromProgramCounter.has_value()) {
this->target->setProgramCounter(event->fromProgramCounter.value());
if (event.fromProgramCounter.has_value()) {
this->target->setProgramCounter(event.fromProgramCounter.value());
}
this->target->step();
this->lastTargetState = TargetState::RUNNING;
auto executionResumedEvent = std::make_shared<TargetExecutionResumed>();
executionResumedEvent->correlationId = event->id;
executionResumedEvent->correlationId = event.id;
this->eventManager.triggerEvent(executionResumedEvent);
} catch (const Exception& exception) {
Logger::error("Failed to step execution on target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onResumeTargetExecutionEvent(EventPointer<Events::ResumeTargetExecution> event) {
void TargetController::onResumeTargetExecutionEvent(EventRef<Events::ResumeTargetExecution> event) {
try {
if (this->target->getState() != TargetState::RUNNING) {
if (event->fromProgramCounter.has_value()) {
this->target->setProgramCounter(event->fromProgramCounter.value());
if (event.fromProgramCounter.has_value()) {
this->target->setProgramCounter(event.fromProgramCounter.value());
}
this->target->run();
@@ -459,72 +459,72 @@ void TargetController::onResumeTargetExecutionEvent(EventPointer<Events::ResumeT
}
auto executionResumedEvent = std::make_shared<Events::TargetExecutionResumed>();
executionResumedEvent->correlationId = event->id;
executionResumedEvent->correlationId = event.id;
this->eventManager.triggerEvent(executionResumedEvent);
} catch (const Exception& exception) {
Logger::error("Failed to resume execution on target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onReadRegistersEvent(EventPointer<Events::RetrieveRegistersFromTarget> event) {
void TargetController::onReadRegistersEvent(EventRef<Events::RetrieveRegistersFromTarget> event) {
try {
auto registers = this->target->readRegisters(event->descriptors);
auto registers = this->target->readRegisters(event.descriptors);
if (registers.size() > 0) {
auto registersRetrievedEvent = std::make_shared<Events::RegistersRetrievedFromTarget>();
registersRetrievedEvent->correlationId = event->id;
registersRetrievedEvent->correlationId = event.id;
registersRetrievedEvent->registers = registers;
this->eventManager.triggerEvent(registersRetrievedEvent);
}
} catch (const Exception& exception) {
Logger::error("Failed to read general registers from target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onWriteRegistersEvent(EventPointer<Events::WriteRegistersToTarget> event) {
void TargetController::onWriteRegistersEvent(EventRef<Events::WriteRegistersToTarget> event) {
try {
this->target->writeRegisters(event->registers);
this->target->writeRegisters(event.registers);
auto registersWrittenEvent = std::make_shared<Events::RegistersWrittenToTarget>();
registersWrittenEvent->correlationId = event->id;
registersWrittenEvent->correlationId = event.id;
this->eventManager.triggerEvent(registersWrittenEvent);
} catch (const Exception& exception) {
Logger::error("Failed to write registers to target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onReadMemoryEvent(EventPointer<Events::RetrieveMemoryFromTarget> event) {
void TargetController::onReadMemoryEvent(EventRef<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);
memoryReadEvent->correlationId = event.id;
memoryReadEvent->data = this->target->readMemory(event.memoryType, event.startAddress, event.bytes);
this->eventManager.triggerEvent(memoryReadEvent);
} catch (const Exception& exception) {
Logger::error("Failed to read memory from target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onWriteMemoryEvent(EventPointer<Events::WriteMemoryToTarget> event) {
void TargetController::onWriteMemoryEvent(EventRef<Events::WriteMemoryToTarget> event) {
try {
this->target->writeMemory(event->memoryType, event->startAddress, event->buffer);
this->target->writeMemory(event.memoryType, event.startAddress, event.buffer);
auto memoryWrittenEvent = std::make_shared<Events::MemoryWrittenToTarget>();
memoryWrittenEvent->correlationId = event->id;
memoryWrittenEvent->correlationId = event.id;
this->eventManager.triggerEvent(memoryWrittenEvent);
if (this->target->memoryAddressRangeClashesWithIoPortRegisters(
event->memoryType,
event->startAddress,
static_cast<std::uint32_t>(event->startAddress + (event->buffer.size() - 1))
event.memoryType,
event.startAddress,
static_cast<std::uint32_t>(event.startAddress + (event.buffer.size() - 1))
)) {
// This memory write has affected the target's IO port values
this->eventManager.triggerEvent(std::make_shared<Events::TargetIoPortsUpdated>());
@@ -532,59 +532,59 @@ void TargetController::onWriteMemoryEvent(EventPointer<Events::WriteMemoryToTarg
} catch (const Exception& exception) {
Logger::error("Failed to write memory to target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onSetBreakpointEvent(EventPointer<Events::SetBreakpointOnTarget> event) {
void TargetController::onSetBreakpointEvent(EventRef<Events::SetBreakpointOnTarget> event) {
try {
this->target->setBreakpoint(event->breakpoint.address);
this->target->setBreakpoint(event.breakpoint.address);
auto breakpointSetEvent = std::make_shared<Events::BreakpointSetOnTarget>();
breakpointSetEvent->correlationId = event->id;
breakpointSetEvent->correlationId = event.id;
this->eventManager.triggerEvent(breakpointSetEvent);
} catch (const Exception& exception) {
Logger::error("Failed to set breakpoint on target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onRemoveBreakpointEvent(EventPointer<Events::RemoveBreakpointOnTarget> event) {
void TargetController::onRemoveBreakpointEvent(EventRef<Events::RemoveBreakpointOnTarget> event) {
try {
this->target->removeBreakpoint(event->breakpoint.address);
this->target->removeBreakpoint(event.breakpoint.address);
auto breakpointRemovedEvent = std::make_shared<Events::BreakpointRemovedOnTarget>();
breakpointRemovedEvent->correlationId = event->id;
breakpointRemovedEvent->correlationId = event.id;
this->eventManager.triggerEvent(breakpointRemovedEvent);
} catch (const Exception& exception) {
Logger::error("Failed to remove breakpoint on target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onSetProgramCounterEvent(EventPointer<Events::SetProgramCounterOnTarget> event) {
void TargetController::onSetProgramCounterEvent(EventRef<Events::SetProgramCounterOnTarget> event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
throw Exception("Invalid target state - target must be stopped before the program counter can be updated");
}
this->target->setProgramCounter(event->address);
this->target->setProgramCounter(event.address);
auto programCounterSetEvent = std::make_shared<Events::ProgramCounterSetOnTarget>();
programCounterSetEvent->correlationId = event->id;
programCounterSetEvent->correlationId = event.id;
this->eventManager.triggerEvent(programCounterSetEvent);
} catch (const Exception& exception) {
Logger::error("Failed to set program counter on target - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
// TODO: remove this
void TargetController::onInsightStateChangedEvent(EventPointer<Events::InsightThreadStateChanged> event) {
if (event->getState() == ThreadState::READY) {
void TargetController::onInsightStateChangedEvent(EventRef<Events::InsightThreadStateChanged> event) {
if (event.getState() == ThreadState::READY) {
/*
* Insight has just started up.
*
@@ -595,45 +595,45 @@ void TargetController::onInsightStateChangedEvent(EventPointer<Events::InsightTh
}
}
void TargetController::onRetrieveTargetPinStatesEvent(EventPointer<Events::RetrieveTargetPinStates> event) {
void TargetController::onRetrieveTargetPinStatesEvent(EventRef<Events::RetrieveTargetPinStates> event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
throw Exception("Invalid target state - target must be stopped before pin states can be retrieved");
}
auto pinStatesRetrieved = std::make_shared<Events::TargetPinStatesRetrieved>();
pinStatesRetrieved->correlationId = event->id;
pinStatesRetrieved->variantId = event->variantId;
pinStatesRetrieved->pinSatesByNumber = this->target->getPinStates(event->variantId);
pinStatesRetrieved->correlationId = event.id;
pinStatesRetrieved->variantId = event.variantId;
pinStatesRetrieved->pinSatesByNumber = this->target->getPinStates(event.variantId);
this->eventManager.triggerEvent(pinStatesRetrieved);
} catch (const Exception& exception) {
Logger::error("Failed to retrieve target pin states - " + exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}
void TargetController::onSetPinStateEvent(EventPointer<Events::SetTargetPinState> event) {
void TargetController::onSetPinStateEvent(EventRef<Events::SetTargetPinState> event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
throw Exception("Invalid target state - target must be stopped before pin state can be set");
}
this->target->setPinState(event->variantId, event->pinDescriptor, event->pinState);
this->target->setPinState(event.variantId, event.pinDescriptor, event.pinState);
auto pinStatesUpdateEvent = std::make_shared<Events::TargetPinStatesRetrieved>();
pinStatesUpdateEvent->correlationId = event->id;
pinStatesUpdateEvent->variantId = event->variantId;
pinStatesUpdateEvent->correlationId = event.id;
pinStatesUpdateEvent->variantId = event.variantId;
pinStatesUpdateEvent->pinSatesByNumber = {
{event->pinDescriptor.number, event->pinState}
{event.pinDescriptor.number, event.pinState}
};
this->eventManager.triggerEvent(pinStatesUpdateEvent);
} catch (const Exception& exception) {
Logger::error("Failed to set target pin state for pin " + event->pinDescriptor.name + " - "
Logger::error("Failed to set target pin state for pin " + event.pinDescriptor.name + " - "
+ exception.getMessage());
this->emitErrorEvent(event->id);
this->emitErrorEvent(event.id);
}
}

40
src/TargetController/TargetController.hpp
View File

@@ -67,7 +67,7 @@ namespace Bloom
/**
* Constructs a mapping of supported debug tool names to lambdas. The lambdas should *only* instantiate
* and return an instance to the derived DebugTool class. They should never attempt to establish
* and return an instance to the derived DebugTool class. They should not attempt to establish
* a connection to the device.
*
* @return
@@ -173,7 +173,7 @@ namespace Bloom
* to /etc/udev/rules.d/. This method will report an error if Bloom isn't running as root (as root privileges
* are required for writing to files in /etc/udev).
*/
void checkUdevRules();
static void checkUdevRules();
/**
* Because the TargetController hogs the thread, this method must be called in a dedicated thread.
@@ -244,70 +244,70 @@ namespace Bloom
*
* @param event
*/
void onStateReportRequest(Events::EventPointer<Events::ReportTargetControllerState> event);
void onStateReportRequest(Events::EventRef<Events::ReportTargetControllerState> event);
/**
* Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event.
*
* @param event
*/
void onExtractTargetDescriptor(Events::EventPointer<Events::ExtractTargetDescriptor> event);
void onExtractTargetDescriptor(Events::EventRef<Events::ExtractTargetDescriptor> event);
/**
* Will attempt to stop execution on the target and emit a TargetExecutionStopped event.
*
* @param event
*/
void onStopTargetExecutionEvent(Events::EventPointer<Events::StopTargetExecution> event);
void onStopTargetExecutionEvent(Events::EventRef<Events::StopTargetExecution> event);
/**
* Will attempt to step execution on the target and emit a TargetExecutionResumed event.
*
* @param event
*/
void onStepTargetExecutionEvent(Events::EventPointer<Events::StepTargetExecution> event);
void onStepTargetExecutionEvent(Events::EventRef<Events::StepTargetExecution> event);
/**
* Will attempt to resume execution on the target and emit a TargetExecutionResumed event.
*
* @param event
*/
void onResumeTargetExecutionEvent(Events::EventPointer<Events::ResumeTargetExecution> event);
void onResumeTargetExecutionEvent(Events::EventRef<Events::ResumeTargetExecution> event);
/**
* Invokes a shutdown.
*
* @param event
*/
void onShutdownTargetControllerEvent(Events::EventPointer<Events::ShutdownTargetController> event);
void onShutdownTargetControllerEvent(Events::EventRef<Events::ShutdownTargetController> event);
/**
* Will attempt to read the requested registers and emit a RegistersRetrievedFromTarget event.
*
* @param event
*/
void onReadRegistersEvent(Events::EventPointer<Events::RetrieveRegistersFromTarget> event);
void onReadRegistersEvent(Events::EventRef<Events::RetrieveRegistersFromTarget> event);
/**
* Will attempt to write the specified register values and emit a RegistersWrittenToTarget event.
*
* @param event
*/
void onWriteRegistersEvent(Events::EventPointer<Events::WriteRegistersToTarget> event);
void onWriteRegistersEvent(Events::EventRef<Events::WriteRegistersToTarget> event);
/**
* Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event.
*
* @param event
*/
void onReadMemoryEvent(Events::EventPointer<Events::RetrieveMemoryFromTarget> event);
void onReadMemoryEvent(Events::EventRef<Events::RetrieveMemoryFromTarget> event);
/**
* Will attempt to write memory to the target. On success, a MemoryWrittenToTarget event is emitted.
*
* @param event
*/
void onWriteMemoryEvent(Events::EventPointer<Events::WriteMemoryToTarget> event);
void onWriteMemoryEvent(Events::EventRef<Events::WriteMemoryToTarget> event);
/**
* Will attempt to set the specific breakpoint on the target. On success, the BreakpointSetOnTarget event will
@@ -315,7 +315,7 @@ namespace Bloom
*
* @param event
*/
void onSetBreakpointEvent(Events::EventPointer<Events::SetBreakpointOnTarget> event);
void onSetBreakpointEvent(Events::EventRef<Events::SetBreakpointOnTarget> event);
/**
* Will attempt to remove a breakpoint at the specified address, on the target. On success, the
@@ -323,21 +323,21 @@ namespace Bloom
*
* @param event
*/
void onRemoveBreakpointEvent(Events::EventPointer<Events::RemoveBreakpointOnTarget> event);
void onRemoveBreakpointEvent(Events::EventRef<Events::RemoveBreakpointOnTarget> event);
/**
* Will hold the target stopped at it's current state.
*
* @param event
*/
void onDebugSessionStartedEvent(Events::EventPointer<Events::DebugSessionStarted> event);
void onDebugSessionStartedEvent(Events::EventRef<Events::DebugSessionStarted> event);
/**
* Will simply kick off execution on the target.
*
* @param event
*/
void onDebugSessionFinishedEvent(Events::EventPointer<Events::DebugSessionFinished> event);
void onDebugSessionFinishedEvent(Events::EventRef<Events::DebugSessionFinished> event);
/**
* Will update the program counter value on the target. On success, a ProgramCounterSetOnTarget event is
@@ -345,7 +345,7 @@ namespace Bloom
*
* @param event
*/
void onSetProgramCounterEvent(Events::EventPointer<Events::SetProgramCounterOnTarget> event);
void onSetProgramCounterEvent(Events::EventRef<Events::SetProgramCounterOnTarget> event);
/**
* Will automatically fire a target state update event.
@@ -353,14 +353,14 @@ namespace Bloom
*
* @param event
*/
void onInsightStateChangedEvent(Events::EventPointer<Events::InsightThreadStateChanged> event);
void onInsightStateChangedEvent(Events::EventRef<Events::InsightThreadStateChanged> event);
/**
* Will attempt to obtain the pin states from the target. Will emit a TargetPinStatesRetrieved event on success.
*
* @param event
*/
void onRetrieveTargetPinStatesEvent(Events::EventPointer<Events::RetrieveTargetPinStates> event);
void onRetrieveTargetPinStatesEvent(Events::EventRef<Events::RetrieveTargetPinStates> event);
/**
* Will update a pin state for a particular pin. Will emit a TargetPinStatesRetrieved with the new pin
@@ -368,6 +368,6 @@ namespace Bloom
*
* @param event
*/
void onSetPinStateEvent(Events::EventPointer<Events::SetTargetPinState> event);
void onSetPinStateEvent(Events::EventRef<Events::SetTargetPinState> event);
};
}

36
src/TargetController/TargetControllerConsole.cpp
View File

@@ -18,12 +18,12 @@ TargetControllerState TargetControllerConsole::getTargetControllerState() {
>(this->defaultTimeout, getStateEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetControllerStateReported>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto stateReportedEvent = std::get<EventPointer<Events::TargetControllerStateReported>>(responseEvent.value());
auto stateReportedEvent = std::get<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value());
return stateReportedEvent->state;
}
@@ -45,12 +45,12 @@ Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
>(this->defaultTimeout, extractEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto descriptorExtracted = std::get<EventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
auto descriptorExtracted = std::get<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
return descriptorExtracted->targetDescriptor;
}
@@ -64,7 +64,7 @@ void TargetControllerConsole::stopTargetExecution() {
>(this->defaultTimeout, stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -84,7 +84,7 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
>(this->defaultTimeout, resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -104,7 +104,7 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
>(this->defaultTimeout, stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -121,12 +121,14 @@ TargetRegisters TargetControllerConsole::readGeneralRegisters(TargetRegisterDesc
>(this->defaultTimeout, readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value());
auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->registers;
}
@@ -141,7 +143,7 @@ void TargetControllerConsole::writeGeneralRegisters(TargetRegisters registers) {
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -164,12 +166,14 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
>(this->defaultTimeout, readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<EventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value());
auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->data;
}
@@ -190,7 +194,7 @@ void TargetControllerConsole::writeMemory(
>(this->defaultTimeout, writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -207,7 +211,7 @@ void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -224,7 +228,7 @@ void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<EventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -240,7 +244,7 @@ void TargetControllerConsole::requestPinStates(int variantId) {
void TargetControllerConsole::setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState) {
auto updateEvent = std::make_shared<Events::SetTargetPinState>();
updateEvent->variantId = variantId;
updateEvent->pinDescriptor = pinDescriptor;
updateEvent->pinDescriptor = std::move(pinDescriptor);
updateEvent->pinState = pinState;
this->eventManager.triggerEvent(updateEvent);