From 3554960a1923c5af23595d70152f90483e01a5d4 Mon Sep 17 00:00:00 2001 From: Nav Date: Thu, 19 Aug 2021 22:06:59 +0100 Subject: [PATCH] Removed unnecessary use of std::string for event management, in an attempt to reduce memory consumption. Now using 16 bit enums for event types. --- src/EventManager/EventListener.cpp | 20 ++-- src/EventManager/EventListener.hpp | 101 +++++++++++------- src/EventManager/EventManager.cpp | 5 +- .../Events/BreakpointRemovedOnTarget.hpp | 5 + .../Events/BreakpointSetOnTarget.hpp | 5 + .../Events/DebugServerThreadStateChanged.hpp | 7 +- .../Events/DebugSessionFinished.hpp | 5 + .../Events/DebugSessionStarted.hpp | 5 + src/EventManager/Events/Event.hpp | 48 +++++++++ src/EventManager/Events/Events.hpp | 3 + .../Events/ExtractTargetDescriptor.hpp | 9 ++ .../Events/InsightThreadStateChanged.hpp | 6 ++ .../Events/MemoryRetrievedFromTarget.hpp | 5 + .../Events/MemoryWrittenToTarget.hpp | 9 +- .../Events/ProgramCounterSetOnTarget.hpp | 5 + .../Events/RegistersRetrievedFromTarget.hpp | 5 + .../Events/RegistersWrittenToTarget.hpp | 5 + .../Events/RemoveBreakpointOnTarget.hpp | 5 + .../Events/ReportTargetControllerState.hpp | 7 +- src/EventManager/Events/ResetTarget.hpp | 5 + .../Events/ResumeTargetExecution.hpp | 11 +- .../Events/RetrieveMemoryFromTarget.hpp | 5 + .../Events/RetrieveRegistersFromTarget.hpp | 5 + .../Events/RetrieveTargetPinStates.hpp | 5 + .../Events/SetBreakpointOnTarget.hpp | 5 + .../Events/SetProgramCounterOnTarget.hpp | 5 + src/EventManager/Events/SetTargetPinState.hpp | 5 + .../Events/ShutdownApplication.hpp | 5 + .../Events/ShutdownDebugServer.hpp | 5 + .../Events/ShutdownTargetController.hpp | 5 + .../Events/StepTargetExecution.hpp | 11 +- .../Events/StopTargetExecution.hpp | 7 +- .../Events/TargetControllerErrorOccurred.hpp | 5 + .../Events/TargetControllerStateReported.hpp | 8 +- .../TargetControllerThreadStateChanged.hpp | 7 +- .../Events/TargetDescriptorExtracted.hpp | 5 + .../Events/TargetExecutionResumed.hpp | 5 + .../Events/TargetExecutionStopped.hpp | 5 + .../Events/TargetIoPortsUpdated.hpp | 5 + .../Events/TargetPinStatesRetrieved.hpp | 5 + .../Events/WriteMemoryToTarget.hpp | 13 ++- .../Events/WriteRegistersToTarget.hpp | 11 +- 42 files changed, 336 insertions(+), 72 deletions(-) diff --git a/src/EventManager/EventListener.cpp b/src/EventManager/EventListener.cpp index 2d7984e5..73128d3b 100644 --- a/src/EventManager/EventListener.cpp +++ b/src/EventManager/EventListener.cpp @@ -3,7 +3,7 @@ using namespace Bloom; using namespace Bloom::Events; -std::set EventListener::getRegisteredEventTypeNames() { +std::set EventListener::getRegisteredEventTypes() { return this->registeredEventTypes.getValue(); } @@ -13,13 +13,12 @@ void EventListener::clearAllCallbacks() { } void EventListener::registerEvent(SharedGenericEventPointer event) { - auto eventType = event->getName(); - Logger::debug("Event \"" + eventType + "\" (" + std::to_string(event->id) - + ") registered for listener " + this->name); + Logger::debug("Event \"" + event->getName() + "\" (" + std::to_string(event->id) + + ") registered for listener " + this->name); auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - eventQueueByType[eventType].push(std::move(event)); + eventQueueByType[event->getType()].push(std::move(event)); this->eventQueueByEventTypeCV.notify_all(); if (this->interruptEventNotifier != nullptr && this->interruptEventNotifier->isInitialised()) { @@ -47,11 +46,10 @@ std::vector EventListener::getEvents() { } void EventListener::dispatchEvent(const SharedGenericEventPointer& event) { - auto eventName = event->getName(); - Logger::debug("Dispatching event " + eventName + " (" + std::to_string(event->id) + ")."); + Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ")."); // Dispatch the event to all registered handlers auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); - auto& callbacks = this->eventTypeToCallbacksMapping.getReference().find(eventName)->second; + auto& callbacks = this->eventTypeToCallbacksMapping.getReference().find(event->getType())->second; mappingLock.unlock(); for (auto& callback : callbacks) { @@ -70,14 +68,12 @@ void EventListener::dispatchCurrentEvents() { void EventListener::waitAndDispatch(int msTimeout) { auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - auto registeredEventTypes = this->getRegisteredEventTypeNames(); + auto registeredEventTypes = this->getRegisteredEventTypes(); std::optional event; auto eventsFound = [®isteredEventTypes, &event, &eventQueueByType]() -> bool { for (auto& eventQueue: eventQueueByType) { - if (registeredEventTypes.find(eventQueue.first) != registeredEventTypes.end() - && !eventQueue.second.empty() - ) { + if (registeredEventTypes.contains(eventQueue.first) && !eventQueue.second.empty()) { return true; } } diff --git a/src/EventManager/EventListener.hpp b/src/EventManager/EventListener.hpp index 018a5c29..9e6304fd 100644 --- a/src/EventManager/EventListener.hpp +++ b/src/EventManager/EventListener.hpp @@ -56,22 +56,22 @@ namespace Bloom /** * Holds all events registered to this listener. * - * Events are grouped by event type name, and removed from their queue just *before* the dispatching to + * Events are grouped by event type, and removed from their queue just *before* the dispatching to * registered handlers begins. */ - SyncSafe>> eventQueueByEventType; + SyncSafe>> eventQueueByEventType; std::condition_variable eventQueueByEventTypeCV; /** - * A mapping of event type names to a vector of callback functions. Events will be dispatched to these + * A mapping of event types to a vector of callback functions. Events will be dispatched to these * callback functions, during a call to EventListener::dispatchEvent(). * * Each callback will be passed a reference to the event (we wrap all registered callbacks in a lambda, where * we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType() * for more) */ - SyncSafe>>> eventTypeToCallbacksMapping; - SyncSafe> registeredEventTypes; + SyncSafe>>> eventTypeToCallbacksMapping; + SyncSafe> registeredEventTypes; std::shared_ptr interruptEventNotifier = nullptr; @@ -85,11 +85,41 @@ namespace Bloom }; /** - * Generates a list of event types names currently registered in the listener. + * Generates a list of event types currently registered in the listener. * * @return */ - std::set getRegisteredEventTypeNames(); + std::set getRegisteredEventTypes(); + + template + bool isEventTypeRegistered() { + return this->registeredEventTypes.getReference().contains(EventType::type); + } + + bool isEventTypeRegistered(Events::EventType eventType) { + return this->registeredEventTypes.getReference().contains(eventType); + }; + + /** + * Registers an event type for the listener. + * + * Any events of EventType that are triggered from the point of calling this function, will be stored in + * listener queue until they are dispatched to a callback, or retrieved via a call to this->waitForEvent() or + * similar. + * + * @tparam EventType + */ + template + void registerEventType() { + auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); + this->registeredEventTypes.getReference().insert(EventType::type); + } + + template + void deRegisterEventType() { + auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); + this->registeredEventTypes.getReference().erase(EventType::type); + } /** * Registers an event with the event listener @@ -122,9 +152,8 @@ namespace Bloom auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); auto& mapping = this->eventTypeToCallbacksMapping.getReference(); - mapping[EventType::name].push_back(parentCallback); - auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); - this->registeredEventTypes.getReference().insert(EventType::name); + mapping[EventType::type].push_back(parentCallback); + this->template registerEventType(); } /** @@ -143,21 +172,21 @@ namespace Bloom auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); auto& mapping = this->eventTypeToCallbacksMapping.getReference(); - if (mapping.contains(EventType::name)) { - mapping.at(EventType::name).clear(); + if (mapping.contains(EventType::type)) { + mapping.at(EventType::type).clear(); } } { auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); - this->registeredEventTypes.getReference().erase(EventType::name); + this->registeredEventTypes.getReference().erase(EventType::type); } auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - if (eventQueueByType.contains(EventType::name)) { - eventQueueByType.erase(EventType::name); + if (eventQueueByType.contains(EventType::type)) { + eventQueueByType.erase(EventType::type); } } @@ -217,15 +246,15 @@ namespace Bloom auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getReference(); - auto eventTypeNames = std::set({EventTypeA::name}); - auto eventTypeNamesToDeRegister = std::set(); + auto eventTypes = std::set({EventTypeA::type}); + auto eventTypesToDeRegister = std::set(); if constexpr (!std::is_same_v) { static_assert( std::is_base_of_v, "All event types must be derived from the Event base class." ); - eventTypeNames.insert(EventTypeB::name); + eventTypes.insert(EventTypeB::type); } if constexpr (!std::is_same_v) { @@ -233,28 +262,28 @@ namespace Bloom std::is_base_of_v, "All event types must be derived from the Event base class." ); - eventTypeNames.insert(EventTypeC::name); + eventTypes.insert(EventTypeC::type); } { auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); auto& registeredEventTypes = this->registeredEventTypes.getReference(); - for (const auto& eventTypeName : eventTypeNames) { - if (registeredEventTypes.find(eventTypeName) == registeredEventTypes.end()) { - registeredEventTypes.insert(eventTypeName); - eventTypeNamesToDeRegister.insert(eventTypeName); + for (const auto& eventType : eventTypes) { + if (!registeredEventTypes.contains(eventType)) { + registeredEventTypes.insert(eventType); + eventTypesToDeRegister.insert(eventType); } } } Events::SharedGenericEventPointer foundEvent = nullptr; - auto eventsFound = [&eventTypeNames, &eventQueueByType, &correlationId, &foundEvent]() -> bool { - for (const auto& eventTypeName : eventTypeNames) { - if (eventQueueByType.find(eventTypeName) != eventQueueByType.end() - && !eventQueueByType.find(eventTypeName)->second.empty() + auto eventsFound = [&eventTypes, &eventQueueByType, &correlationId, &foundEvent]() -> bool { + for (const auto& eventType : eventTypes) { + if (eventQueueByType.find(eventType) != eventQueueByType.end() + && !eventQueueByType.find(eventType)->second.empty() ) { - auto& queue = eventQueueByType.find(eventTypeName)->second; + auto& queue = eventQueueByType.find(eventType)->second; while (!queue.empty()) { auto event = queue.front(); @@ -266,7 +295,7 @@ namespace Bloom return true; } - // Events that match in type but not correlation ID are disregarded + // Events that match in type but not correlation ID are discarded queue.pop(); } } @@ -282,25 +311,25 @@ namespace Bloom this->eventQueueByEventTypeCV.wait(queueLock, eventsFound); } - if (!eventTypeNamesToDeRegister.empty()) { + if (!eventTypesToDeRegister.empty()) { auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); auto& registeredEventTypes = this->registeredEventTypes.getReference(); - for (const auto& eventTypeName : eventTypeNamesToDeRegister) { - registeredEventTypes.erase(eventTypeName); + for (const auto& eventType : eventTypesToDeRegister) { + registeredEventTypes.erase(eventType); } } if (foundEvent != nullptr) { // If we're looking for multiple event types, use an std::variant. if constexpr (!std::is_same_v || !std::is_same_v) { - if (foundEvent->getName() == EventTypeA::name) { + if (foundEvent->getType() == EventTypeA::type) { output = std::optional( std::dynamic_pointer_cast(foundEvent) ); } else if constexpr (!std::is_same_v) { - if (foundEvent->getName() == EventTypeB::name) { + if (foundEvent->getType() == EventTypeB::type) { output = std::optional( std::dynamic_pointer_cast(foundEvent) ); @@ -308,7 +337,7 @@ namespace Bloom } if constexpr (!std::is_same_v) { - if (foundEvent->getName() == EventTypeC::name) { + if (foundEvent->getType() == EventTypeC::type) { output = std::optional( std::dynamic_pointer_cast(foundEvent) ); @@ -316,7 +345,7 @@ namespace Bloom } } else { - if (foundEvent->getName() == EventTypeA::name) { + if (foundEvent->getType() == EventTypeA::type) { output = std::dynamic_pointer_cast(foundEvent); } } diff --git a/src/EventManager/EventManager.cpp b/src/EventManager/EventManager.cpp index 49061a88..09323b9c 100644 --- a/src/EventManager/EventManager.cpp +++ b/src/EventManager/EventManager.cpp @@ -14,10 +14,9 @@ void EventManager::deregisterListener(size_t listenerId) { void EventManager::triggerEvent(const std::shared_ptr& event) { auto registerListenersLock = std::unique_lock(this->registerListenerMutex); - for(auto const& [listenerId, listener] : this->registeredListeners) { - auto registeredEventTypes = listener->getRegisteredEventTypeNames(); - if (registeredEventTypes.contains(event->getName())) { + for(auto const& [listenerId, listener] : this->registeredListeners) { + if (listener->isEventTypeRegistered(event->getType())) { listener->registerEvent(event); } } diff --git a/src/EventManager/Events/BreakpointRemovedOnTarget.hpp b/src/EventManager/Events/BreakpointRemovedOnTarget.hpp index 1ff5a95c..7d942094 100644 --- a/src/EventManager/Events/BreakpointRemovedOnTarget.hpp +++ b/src/EventManager/Events/BreakpointRemovedOnTarget.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class BreakpointRemovedOnTarget: public Event { public: + static inline EventType type = EventType::BREAKPOINT_REMOVED_ON_TARGET; static inline const std::string name = "BreakpointRemovedOnTarget"; + [[nodiscard]] EventType getType() const override { + return BreakpointRemovedOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return BreakpointRemovedOnTarget::name; } diff --git a/src/EventManager/Events/BreakpointSetOnTarget.hpp b/src/EventManager/Events/BreakpointSetOnTarget.hpp index a8ca2615..f05e3e8c 100644 --- a/src/EventManager/Events/BreakpointSetOnTarget.hpp +++ b/src/EventManager/Events/BreakpointSetOnTarget.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class BreakpointSetOnTarget: public Event { public: + static inline EventType type = EventType::BREAKPOINT_SET_ON_TARGET; static inline const std::string name = "BreakpointSetOnTarget"; + [[nodiscard]] EventType getType() const override { + return BreakpointSetOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return BreakpointSetOnTarget::name; } diff --git a/src/EventManager/Events/DebugServerThreadStateChanged.hpp b/src/EventManager/Events/DebugServerThreadStateChanged.hpp index 08922d5f..592285cc 100644 --- a/src/EventManager/Events/DebugServerThreadStateChanged.hpp +++ b/src/EventManager/Events/DebugServerThreadStateChanged.hpp @@ -12,9 +12,14 @@ namespace Bloom::Events private: ThreadState state; public: + static inline EventType type = EventType::DEBUG_SERVER_THREAD_STATE_CHANGED; + static inline const std::string name = "DebugServerThreadStateChanged"; + explicit DebugServerThreadStateChanged(ThreadState state): state(state) {}; - static inline const std::string name = "DebugServerThreadStateChanged"; + [[nodiscard]] EventType getType() const override { + return DebugServerThreadStateChanged::type; + } [[nodiscard]] std::string getName() const override { return DebugServerThreadStateChanged::name; diff --git a/src/EventManager/Events/DebugSessionFinished.hpp b/src/EventManager/Events/DebugSessionFinished.hpp index 7ef20568..a0b497f8 100644 --- a/src/EventManager/Events/DebugSessionFinished.hpp +++ b/src/EventManager/Events/DebugSessionFinished.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class DebugSessionFinished: public Event { public: + static inline EventType type = EventType::DEBUG_SESSION_FINISHED; static inline const std::string name = "DebugSessionFinished"; + [[nodiscard]] EventType getType() const override { + return DebugSessionFinished::type; + } + [[nodiscard]] std::string getName() const override { return DebugSessionFinished::name; } diff --git a/src/EventManager/Events/DebugSessionStarted.hpp b/src/EventManager/Events/DebugSessionStarted.hpp index 6a7b5e9e..a237ad15 100644 --- a/src/EventManager/Events/DebugSessionStarted.hpp +++ b/src/EventManager/Events/DebugSessionStarted.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class DebugSessionStarted: public Event { public: + static inline EventType type = EventType::DEBUG_SESSION_STARTED; static inline const std::string name = "DebugSessionStarted"; + [[nodiscard]] EventType getType() const override { + return DebugSessionStarted::type; + } + [[nodiscard]] std::string getName() const override { return DebugSessionStarted::name; } diff --git a/src/EventManager/Events/Event.hpp b/src/EventManager/Events/Event.hpp index a01019c6..5151abcb 100644 --- a/src/EventManager/Events/Event.hpp +++ b/src/EventManager/Events/Event.hpp @@ -4,6 +4,7 @@ #include #include #include +#include #include "src/Helpers/DateTime.hpp" @@ -11,6 +12,48 @@ namespace Bloom::Events { static_assert(std::atomic::is_always_lock_free); + enum EventType: std::uint16_t + { + GENERIC, + STOP_TARGET_EXECUTION, + RESUME_TARGET_EXECUTION, + RESET_TARGET, + DEBUG_SESSION_STARTED, + DEBUG_SESSION_FINISHED, + TARGET_CONTROLLER_THREAD_STATE_CHANGED, + REPORT_TARGET_CONTROLLER_STATE, + TARGET_CONTROLLER_STATE_REPORTED, + SHUTDOWN_TARGET_CONTROLLER, + TARGET_CONTROLLER_ERROR_OCCURRED, + SHUTDOWN_APPLICATION, + DEBUG_SERVER_THREAD_STATE_CHANGED, + SHUTDOWN_DEBUG_SERVER, + RETRIEVE_REGISTERS_FROM_TARGET, + REGISTERS_RETRIEVED_FROM_TARGET, + WRITE_REGISTERS_TO_TARGET, + REGISTERS_WRITTEN_TO_TARGET, + TARGET_EXECUTION_RESUMED, + TARGET_EXECUTION_STOPPED, + RETRIEVE_MEMORY_FROM_TARGET, + MEMORY_RETRIEVED_FROM_TARGET, + WRITE_MEMORY_TO_TARGET, + MEMORY_WRITTEN_TO_TARGET, + SET_BREAKPOINT_ON_TARGET, + REMOVE_BREAKPOINT_ON_TARGET, + BREAKPOINT_SET_ON_TARGET, + BREAKPOINT_REMOVED_ON_TARGET, + STEP_TARGET_EXECUTION, + SET_PROGRAM_COUNTER_ON_TARGET, + PROGRAM_COUNTER_SET_ON_TARGET, + EXTRACT_TARGET_DESCRIPTOR, + TARGET_DESCRIPTOR_EXTRACTED, + INSIGHT_THREAD_STATE_CHANGED, + RETRIEVE_TARGET_PIN_STATES, + TARGET_PIN_STATES_RETRIEVED, + SET_TARGET_PIN_STATE, + TARGET_IO_PORTS_UPDATED, + }; + class Event { private: @@ -21,10 +64,15 @@ namespace Bloom::Events QDateTime createdTimestamp = DateTime::currentDateTime(); std::optional correlationId; + static inline EventType type = EventType::GENERIC; static inline const std::string name = "GenericEvent"; [[nodiscard]] virtual std::string getName() const { return Event::name; } + + [[nodiscard]] virtual EventType getType() const { + return Event::type; + } }; } diff --git a/src/EventManager/Events/Events.hpp b/src/EventManager/Events/Events.hpp index 21bf733f..e0f7a748 100644 --- a/src/EventManager/Events/Events.hpp +++ b/src/EventManager/Events/Events.hpp @@ -46,5 +46,8 @@ namespace Bloom::Events template using SharedEventPointer = std::shared_ptr; + template + using SharedEventPointerNonConst = std::shared_ptr; + using SharedGenericEventPointer = SharedEventPointer; } diff --git a/src/EventManager/Events/ExtractTargetDescriptor.hpp b/src/EventManager/Events/ExtractTargetDescriptor.hpp index 5685dddf..1681a92e 100644 --- a/src/EventManager/Events/ExtractTargetDescriptor.hpp +++ b/src/EventManager/Events/ExtractTargetDescriptor.hpp @@ -4,13 +4,22 @@ #include "Event.hpp" +#include "TargetDescriptorExtracted.hpp" + namespace Bloom::Events { class ExtractTargetDescriptor: public Event { public: + using TargetControllerResponseType = TargetDescriptorExtracted; + + static inline EventType type = EventType::EXTRACT_TARGET_DESCRIPTOR; static inline const std::string name = "ExtractTargetDescriptor"; + [[nodiscard]] EventType getType() const override { + return ExtractTargetDescriptor::type; + } + [[nodiscard]] std::string getName() const override { return ExtractTargetDescriptor::name; } diff --git a/src/EventManager/Events/InsightThreadStateChanged.hpp b/src/EventManager/Events/InsightThreadStateChanged.hpp index 559ec6ec..c6c8d442 100644 --- a/src/EventManager/Events/InsightThreadStateChanged.hpp +++ b/src/EventManager/Events/InsightThreadStateChanged.hpp @@ -11,11 +11,17 @@ namespace Bloom::Events { private: ThreadState state; + public: explicit InsightThreadStateChanged(ThreadState state): state(state) {}; + static inline EventType type = EventType::INSIGHT_THREAD_STATE_CHANGED; static inline const std::string name = "InsightThreadStateChanged"; + [[nodiscard]] EventType getType() const override { + return InsightThreadStateChanged::type; + } + [[nodiscard]] std::string getName() const override { return InsightThreadStateChanged::name; } diff --git a/src/EventManager/Events/MemoryRetrievedFromTarget.hpp b/src/EventManager/Events/MemoryRetrievedFromTarget.hpp index 07278e57..24e75758 100644 --- a/src/EventManager/Events/MemoryRetrievedFromTarget.hpp +++ b/src/EventManager/Events/MemoryRetrievedFromTarget.hpp @@ -10,9 +10,14 @@ namespace Bloom::Events class MemoryRetrievedFromTarget: public Event { public: + static inline EventType type = EventType::MEMORY_RETRIEVED_FROM_TARGET; static inline const std::string name = "MemoryRetrievedFromTarget"; Targets::TargetMemoryBuffer data; + [[nodiscard]] EventType getType() const override { + return MemoryRetrievedFromTarget::type; + } + [[nodiscard]] std::string getName() const override { return MemoryRetrievedFromTarget::name; } diff --git a/src/EventManager/Events/MemoryWrittenToTarget.hpp b/src/EventManager/Events/MemoryWrittenToTarget.hpp index 9c9b2715..76652537 100644 --- a/src/EventManager/Events/MemoryWrittenToTarget.hpp +++ b/src/EventManager/Events/MemoryWrittenToTarget.hpp @@ -10,12 +10,17 @@ namespace Bloom::Events class MemoryWrittenToTarget: public Event { public: + static inline EventType type = EventType::MEMORY_WRITTEN_TO_TARGET; static inline const std::string name = "MemoryWrittenToTarget"; + MemoryWrittenToTarget() = default; + + [[nodiscard]] EventType getType() const override { + return MemoryWrittenToTarget::type; + } + [[nodiscard]] std::string getName() const override { return MemoryWrittenToTarget::name; } - - MemoryWrittenToTarget() = default; }; } diff --git a/src/EventManager/Events/ProgramCounterSetOnTarget.hpp b/src/EventManager/Events/ProgramCounterSetOnTarget.hpp index 545aaa54..4602c1eb 100644 --- a/src/EventManager/Events/ProgramCounterSetOnTarget.hpp +++ b/src/EventManager/Events/ProgramCounterSetOnTarget.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class ProgramCounterSetOnTarget: public Event { public: + static inline EventType type = EventType::PROGRAM_COUNTER_SET_ON_TARGET; static inline const std::string name = "ProgramCounterSetOnTarget"; + [[nodiscard]] EventType getType() const override { + return ProgramCounterSetOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return ProgramCounterSetOnTarget::name; } diff --git a/src/EventManager/Events/RegistersRetrievedFromTarget.hpp b/src/EventManager/Events/RegistersRetrievedFromTarget.hpp index 6eb483dd..a0e35e48 100644 --- a/src/EventManager/Events/RegistersRetrievedFromTarget.hpp +++ b/src/EventManager/Events/RegistersRetrievedFromTarget.hpp @@ -10,9 +10,14 @@ namespace Bloom::Events class RegistersRetrievedFromTarget: public Event { public: + static inline EventType type = EventType::REGISTERS_RETRIEVED_FROM_TARGET; static inline const std::string name = "RegistersRetrievedFromTarget"; Targets::TargetRegisters registers; + [[nodiscard]] EventType getType() const override { + return RegistersRetrievedFromTarget::type; + } + [[nodiscard]] std::string getName() const override { return RegistersRetrievedFromTarget::name; } diff --git a/src/EventManager/Events/RegistersWrittenToTarget.hpp b/src/EventManager/Events/RegistersWrittenToTarget.hpp index 082b96f1..cb57896b 100644 --- a/src/EventManager/Events/RegistersWrittenToTarget.hpp +++ b/src/EventManager/Events/RegistersWrittenToTarget.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class RegistersWrittenToTarget: public Event { public: + static inline EventType type = EventType::REGISTERS_WRITTEN_TO_TARGET; static inline const std::string name = "RegistersWrittenToTarget"; + [[nodiscard]] EventType getType() const override { + return RegistersWrittenToTarget::type; + } + [[nodiscard]] std::string getName() const override { return RegistersWrittenToTarget::name; } diff --git a/src/EventManager/Events/RemoveBreakpointOnTarget.hpp b/src/EventManager/Events/RemoveBreakpointOnTarget.hpp index 605f5030..3e1adc8e 100644 --- a/src/EventManager/Events/RemoveBreakpointOnTarget.hpp +++ b/src/EventManager/Events/RemoveBreakpointOnTarget.hpp @@ -11,9 +11,14 @@ namespace Bloom::Events class RemoveBreakpointOnTarget: public Event { public: + static inline EventType type = EventType::REMOVE_BREAKPOINT_ON_TARGET; static inline const std::string name = "RemoveBreakpointOnTarget"; Targets::TargetBreakpoint breakpoint; + [[nodiscard]] EventType getType() const override { + return RemoveBreakpointOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return RemoveBreakpointOnTarget::name; } diff --git a/src/EventManager/Events/ReportTargetControllerState.hpp b/src/EventManager/Events/ReportTargetControllerState.hpp index 547c32a5..32dd56af 100644 --- a/src/EventManager/Events/ReportTargetControllerState.hpp +++ b/src/EventManager/Events/ReportTargetControllerState.hpp @@ -9,9 +9,14 @@ namespace Bloom::Events class ReportTargetControllerState: public Event { public: + static inline EventType type = EventType::REPORT_TARGET_CONTROLLER_STATE; + static inline const std::string name = "ReportTargetControllerState"; + ReportTargetControllerState() {}; - static inline const std::string name = "ReportTargetControllerState"; + [[nodiscard]] EventType getType() const override { + return ReportTargetControllerState::type; + } [[nodiscard]] std::string getName() const override { return ReportTargetControllerState::name; diff --git a/src/EventManager/Events/ResetTarget.hpp b/src/EventManager/Events/ResetTarget.hpp index eebc72ee..9ac0753e 100644 --- a/src/EventManager/Events/ResetTarget.hpp +++ b/src/EventManager/Events/ResetTarget.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class ResetTarget: public Event { public: + static inline EventType type = EventType::RESET_TARGET; static inline const std::string name = "ResetTargetEvent"; + [[nodiscard]] EventType getType() const override { + return ResetTarget::type; + } + [[nodiscard]] std::string getName() const override { return ResetTarget::name; } diff --git a/src/EventManager/Events/ResumeTargetExecution.hpp b/src/EventManager/Events/ResumeTargetExecution.hpp index b417313d..31afb0dd 100644 --- a/src/EventManager/Events/ResumeTargetExecution.hpp +++ b/src/EventManager/Events/ResumeTargetExecution.hpp @@ -10,14 +10,19 @@ namespace Bloom::Events class ResumeTargetExecution: public Event { public: + static inline EventType type = EventType::RESUME_TARGET_EXECUTION; static inline const std::string name = "ResumeTargetExecutionEvent"; std::optional fromProgramCounter; + ResumeTargetExecution() = default; + explicit ResumeTargetExecution(std::uint32_t fromProgramCounter): fromProgramCounter(fromProgramCounter) {}; + + [[nodiscard]] EventType getType() const override { + return ResumeTargetExecution::type; + } + [[nodiscard]] std::string getName() const override { return ResumeTargetExecution::name; } - - ResumeTargetExecution() = default; - explicit ResumeTargetExecution(std::uint32_t fromProgramCounter): fromProgramCounter(fromProgramCounter) {}; }; } diff --git a/src/EventManager/Events/RetrieveMemoryFromTarget.hpp b/src/EventManager/Events/RetrieveMemoryFromTarget.hpp index 8e968709..a828e7ae 100644 --- a/src/EventManager/Events/RetrieveMemoryFromTarget.hpp +++ b/src/EventManager/Events/RetrieveMemoryFromTarget.hpp @@ -11,11 +11,16 @@ namespace Bloom::Events class RetrieveMemoryFromTarget: public Event { public: + static inline EventType type = EventType::RETRIEVE_MEMORY_FROM_TARGET; static inline const std::string name = "RetrieveMemoryFromTarget"; Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM; std::uint32_t startAddress = 0; std::uint32_t bytes = 0; + [[nodiscard]] EventType getType() const override { + return RetrieveMemoryFromTarget::type; + } + [[nodiscard]] std::string getName() const override { return RetrieveMemoryFromTarget::name; } diff --git a/src/EventManager/Events/RetrieveRegistersFromTarget.hpp b/src/EventManager/Events/RetrieveRegistersFromTarget.hpp index 4c1e03a0..ec819ae5 100644 --- a/src/EventManager/Events/RetrieveRegistersFromTarget.hpp +++ b/src/EventManager/Events/RetrieveRegistersFromTarget.hpp @@ -10,9 +10,14 @@ namespace Bloom::Events class RetrieveRegistersFromTarget: public Event { public: + static inline EventType type = EventType::RETRIEVE_REGISTERS_FROM_TARGET; static inline const std::string name = "RetrieveRegistersFromTarget"; Targets::TargetRegisterDescriptors descriptors; + [[nodiscard]] EventType getType() const override { + return RetrieveRegistersFromTarget::type; + } + [[nodiscard]] std::string getName() const override { return RetrieveRegistersFromTarget::name; } diff --git a/src/EventManager/Events/RetrieveTargetPinStates.hpp b/src/EventManager/Events/RetrieveTargetPinStates.hpp index f0889aa1..0f785a4f 100644 --- a/src/EventManager/Events/RetrieveTargetPinStates.hpp +++ b/src/EventManager/Events/RetrieveTargetPinStates.hpp @@ -9,9 +9,14 @@ namespace Bloom::Events class RetrieveTargetPinStates: public Event { public: + static inline EventType type = EventType::RETRIEVE_TARGET_PIN_STATES; static inline const std::string name = "RetrieveTargetPinStates"; int variantId = 0; + [[nodiscard]] EventType getType() const override { + return RetrieveTargetPinStates::type; + } + [[nodiscard]] std::string getName() const override { return RetrieveTargetPinStates::name; } diff --git a/src/EventManager/Events/SetBreakpointOnTarget.hpp b/src/EventManager/Events/SetBreakpointOnTarget.hpp index 37353367..46e82f7e 100644 --- a/src/EventManager/Events/SetBreakpointOnTarget.hpp +++ b/src/EventManager/Events/SetBreakpointOnTarget.hpp @@ -11,9 +11,14 @@ namespace Bloom::Events class SetBreakpointOnTarget: public Event { public: + static inline EventType type = EventType::SET_BREAKPOINT_ON_TARGET; static inline const std::string name = "SetBreakpointOnTarget"; Targets::TargetBreakpoint breakpoint; + [[nodiscard]] EventType getType() const override { + return SetBreakpointOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return SetBreakpointOnTarget::name; } diff --git a/src/EventManager/Events/SetProgramCounterOnTarget.hpp b/src/EventManager/Events/SetProgramCounterOnTarget.hpp index db75bc5d..5ed7fda1 100644 --- a/src/EventManager/Events/SetProgramCounterOnTarget.hpp +++ b/src/EventManager/Events/SetProgramCounterOnTarget.hpp @@ -10,9 +10,14 @@ namespace Bloom::Events class SetProgramCounterOnTarget: public Event { public: + static inline EventType type = EventType::SET_PROGRAM_COUNTER_ON_TARGET; static inline const std::string name = "SetProgramCounterOnTarget"; std::uint32_t address = 0; + [[nodiscard]] EventType getType() const override { + return SetProgramCounterOnTarget::type; + } + [[nodiscard]] std::string getName() const override { return SetProgramCounterOnTarget::name; } diff --git a/src/EventManager/Events/SetTargetPinState.hpp b/src/EventManager/Events/SetTargetPinState.hpp index 6f96d65d..44cb3473 100644 --- a/src/EventManager/Events/SetTargetPinState.hpp +++ b/src/EventManager/Events/SetTargetPinState.hpp @@ -10,11 +10,16 @@ namespace Bloom::Events class SetTargetPinState: public Event { public: + static inline EventType type = EventType::SET_TARGET_PIN_STATE; static inline const std::string name = "SetTargetPinState"; int variantId = 0; Targets::TargetPinDescriptor pinDescriptor; Targets::TargetPinState pinState; + [[nodiscard]] EventType getType() const override { + return SetTargetPinState::type; + } + [[nodiscard]] std::string getName() const override { return SetTargetPinState::name; } diff --git a/src/EventManager/Events/ShutdownApplication.hpp b/src/EventManager/Events/ShutdownApplication.hpp index b429b244..cfd7a1fe 100644 --- a/src/EventManager/Events/ShutdownApplication.hpp +++ b/src/EventManager/Events/ShutdownApplication.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class ShutdownApplication: public Event { public: + static inline EventType type = EventType::SHUTDOWN_APPLICATION; static inline const std::string name = "ShutdownApplicationEvent"; + [[nodiscard]] EventType getType() const override { + return ShutdownApplication::type; + } + [[nodiscard]] std::string getName() const override { return ShutdownApplication::name; } diff --git a/src/EventManager/Events/ShutdownDebugServer.hpp b/src/EventManager/Events/ShutdownDebugServer.hpp index 0c8c3922..fa04c6d3 100644 --- a/src/EventManager/Events/ShutdownDebugServer.hpp +++ b/src/EventManager/Events/ShutdownDebugServer.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class ShutdownDebugServer: public Event { public: + static inline EventType type = EventType::SHUTDOWN_DEBUG_SERVER; static inline const std::string name = "ShutdownDebugServer"; + [[nodiscard]] EventType getType() const override { + return ShutdownDebugServer::type; + } + [[nodiscard]] std::string getName() const override { return ShutdownDebugServer::name; } diff --git a/src/EventManager/Events/ShutdownTargetController.hpp b/src/EventManager/Events/ShutdownTargetController.hpp index 4ce1df57..dc56bc64 100644 --- a/src/EventManager/Events/ShutdownTargetController.hpp +++ b/src/EventManager/Events/ShutdownTargetController.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class ShutdownTargetController: public Event { public: + static inline EventType type = EventType::SHUTDOWN_TARGET_CONTROLLER; static inline const std::string name = "ShutdownTargetControllerEvent"; + [[nodiscard]] EventType getType() const override { + return ShutdownTargetController::type; + } + [[nodiscard]] std::string getName() const override { return ShutdownTargetController::name; } diff --git a/src/EventManager/Events/StepTargetExecution.hpp b/src/EventManager/Events/StepTargetExecution.hpp index 9ac0d121..94d50026 100644 --- a/src/EventManager/Events/StepTargetExecution.hpp +++ b/src/EventManager/Events/StepTargetExecution.hpp @@ -10,14 +10,19 @@ namespace Bloom::Events class StepTargetExecution: public Event { public: + static inline EventType type = EventType::STEP_TARGET_EXECUTION; static inline const std::string name = "StepTargetExecution"; std::optional fromProgramCounter; + StepTargetExecution() = default; + explicit StepTargetExecution(std::uint32_t fromProgramCounter): fromProgramCounter(fromProgramCounter) {}; + + [[nodiscard]] EventType getType() const override { + return StepTargetExecution::type; + } + [[nodiscard]] std::string getName() const override { return StepTargetExecution::name; } - - StepTargetExecution() = default; - explicit StepTargetExecution(std::uint32_t fromProgramCounter): fromProgramCounter(fromProgramCounter) {}; }; } diff --git a/src/EventManager/Events/StopTargetExecution.hpp b/src/EventManager/Events/StopTargetExecution.hpp index 73d82606..a6ec057a 100644 --- a/src/EventManager/Events/StopTargetExecution.hpp +++ b/src/EventManager/Events/StopTargetExecution.hpp @@ -9,7 +9,12 @@ namespace Bloom::Events class StopTargetExecution: public Event { public: - static inline const std::string name = "StopTargetEvent"; + static inline EventType type = EventType::STOP_TARGET_EXECUTION; + static inline const std::string name = "StopTargetExecution"; + + [[nodiscard]] EventType getType() const override { + return StopTargetExecution::type; + } [[nodiscard]] std::string getName() const override { return StopTargetExecution::name; diff --git a/src/EventManager/Events/TargetControllerErrorOccurred.hpp b/src/EventManager/Events/TargetControllerErrorOccurred.hpp index 23fa4bda..42229b45 100644 --- a/src/EventManager/Events/TargetControllerErrorOccurred.hpp +++ b/src/EventManager/Events/TargetControllerErrorOccurred.hpp @@ -9,10 +9,15 @@ namespace Bloom::Events class TargetControllerErrorOccurred: public Event { public: + static inline EventType type = EventType::TARGET_CONTROLLER_ERROR_OCCURRED; static inline const std::string name = "TargetControllerErrorOccurred"; TargetControllerErrorOccurred() = default; + [[nodiscard]] EventType getType() const override { + return TargetControllerErrorOccurred::type; + } + [[nodiscard]] std::string getName() const override { return TargetControllerErrorOccurred::name; } diff --git a/src/EventManager/Events/TargetControllerStateReported.hpp b/src/EventManager/Events/TargetControllerStateReported.hpp index 98e33e1d..498b756e 100644 --- a/src/EventManager/Events/TargetControllerStateReported.hpp +++ b/src/EventManager/Events/TargetControllerStateReported.hpp @@ -10,11 +10,15 @@ namespace Bloom::Events class TargetControllerStateReported: public Event { public: - TargetControllerState state; + static inline EventType type = EventType::TARGET_CONTROLLER_STATE_REPORTED; + static inline const std::string name = "TargetControllerStateReported"; + TargetControllerState state; explicit TargetControllerStateReported(TargetControllerState state): state(state) {}; - static inline const std::string name = "TargetControllerStateReported"; + [[nodiscard]] EventType getType() const override { + return TargetControllerStateReported::type; + } [[nodiscard]] std::string getName() const override { return TargetControllerStateReported::name; diff --git a/src/EventManager/Events/TargetControllerThreadStateChanged.hpp b/src/EventManager/Events/TargetControllerThreadStateChanged.hpp index 53131872..c18a42f1 100644 --- a/src/EventManager/Events/TargetControllerThreadStateChanged.hpp +++ b/src/EventManager/Events/TargetControllerThreadStateChanged.hpp @@ -13,9 +13,14 @@ namespace Bloom::Events ThreadState state; public: + static inline EventType type = EventType::TARGET_CONTROLLER_THREAD_STATE_CHANGED; + static inline const std::string name = "TargetControllerThreadStateChanged"; + explicit TargetControllerThreadStateChanged(ThreadState state): state(state) {}; - static inline const std::string name = "TargetControllerThreadStateChanged"; + [[nodiscard]] EventType getType() const override { + return TargetControllerThreadStateChanged::type; + } [[nodiscard]] std::string getName() const override { return TargetControllerThreadStateChanged::name; diff --git a/src/EventManager/Events/TargetDescriptorExtracted.hpp b/src/EventManager/Events/TargetDescriptorExtracted.hpp index 22b89f06..85f16460 100644 --- a/src/EventManager/Events/TargetDescriptorExtracted.hpp +++ b/src/EventManager/Events/TargetDescriptorExtracted.hpp @@ -10,9 +10,14 @@ namespace Bloom::Events class TargetDescriptorExtracted: public Event { public: + static inline EventType type = EventType::TARGET_DESCRIPTOR_EXTRACTED; static inline const std::string name = "TargetDescriptorExtracted"; Targets::TargetDescriptor targetDescriptor; + [[nodiscard]] EventType getType() const override { + return TargetDescriptorExtracted::type; + } + [[nodiscard]] std::string getName() const override { return TargetDescriptorExtracted::name; } diff --git a/src/EventManager/Events/TargetExecutionResumed.hpp b/src/EventManager/Events/TargetExecutionResumed.hpp index ef47a322..a876af26 100644 --- a/src/EventManager/Events/TargetExecutionResumed.hpp +++ b/src/EventManager/Events/TargetExecutionResumed.hpp @@ -9,10 +9,15 @@ namespace Bloom::Events class TargetExecutionResumed: public Event { public: + static inline EventType type = EventType::TARGET_EXECUTION_RESUMED; static inline const std::string name = "TargetExecutionResumed"; TargetExecutionResumed() = default; + [[nodiscard]] EventType getType() const override { + return TargetExecutionResumed::type; + } + [[nodiscard]] std::string getName() const override { return TargetExecutionResumed::name; } diff --git a/src/EventManager/Events/TargetExecutionStopped.hpp b/src/EventManager/Events/TargetExecutionStopped.hpp index 6b4a81e6..2412e2c4 100644 --- a/src/EventManager/Events/TargetExecutionStopped.hpp +++ b/src/EventManager/Events/TargetExecutionStopped.hpp @@ -11,6 +11,7 @@ namespace Bloom::Events class TargetExecutionStopped: public Event { public: + static inline EventType type = EventType::TARGET_EXECUTION_STOPPED; static inline const std::string name = "TargetExecutionStopped"; std::uint32_t programCounter; Targets::TargetBreakCause breakCause; @@ -18,6 +19,10 @@ namespace Bloom::Events TargetExecutionStopped(std::uint32_t programCounter, Targets::TargetBreakCause breakCause) : programCounter(programCounter), breakCause(breakCause) {} + [[nodiscard]] EventType getType() const override { + return TargetExecutionStopped::type; + } + [[nodiscard]] std::string getName() const override { return TargetExecutionStopped::name; } diff --git a/src/EventManager/Events/TargetIoPortsUpdated.hpp b/src/EventManager/Events/TargetIoPortsUpdated.hpp index ed883447..a90c719b 100644 --- a/src/EventManager/Events/TargetIoPortsUpdated.hpp +++ b/src/EventManager/Events/TargetIoPortsUpdated.hpp @@ -9,8 +9,13 @@ namespace Bloom::Events class TargetIoPortsUpdated: public Event { public: + static inline EventType type = EventType::TARGET_IO_PORTS_UPDATED; static inline const std::string name = "TargetIoPortsUpdated"; + [[nodiscard]] EventType getType() const override { + return TargetIoPortsUpdated::type; + } + [[nodiscard]] std::string getName() const override { return TargetIoPortsUpdated::name; } diff --git a/src/EventManager/Events/TargetPinStatesRetrieved.hpp b/src/EventManager/Events/TargetPinStatesRetrieved.hpp index cbbd9da8..2e4ccc07 100644 --- a/src/EventManager/Events/TargetPinStatesRetrieved.hpp +++ b/src/EventManager/Events/TargetPinStatesRetrieved.hpp @@ -11,10 +11,15 @@ namespace Bloom::Events class TargetPinStatesRetrieved: public Event { public: + static inline EventType type = EventType::TARGET_PIN_STATES_RETRIEVED; static inline const std::string name = "TargetPinStatesRetrieved"; int variantId = 0; std::map pinSatesByNumber; + [[nodiscard]] EventType getType() const override { + return TargetPinStatesRetrieved::type; + } + [[nodiscard]] std::string getName() const override { return TargetPinStatesRetrieved::name; } diff --git a/src/EventManager/Events/WriteMemoryToTarget.hpp b/src/EventManager/Events/WriteMemoryToTarget.hpp index 872fca6c..94c32d32 100644 --- a/src/EventManager/Events/WriteMemoryToTarget.hpp +++ b/src/EventManager/Events/WriteMemoryToTarget.hpp @@ -12,20 +12,25 @@ namespace Bloom::Events class WriteMemoryToTarget: public Event { public: + static inline EventType type = EventType::WRITE_MEMORY_TO_TARGET; static inline const std::string name = "WriteMemoryToTarget"; Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM; std::uint32_t startAddress = 0; Targets::TargetMemoryBuffer buffer; - [[nodiscard]] std::string getName() const override { - return WriteMemoryToTarget::name; - } - WriteMemoryToTarget() = default; WriteMemoryToTarget( Targets::TargetMemoryType memoryType, std::uint32_t startAddress, Targets::TargetMemoryBuffer buffer ): memoryType(memoryType), startAddress(startAddress), buffer(std::move(buffer)) {}; + + [[nodiscard]] EventType getType() const override { + return WriteMemoryToTarget::type; + } + + [[nodiscard]] std::string getName() const override { + return WriteMemoryToTarget::name; + } }; } diff --git a/src/EventManager/Events/WriteRegistersToTarget.hpp b/src/EventManager/Events/WriteRegistersToTarget.hpp index e67f252f..a255eec6 100644 --- a/src/EventManager/Events/WriteRegistersToTarget.hpp +++ b/src/EventManager/Events/WriteRegistersToTarget.hpp @@ -11,14 +11,19 @@ namespace Bloom::Events class WriteRegistersToTarget: public Event { public: + static inline EventType type = EventType::WRITE_REGISTERS_TO_TARGET; static inline const std::string name = "WriteRegistersToTarget"; Targets::TargetRegisters registers; + WriteRegistersToTarget() = default; + explicit WriteRegistersToTarget(Targets::TargetRegisters registers): registers(std::move(registers)) {}; + + [[nodiscard]] EventType getType() const override { + return WriteRegistersToTarget::type; + } + [[nodiscard]] std::string getName() const override { return WriteRegistersToTarget::name; } - - WriteRegistersToTarget() = default; - explicit WriteRegistersToTarget(Targets::TargetRegisters registers): registers(std::move(registers)) {}; }; }