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

Removed EventRef alias for clarity

Browse Source
This commit is contained in:
Nav
2021-06-22 14:44:00 +01:00
parent a7df862d36
commit 69cee4d579
14 changed files with 78 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Application.cpp
View File

@@ -323,19 +323,19 @@ void Application::stopDebugServer() {
}
}
void Application::onTargetControllerThreadStateChanged(EventRef<Events::TargetControllerThreadStateChanged> event) {
void Application::onTargetControllerThreadStateChanged(const Events::TargetControllerThreadStateChanged& event) {
if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) {
// TargetController has unexpectedly shutdown - it must have encountered a fatal error.
this->shutdown();
}
}
void Application::onShutdownApplicationRequest(EventRef<Events::ShutdownApplication>) {
void Application::onShutdownApplicationRequest(const Events::ShutdownApplication&) {
Logger::debug("ShutdownApplication event received.");
this->shutdown();
}
void Application::onDebugServerThreadStateChanged(EventRef<Events::DebugServerThreadStateChanged> event) {
void Application::onDebugServerThreadStateChanged(const Events::DebugServerThreadStateChanged& event) {
if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) {
// DebugServer has unexpectedly shutdown - it must have encountered a fatal error.
this->shutdown();

6
src/Application.hpp
View File

@@ -233,7 +233,7 @@ namespace Bloom
*
* @param event
*/
void onTargetControllerThreadStateChanged(Events::EventRef<Events::TargetControllerThreadStateChanged> event);
void onTargetControllerThreadStateChanged(const Events::TargetControllerThreadStateChanged& event);
/**
* Same goes for the DebugServer - it should never shutdown unless a shutdown request was issued. If it does,
@@ -241,12 +241,12 @@ namespace Bloom
*
* @param event
*/
void onDebugServerThreadStateChanged(Events::EventRef<Events::DebugServerThreadStateChanged> event);
void onDebugServerThreadStateChanged(const Events::DebugServerThreadStateChanged& event);
/**
* Triggers a shutdown of Bloom and all of its components.
*/
void onShutdownApplicationRequest(Events::EventRef<Events::ShutdownApplication>);
void onShutdownApplicationRequest(const Events::ShutdownApplication&);
/**
* Checks if the current effective user running Bloom has root privileges.

2
src/DebugServers/DebugServer.cpp
View File

@@ -55,6 +55,6 @@ void DebugServer::shutdown() {
this->eventManager.deregisterListener(this->eventListener->getId());
}
void DebugServer::onShutdownDebugServerEvent(EventRef<Events::ShutdownDebugServer> event) {
void DebugServer::onShutdownDebugServerEvent(const Events::ShutdownDebugServer& event) {
this->shutdown();
}

2
src/DebugServers/DebugServer.hpp
View File

@@ -59,7 +59,7 @@ namespace Bloom::DebugServers
*
* @param event
*/
void onShutdownDebugServerEvent(Events::EventRef<Events::ShutdownDebugServer> event);
void onShutdownDebugServerEvent(const Events::ShutdownDebugServer& event);
protected:
/**

4
src/DebugServers/GdbRsp/GdbRspDebugServer.cpp
View File

@@ -201,7 +201,7 @@ void GdbRspDebugServer::waitForConnection() {
}
}
void GdbRspDebugServer::onTargetControllerStateReported(Events::EventRef<Events::TargetControllerStateReported> event) {
void GdbRspDebugServer::onTargetControllerStateReported(const Events::TargetControllerStateReported& event) {
if (event.state == TargetControllerState::SUSPENDED && this->clientConnection.has_value()) {
Logger::warning("Terminating debug session - TargetController suspended unexpectedly");
this->closeClientConnection();
@@ -232,7 +232,7 @@ void GdbRspDebugServer::handleGdbPacket(CommandPacket& packet) {
}
}
void GdbRspDebugServer::onTargetExecutionStopped(EventRef<Events::TargetExecutionStopped>) {
void GdbRspDebugServer::onTargetExecutionStopped(const Events::TargetExecutionStopped&) {
if (this->clientConnection.has_value() && this->clientConnection->waitingForBreak) {
this->clientConnection->writePacket(TargetStopped(Signal::TRAP));
this->clientConnection->waitingForBreak = false;

4
src/DebugServers/GdbRsp/GdbRspDebugServer.hpp
View File

@@ -169,13 +169,13 @@ namespace Bloom::DebugServers::Gdb
return "GDB Remote Serial Protocol DebugServer";
};
void onTargetControllerStateReported(Events::EventRef<Events::TargetControllerStateReported> event);
void onTargetControllerStateReported(const Events::TargetControllerStateReported& event);
/**
* If the GDB client is currently waiting for the target execution to stop, this event handler will issue
* a "stop reply" packet to the client once the target execution stops.
*/
void onTargetExecutionStopped(Events::EventRef<Events::TargetExecutionStopped>);
void onTargetExecutionStopped(const Events::TargetExecutionStopped&);
/**
* Handles any other GDB command packet that has not been promoted to a more specific type.

10
src/EventManager/EventListener.hpp
View File

@@ -70,7 +70,7 @@ namespace Bloom
* we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType()
* for more)
*/
SyncSafe<std::map<std::string, std::vector<std::function<void(Events::GenericEventRef)>>>> eventTypeToCallbacksMapping;
SyncSafe<std::map<std::string, std::vector<std::function<void(const Events::Event&)>>>> eventTypeToCallbacksMapping;
SyncSafe<std::set<std::string>> registeredEventTypes;
std::shared_ptr<EventNotifier> interruptEventNotifier = nullptr;
@@ -110,12 +110,12 @@ namespace Bloom
* @param callback
*/
template<class EventType>
void registerCallbackForEventType(std::function<void(Events::EventRef<EventType>)> callback) {
void registerCallbackForEventType(std::function<void(const EventType&)> callback) {
// We encapsulate the callback in a lambda to handle the downcasting.
std::function<void(Events::GenericEventRef)> parentCallback =
[callback] (Events::GenericEventRef event) {
std::function<void(const Events::Event&)> parentCallback =
[callback] (const Events::Event& event) {
// Downcast the event to the expected type
callback(dynamic_cast<Events::EventRef<EventType>>(event));
callback(dynamic_cast<const EventType&>(event));
}
;

4
src/EventManager/Events/Events.hpp
View File

@@ -46,9 +46,5 @@ namespace Bloom::Events
template <class EventType>
using SharedEventPointer = std::shared_ptr<const EventType>;
template <class EventType>
using EventRef = const EventType&;
using SharedGenericEventPointer = SharedEventPointer<Event>;
using GenericEventRef = EventRef<Event>;
}

9
src/Insight/Insight.cpp
View File

@@ -9,7 +9,6 @@
#include "src/Targets/TargetState.hpp"
using namespace Bloom;
using namespace Bloom::Events;
using namespace Bloom::Exceptions;
void Insight::run() {
@@ -38,11 +37,11 @@ void Insight::startup() {
this->setThreadState(ThreadState::STARTING);
this->eventManager.registerListener(this->eventListener);
this->eventListener->registerCallbackForEventType<ShutdownApplication>(
this->eventListener->registerCallbackForEventType<Events::ShutdownApplication>(
std::bind(&Insight::onShutdownApplicationEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<TargetControllerThreadStateChanged>(
this->eventListener->registerCallbackForEventType<Events::TargetControllerThreadStateChanged>(
std::bind(&Insight::onTargetControllerThreadStateChangedEvent, this, std::placeholders::_1)
);
@@ -119,7 +118,7 @@ void Insight::shutdown() {
this->setThreadState(ThreadState::STOPPED);
}
void Insight::onShutdownApplicationEvent(EventRef<ShutdownApplication>) {
void Insight::onShutdownApplicationEvent(const Events::ShutdownApplication&) {
/*
* Once Insight shuts down, control of the main thread will be returned to Application::run(), which
* will pickup the ShutdownApplication event and proceed with the shutdown.
@@ -127,7 +126,7 @@ void Insight::onShutdownApplicationEvent(EventRef<ShutdownApplication>) {
this->shutdown();
}
void Insight::onTargetControllerThreadStateChangedEvent(EventRef<TargetControllerThreadStateChanged> event) {
void Insight::onTargetControllerThreadStateChangedEvent(const Events::TargetControllerThreadStateChanged& event) {
if (event.getState() == ThreadState::STOPPED) {
// Something horrible has happened with the TargetController - Insight is useless without the TargetController
this->shutdown();

6
src/Insight/Insight.hpp
View File

@@ -81,16 +81,14 @@ namespace Bloom
*
* @param event
*/
void onShutdownApplicationEvent(Events::EventRef<Events::ShutdownApplication> event);
void onShutdownApplicationEvent(const Events::ShutdownApplication& event);
/**
* If the something horrible was to happen and the TC dies unexpectedly, Insight will shutdown in response.
*
* @param event
*/
void onTargetControllerThreadStateChangedEvent(
Events::EventRef<Events::TargetControllerThreadStateChanged> event
);
void onTargetControllerThreadStateChangedEvent(const Events::TargetControllerThreadStateChanged& event);
/**
* Dispatches any events currently in the queue.

23
src/Insight/InsightWorker.cpp
View File

@@ -10,7 +10,6 @@
#include "src/Exceptions/InvalidConfig.hpp"
using namespace Bloom;
using namespace Bloom::Events;
using namespace Bloom::Exceptions;
using Bloom::Targets::TargetState;
@@ -19,23 +18,23 @@ void InsightWorker::startup() {
Logger::debug("Starting InsightWorker thread");
this->eventManager.registerListener(this->eventListener);
this->eventListener->registerCallbackForEventType<TargetControllerStateReported>(
this->eventListener->registerCallbackForEventType<Events::TargetControllerStateReported>(
std::bind(&InsightWorker::onTargetControllerStateReported, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<TargetExecutionStopped>(
this->eventListener->registerCallbackForEventType<Events::TargetExecutionStopped>(
std::bind(&InsightWorker::onTargetStoppedEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<TargetExecutionResumed>(
this->eventListener->registerCallbackForEventType<Events::TargetExecutionResumed>(
std::bind(&InsightWorker::onTargetResumedEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<TargetPinStatesRetrieved>(
this->eventListener->registerCallbackForEventType<Events::TargetPinStatesRetrieved>(
std::bind(&InsightWorker::onTargetPinStatesRetrievedEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<TargetIoPortsUpdated>(
this->eventListener->registerCallbackForEventType<Events::TargetIoPortsUpdated>(
std::bind(&InsightWorker::onTargetIoPortsUpdatedEvent, this, std::placeholders::_1)
);
@@ -60,7 +59,7 @@ void InsightWorker::requestPinStateUpdate(
this->targetControllerConsole.setPinState(variantId, pinDescriptor, pinState);
}
void InsightWorker::onTargetStoppedEvent(EventRef<TargetExecutionStopped> event) {
void InsightWorker::onTargetStoppedEvent(const Events::TargetExecutionStopped& event) {
/*
* When we report a target halt to Insight, Insight will immediately seek more data from the target (such as GPIO
* pin states). This can be problematic for cases where the target had halted due to a conditional breakpoint.
@@ -82,7 +81,7 @@ void InsightWorker::onTargetStoppedEvent(EventRef<TargetExecutionStopped> event)
* only way. It would be nice if the debug client gave us some form of indication of whether the breakpoint is a
* conditional one.
*/
auto resumedEvent = this->eventListener->waitForEvent<TargetExecutionResumed>(
auto resumedEvent = this->eventListener->waitForEvent<Events::TargetExecutionResumed>(
std::chrono::milliseconds(650)
);
@@ -92,19 +91,19 @@ void InsightWorker::onTargetStoppedEvent(EventRef<TargetExecutionStopped> event)
}
}
void InsightWorker::onTargetResumedEvent(EventRef<TargetExecutionResumed> event) {
void InsightWorker::onTargetResumedEvent(const Events::TargetExecutionResumed& event) {
emit this->targetStateUpdated(TargetState::RUNNING);
}
void InsightWorker::onTargetPinStatesRetrievedEvent(EventRef<TargetPinStatesRetrieved> event) {
void InsightWorker::onTargetPinStatesRetrievedEvent(const Events::TargetPinStatesRetrieved& event) {
emit this->targetPinStatesUpdated(event.variantId, event.pinSatesByNumber);
}
void InsightWorker::onTargetIoPortsUpdatedEvent(EventRef<TargetIoPortsUpdated> event) {
void InsightWorker::onTargetIoPortsUpdatedEvent(const Events::TargetIoPortsUpdated& event) {
emit this->targetIoPortsUpdated();
}
void InsightWorker::onTargetControllerStateReported(EventRef<TargetControllerStateReported> event) {
void InsightWorker::onTargetControllerStateReported(const Events::TargetControllerStateReported& event) {
if (this->lastTargetControllerState == TargetControllerState::ACTIVE
&& event.state == TargetControllerState::SUSPENDED
) {

10
src/Insight/InsightWorker.hpp
View File

@@ -33,11 +33,11 @@ namespace Bloom
QTimer* eventDispatchTimer = nullptr;
void onTargetStoppedEvent(Events::EventRef<Events::TargetExecutionStopped> event);
void onTargetResumedEvent(Events::EventRef<Events::TargetExecutionResumed> event);
void onTargetPinStatesRetrievedEvent(Events::EventRef<Events::TargetPinStatesRetrieved> event);
void onTargetIoPortsUpdatedEvent(Events::EventRef<Events::TargetIoPortsUpdated> event);
void onTargetControllerStateReported(Events::EventRef<Events::TargetControllerStateReported> event);
void onTargetStoppedEvent(const Events::TargetExecutionStopped& event);
void onTargetResumedEvent(const Events::TargetExecutionResumed& event);
void onTargetPinStatesRetrievedEvent(const Events::TargetPinStatesRetrieved& event);
void onTargetIoPortsUpdatedEvent(const Events::TargetIoPortsUpdated& event);
void onTargetControllerStateReported(const Events::TargetControllerStateReported& event);
public:
explicit InsightWorker(EventManager& eventManager): eventManager(eventManager) {};

42
src/TargetController/TargetController.cpp
View File

@@ -360,17 +360,17 @@ void TargetController::emitErrorEvent(int correlationId) {
this->eventManager.triggerEvent(errorEvent);
}
void TargetController::onShutdownTargetControllerEvent(EventRef<Events::ShutdownTargetController>) {
void TargetController::onShutdownTargetControllerEvent(const Events::ShutdownTargetController&) {
this->shutdown();
}
void TargetController::onStateReportRequest(EventRef<Events::ReportTargetControllerState> event) {
auto stateEvent = std::make_shared<TargetControllerStateReported>(this->state);
void TargetController::onStateReportRequest(const Events::ReportTargetControllerState& event) {
auto stateEvent = std::make_shared<Events::TargetControllerStateReported>(this->state);
stateEvent->correlationId = event.id;
this->eventManager.triggerEvent(stateEvent);
}
void TargetController::onDebugSessionStartedEvent(EventRef<Events::DebugSessionStarted>) {
void TargetController::onDebugSessionStartedEvent(const Events::DebugSessionStarted&) {
if (this->state == TargetControllerState::SUSPENDED) {
Logger::debug("Waking TargetController");
@@ -385,7 +385,7 @@ void TargetController::onDebugSessionStartedEvent(EventRef<Events::DebugSessionS
}
}
void TargetController::onDebugSessionFinishedEvent(EventRef<DebugSessionFinished>) {
void TargetController::onDebugSessionFinishedEvent(const DebugSessionFinished&) {
if (this->target->getState() != TargetState::RUNNING) {
this->target->run();
this->fireTargetEvents();
@@ -396,7 +396,7 @@ void TargetController::onDebugSessionFinishedEvent(EventRef<DebugSessionFinished
}
}
void TargetController::onExtractTargetDescriptor(EventRef<Events::ExtractTargetDescriptor> event) {
void TargetController::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) {
if (!this->cachedTargetDescriptor.has_value()) {
this->cachedTargetDescriptor = this->target->getDescriptor();
}
@@ -408,13 +408,13 @@ void TargetController::onExtractTargetDescriptor(EventRef<Events::ExtractTargetD
this->eventManager.triggerEvent(targetDescriptorExtracted);
}
void TargetController::onStopTargetExecutionEvent(EventRef<Events::StopTargetExecution> event) {
void TargetController::onStopTargetExecutionEvent(const Events::StopTargetExecution& event) {
if (this->target->getState() != TargetState::STOPPED) {
this->target->stop();
this->lastTargetState = TargetState::STOPPED;
}
auto executionStoppedEvent = std::make_shared<TargetExecutionStopped>(
auto executionStoppedEvent = std::make_shared<Events::TargetExecutionStopped>(
this->target->getProgramCounter(),
TargetBreakCause::UNKNOWN
);
@@ -423,7 +423,7 @@ void TargetController::onStopTargetExecutionEvent(EventRef<Events::StopTargetExe
this->eventManager.triggerEvent(executionStoppedEvent);
}
void TargetController::onStepTargetExecutionEvent(EventRef<Events::StepTargetExecution> event) {
void TargetController::onStepTargetExecutionEvent(const Events::StepTargetExecution& event) {
try {
if (this->target->getState() != TargetState::STOPPED) {
// We can't step the target if it's already running.
@@ -437,7 +437,7 @@ void TargetController::onStepTargetExecutionEvent(EventRef<Events::StepTargetExe
this->target->step();
this->lastTargetState = TargetState::RUNNING;
auto executionResumedEvent = std::make_shared<TargetExecutionResumed>();
auto executionResumedEvent = std::make_shared<Events::TargetExecutionResumed>();
executionResumedEvent->correlationId = event.id;
this->eventManager.triggerEvent(executionResumedEvent);
@@ -447,7 +447,7 @@ void TargetController::onStepTargetExecutionEvent(EventRef<Events::StepTargetExe
}
}
void TargetController::onResumeTargetExecutionEvent(EventRef<Events::ResumeTargetExecution> event) {
void TargetController::onResumeTargetExecutionEvent(const Events::ResumeTargetExecution& event) {
try {
if (this->target->getState() != TargetState::RUNNING) {
if (event.fromProgramCounter.has_value()) {
@@ -468,7 +468,7 @@ void TargetController::onResumeTargetExecutionEvent(EventRef<Events::ResumeTarge
}
}
void TargetController::onReadRegistersEvent(EventRef<Events::RetrieveRegistersFromTarget> event) {
void TargetController::onReadRegistersEvent(const Events::RetrieveRegistersFromTarget& event) {
try {
auto registers = this->target->readRegisters(event.descriptors);
@@ -485,7 +485,7 @@ void TargetController::onReadRegistersEvent(EventRef<Events::RetrieveRegistersFr
}
}
void TargetController::onWriteRegistersEvent(EventRef<Events::WriteRegistersToTarget> event) {
void TargetController::onWriteRegistersEvent(const Events::WriteRegistersToTarget& event) {
try {
this->target->writeRegisters(event.registers);
@@ -499,7 +499,7 @@ void TargetController::onWriteRegistersEvent(EventRef<Events::WriteRegistersToTa
}
}
void TargetController::onReadMemoryEvent(EventRef<Events::RetrieveMemoryFromTarget> event) {
void TargetController::onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event) {
try {
auto memoryReadEvent = std::make_shared<Events::MemoryRetrievedFromTarget>();
memoryReadEvent->correlationId = event.id;
@@ -513,7 +513,7 @@ void TargetController::onReadMemoryEvent(EventRef<Events::RetrieveMemoryFromTarg
}
}
void TargetController::onWriteMemoryEvent(EventRef<Events::WriteMemoryToTarget> event) {
void TargetController::onWriteMemoryEvent(const Events::WriteMemoryToTarget& event) {
try {
this->target->writeMemory(event.memoryType, event.startAddress, event.buffer);
@@ -536,7 +536,7 @@ void TargetController::onWriteMemoryEvent(EventRef<Events::WriteMemoryToTarget>
}
}
void TargetController::onSetBreakpointEvent(EventRef<Events::SetBreakpointOnTarget> event) {
void TargetController::onSetBreakpointEvent(const Events::SetBreakpointOnTarget& event) {
try {
this->target->setBreakpoint(event.breakpoint.address);
auto breakpointSetEvent = std::make_shared<Events::BreakpointSetOnTarget>();
@@ -550,7 +550,7 @@ void TargetController::onSetBreakpointEvent(EventRef<Events::SetBreakpointOnTarg
}
}
void TargetController::onRemoveBreakpointEvent(EventRef<Events::RemoveBreakpointOnTarget> event) {
void TargetController::onRemoveBreakpointEvent(const Events::RemoveBreakpointOnTarget& event) {
try {
this->target->removeBreakpoint(event.breakpoint.address);
auto breakpointRemovedEvent = std::make_shared<Events::BreakpointRemovedOnTarget>();
@@ -564,7 +564,7 @@ void TargetController::onRemoveBreakpointEvent(EventRef<Events::RemoveBreakpoint
}
}
void TargetController::onSetProgramCounterEvent(EventRef<Events::SetProgramCounterOnTarget> event) {
void TargetController::onSetProgramCounterEvent(const 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");
@@ -583,7 +583,7 @@ void TargetController::onSetProgramCounterEvent(EventRef<Events::SetProgramCount
}
// TODO: remove this
void TargetController::onInsightStateChangedEvent(EventRef<Events::InsightThreadStateChanged> event) {
void TargetController::onInsightStateChangedEvent(const Events::InsightThreadStateChanged& event) {
if (event.getState() == ThreadState::READY) {
/*
* Insight has just started up.
@@ -595,7 +595,7 @@ void TargetController::onInsightStateChangedEvent(EventRef<Events::InsightThread
}
}
void TargetController::onRetrieveTargetPinStatesEvent(EventRef<Events::RetrieveTargetPinStates> event) {
void TargetController::onRetrieveTargetPinStatesEvent(const 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");
@@ -614,7 +614,7 @@ void TargetController::onRetrieveTargetPinStatesEvent(EventRef<Events::RetrieveT
}
}
void TargetController::onSetPinStateEvent(EventRef<Events::SetTargetPinState> event) {
void TargetController::onSetPinStateEvent(const 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");

36
src/TargetController/TargetController.hpp
View File

@@ -244,70 +244,70 @@ namespace Bloom
*
* @param event
*/
void onStateReportRequest(Events::EventRef<Events::ReportTargetControllerState> event);
void onStateReportRequest(const Events::ReportTargetControllerState& event);
/**
* Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event.
*
* @param event
*/
void onExtractTargetDescriptor(Events::EventRef<Events::ExtractTargetDescriptor> event);
void onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event);
/**
* Will attempt to stop execution on the target and emit a TargetExecutionStopped event.
*
* @param event
*/
void onStopTargetExecutionEvent(Events::EventRef<Events::StopTargetExecution> event);
void onStopTargetExecutionEvent(const Events::StopTargetExecution& event);
/**
* Will attempt to step execution on the target and emit a TargetExecutionResumed event.
*
* @param event
*/
void onStepTargetExecutionEvent(Events::EventRef<Events::StepTargetExecution> event);
void onStepTargetExecutionEvent(const Events::StepTargetExecution& event);
/**
* Will attempt to resume execution on the target and emit a TargetExecutionResumed event.
*
* @param event
*/
void onResumeTargetExecutionEvent(Events::EventRef<Events::ResumeTargetExecution> event);
void onResumeTargetExecutionEvent(const Events::ResumeTargetExecution& event);
/**
* Invokes a shutdown.
*
* @param event
*/
void onShutdownTargetControllerEvent(Events::EventRef<Events::ShutdownTargetController> event);
void onShutdownTargetControllerEvent(const Events::ShutdownTargetController& event);
/**
* Will attempt to read the requested registers and emit a RegistersRetrievedFromTarget event.
*
* @param event
*/
void onReadRegistersEvent(Events::EventRef<Events::RetrieveRegistersFromTarget> event);
void onReadRegistersEvent(const Events::RetrieveRegistersFromTarget& event);
/**
* Will attempt to write the specified register values and emit a RegistersWrittenToTarget event.
*
* @param event
*/
void onWriteRegistersEvent(Events::EventRef<Events::WriteRegistersToTarget> event);
void onWriteRegistersEvent(const Events::WriteRegistersToTarget& event);
/**
* Will attempt to read memory from the target and include the data in a MemoryRetrievedFromTarget event.
*
* @param event
*/
void onReadMemoryEvent(Events::EventRef<Events::RetrieveMemoryFromTarget> event);
void onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& event);
/**
* Will attempt to write memory to the target. On success, a MemoryWrittenToTarget event is emitted.
*
* @param event
*/
void onWriteMemoryEvent(Events::EventRef<Events::WriteMemoryToTarget> event);
void onWriteMemoryEvent(const 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::EventRef<Events::SetBreakpointOnTarget> event);
void onSetBreakpointEvent(const 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::EventRef<Events::RemoveBreakpointOnTarget> event);
void onRemoveBreakpointEvent(const Events::RemoveBreakpointOnTarget& event);
/**
* Will hold the target stopped at it's current state.
*
* @param event
*/
void onDebugSessionStartedEvent(Events::EventRef<Events::DebugSessionStarted> event);
void onDebugSessionStartedEvent(const Events::DebugSessionStarted& event);
/**
* Will simply kick off execution on the target.
*
* @param event
*/
void onDebugSessionFinishedEvent(Events::EventRef<Events::DebugSessionFinished> event);
void onDebugSessionFinishedEvent(const 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::EventRef<Events::SetProgramCounterOnTarget> event);
void onSetProgramCounterEvent(const Events::SetProgramCounterOnTarget& event);
/**
* Will automatically fire a target state update event.
@@ -353,14 +353,14 @@ namespace Bloom
*
* @param event
*/
void onInsightStateChangedEvent(Events::EventRef<Events::InsightThreadStateChanged> event);
void onInsightStateChangedEvent(const 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::EventRef<Events::RetrieveTargetPinStates> event);
void onRetrieveTargetPinStatesEvent(const 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::EventRef<Events::SetTargetPinState> event);
void onSetPinStateEvent(const Events::SetTargetPinState& event);
};
}