Initial commit

src/EventManager/Events/BreakpointRemovedOnTarget.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class BreakpointRemovedOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "BreakpointRemovedOnTarget";
+
+        std::string getName() const override {
+            return BreakpointRemovedOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/BreakpointSetOnTarget.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <set>
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class BreakpointSetOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "BreakpointSetOnTarget";
+
+        std::string getName() const override {
+            return BreakpointSetOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/DebugServerStateChanged.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <src/Helpers/Thread.hpp>
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class DebugServerStateChanged: public Event
+    {
+    private:
+        ThreadState state;
+    public:
+        DebugServerStateChanged(ThreadState state) : state(state) {};
+
+        static inline const std::string name = "DebugServerStateChanged";
+
+        std::string getName() const override {
+            return DebugServerStateChanged::name;
+        }
+
+        ThreadState getState() const {
+            return this->state;
+        }
+    };
+}

src/EventManager/Events/DebugSessionFinished.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class DebugSessionFinished: public Event
+    {
+    public:
+        static inline const std::string name = "DebugSessionFinished";
+
+        std::string getName() const override {
+            return DebugSessionFinished::name;
+        }
+    };
+}

src/EventManager/Events/DebugSessionStarted.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class DebugSessionStarted: public Event
+    {
+    public:
+        static inline const std::string name = "DebugSessionStarted";
+
+        std::string getName() const override {
+            return DebugSessionStarted::name;
+        }
+    };
+}

src/EventManager/Events/Event.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <atomic>
+#include <optional>
+
+#include "src/Helpers/DateTime.hpp"
+
+namespace Bloom::Events
+{
+    static_assert(std::atomic<int>::is_always_lock_free);
+
+    class Event
+    {
+    private:
+        QDateTime createdTimestamp = DateTime::currentDateTime();
+        static inline std::atomic<int> lastEventId = 0;
+
+    public:
+        int id = ++(this->lastEventId);
+        std::optional<int> correlationId;
+
+        static inline const std::string name = "GenericEvent";
+
+        virtual std::string getName() const {
+            return Event::name;
+        }
+
+        long getCreatedEpochTimestamp() const {
+            return this->createdTimestamp.toMSecsSinceEpoch();
+        }
+    };
+}

src/EventManager/Events/Events.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+
+#include "Event.hpp"
+#include "StopTargetExecution.hpp"
+#include "ResumeTargetExecution.hpp"
+#include "ResetTarget.hpp"
+#include "DebugSessionStarted.hpp"
+#include "DebugSessionFinished.hpp"
+#include "TargetControllerStateChanged.hpp"
+#include "TargetControllerStopped.hpp"
+#include "ShutdownTargetController.hpp"
+#include "TargetControllerErrorOccurred.hpp"
+#include "ShutdownApplication.hpp"
+#include "DebugServerStateChanged.hpp"
+#include "ShutdownDebugServer.hpp"
+#include "RetrieveRegistersFromTarget.hpp"
+#include "RegistersRetrievedFromTarget.hpp"
+#include "WriteRegistersToTarget.hpp"
+#include "RegistersWrittenToTarget.hpp"
+#include "TargetExecutionResumed.hpp"
+#include "TargetExecutionStopped.hpp"
+#include "RetrieveMemoryFromTarget.hpp"
+#include "MemoryRetrievedFromTarget.hpp"
+#include "WriteMemoryToTarget.hpp"
+#include "MemoryWrittenToTarget.hpp"
+#include "SetBreakpointOnTarget.hpp"
+#include "RemoveBreakpointOnTarget.hpp"
+#include "BreakpointSetOnTarget.hpp"
+#include "BreakpointRemovedOnTarget.hpp"
+#include "StepTargetExecution.hpp"
+#include "SetProgramCounterOnTarget.hpp"
+#include "ProgramCounterSetOnTarget.hpp"
+#include "ExtractTargetDescriptor.hpp"
+#include "TargetDescriptorExtracted.hpp"
+#include "InsightStateChanged.hpp"
+#include "RetrieveTargetPinStates.hpp"
+#include "TargetPinStatesRetrieved.hpp"
+#include "SetTargetPinState.hpp"
+#include "TargetIoPortsUpdated.hpp"
+
+namespace Bloom::Events
+{
+    template <class EventType>
+    using EventPointer = std::shared_ptr<const EventType>;
+
+    using GenericEventPointer = EventPointer<Event>;
+}

src/EventManager/Events/ExtractTargetDescriptor.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ExtractTargetDescriptor: public Event
+    {
+    public:
+        static inline const std::string name = "ExtractTargetDescriptor";
+
+        std::string getName() const override {
+            return ExtractTargetDescriptor::name;
+        }
+    };
+}

src/EventManager/Events/InsightStateChanged.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Event.hpp"
+#include "src/Helpers/Thread.hpp"
+
+namespace Bloom::Events
+{
+    class InsightStateChanged: public Event
+    {
+    private:
+        ThreadState state;
+    public:
+        InsightStateChanged(ThreadState state) : state(state) {
+
+        };
+
+        static inline const std::string name = "InsightStateChanged";
+
+        std::string getName() const override {
+            return InsightStateChanged::name;
+        }
+
+        ThreadState getState() const {
+            return this->state;
+        }
+    };
+}

src/EventManager/Events/MemoryRetrievedFromTarget.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <vector>
+
+#include "Event.hpp"
+#include "src/Targets/TargetMemory.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetMemoryBuffer;
+    class MemoryRetrievedFromTarget: public Event
+    {
+    public:
+        static inline const std::string name = "MemoryRetrievedFromTarget";
+        TargetMemoryBuffer data;
+
+        std::string getName() const override {
+            return MemoryRetrievedFromTarget::name;
+        }
+    };
+}

src/EventManager/Events/MemoryWrittenToTarget.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Event.hpp"
+#include "src/Targets/TargetMemory.hpp"
+
+namespace Bloom::Events
+{
+    using Bloom::Targets::TargetMemoryBuffer;
+
+    class MemoryWrittenToTarget: public Event
+    {
+    public:
+        static inline const std::string name = "MemoryWrittenToTarget";
+
+        std::string getName() const override {
+            return MemoryWrittenToTarget::name;
+        }
+
+        MemoryWrittenToTarget() = default;
+    };
+}

src/EventManager/Events/ProgramCounterSetOnTarget.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ProgramCounterSetOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "ProgramCounterSetOnTarget";
+
+        std::string getName() const override {
+            return ProgramCounterSetOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/RegistersRetrievedFromTarget.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <vector>
+
+#include "Event.hpp"
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetRegisters;
+
+    class RegistersRetrievedFromTarget: public Event
+    {
+    public:
+        static inline const std::string name = "RegistersRetrievedFromTarget";
+        TargetRegisters registers;
+
+        std::string getName() const override {
+            return RegistersRetrievedFromTarget::name;
+        }
+    };
+}

src/EventManager/Events/RegistersWrittenToTarget.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <set>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class RegistersWrittenToTarget: public Event
+    {
+    public:
+        static inline const std::string name = "RegistersWrittenToTarget";
+
+        std::string getName() const override {
+            return RegistersWrittenToTarget::name;
+        }
+    };
+}

src/EventManager/Events/RemoveBreakpointOnTarget.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetBreakpoint.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetBreakpoint;
+
+    class RemoveBreakpointOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "RemoveBreakpointOnTarget";
+        std::uint32_t address;
+        TargetBreakpoint breakpoint;
+
+        std::string getName() const override {
+            return RemoveBreakpointOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/ResetTarget.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ResetTarget: public Event
+    {
+    public:
+        static inline const std::string name = "ResetTargetEvent";
+
+        std::string getName() const override {
+            return ResetTarget::name;
+        }
+    };
+}

src/EventManager/Events/ResumeTargetExecution.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ResumeTargetExecution: public Event
+    {
+    public:
+        static inline const std::string name = "ResumeTargetExecutionEvent";
+        std::optional<std::uint32_t> fromProgramCounter;
+
+        std::string getName() const override {
+            return ResumeTargetExecution::name;
+        }
+
+        ResumeTargetExecution() = default;
+        ResumeTargetExecution(std::uint32_t fromProgramCounter) : fromProgramCounter(fromProgramCounter) {};
+    };
+}

src/EventManager/Events/RetrieveMemoryFromTarget.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetMemory.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetMemoryType;
+
+    class RetrieveMemoryFromTarget: public Event
+    {
+    public:
+        static inline const std::string name = "RetrieveMemoryFromTarget";
+        TargetMemoryType memoryType = TargetMemoryType::RAM;
+        std::uint32_t startAddress;
+        std::uint32_t bytes;
+
+        std::string getName() const override {
+            return RetrieveMemoryFromTarget::name;
+        }
+    };
+}

src/EventManager/Events/RetrieveRegistersFromTarget.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <set>
+
+#include "Event.hpp"
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::Events
+{
+    using Bloom::Targets::TargetRegisterDescriptors;
+
+    class RetrieveRegistersFromTarget: public Event
+    {
+    public:
+        static inline const std::string name = "RetrieveRegistersFromTarget";
+        TargetRegisterDescriptors descriptors;
+
+        std::string getName() const override {
+            return RetrieveRegistersFromTarget::name;
+        }
+    };
+}

src/EventManager/Events/RetrieveTargetPinStates.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class RetrieveTargetPinStates: public Event
+    {
+    public:
+        static inline const std::string name = "RetrieveTargetPinStates";
+        int variantId;
+
+        std::string getName() const override {
+            return RetrieveTargetPinStates::name;
+        }
+    };
+}

src/EventManager/Events/SetBreakpointOnTarget.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetBreakpoint.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetBreakpoint;
+
+    class SetBreakpointOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "SetBreakpointOnTarget";
+        std::uint32_t address;
+        TargetBreakpoint breakpoint;
+
+        std::string getName() const override {
+            return SetBreakpointOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/SetProgramCounterOnTarget.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class SetProgramCounterOnTarget: public Event
+    {
+    public:
+        static inline const std::string name = "SetProgramCounterOnTarget";
+        std::uint32_t address;
+
+        std::string getName() const override {
+            return SetProgramCounterOnTarget::name;
+        }
+    };
+}

src/EventManager/Events/SetTargetPinState.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetPinDescriptor.hpp"
+
+namespace Bloom::Events
+{
+    class SetTargetPinState: public Event
+    {
+    public:
+        static inline const std::string name = "SetTargetPinState";
+        int variantId;
+        Targets::TargetPinDescriptor pinDescriptor;
+        Targets::TargetPinState pinState;
+
+        std::string getName() const override {
+            return SetTargetPinState::name;
+        }
+    };
+}

src/EventManager/Events/ShutdownApplication.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ShutdownApplication: public Event
+    {
+    public:
+        static inline const std::string name = "ShutdownApplicationEvent";
+
+        std::string getName() const override {
+            return ShutdownApplication::name;
+        }
+    };
+}

src/EventManager/Events/ShutdownDebugServer.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ShutdownDebugServer: public Event
+    {
+    public:
+        static inline const std::string name = "ShutdownDebugServer";
+
+        std::string getName() const override {
+            return ShutdownDebugServer::name;
+        }
+    };
+}

src/EventManager/Events/ShutdownTargetController.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class ShutdownTargetController: public Event
+    {
+    public:
+        static inline const std::string name = "ShutdownTargetControllerEvent";
+
+        std::string getName() const override {
+            return ShutdownTargetController::name;
+        }
+    };
+}

src/EventManager/Events/StepTargetExecution.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class StepTargetExecution: public Event
+    {
+    public:
+        static inline const std::string name = "StepTargetExecution";
+        std::optional<std::uint32_t> fromProgramCounter;
+
+        std::string getName() const override {
+            return StepTargetExecution::name;
+        }
+
+        StepTargetExecution() = default;
+        StepTargetExecution(std::uint32_t fromProgramCounter) : fromProgramCounter(fromProgramCounter) {};
+    };
+}

src/EventManager/Events/StopTargetExecution.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class StopTargetExecution: public Event
+    {
+    public:
+        static inline const std::string name = "StopTargetEvent";
+
+        std::string getName() const override {
+            return StopTargetExecution::name;
+        }
+    };
+}

src/EventManager/Events/TargetControllerErrorOccurred.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class TargetControllerErrorOccurred: public Event
+    {
+    public:
+        static inline const std::string name = "TargetControllerErrorOccurred";
+
+        TargetControllerErrorOccurred() = default;
+
+        std::string getName() const override {
+            return TargetControllerErrorOccurred::name;
+        }
+    };
+}

src/EventManager/Events/TargetControllerStateChanged.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Event.hpp"
+#include "src/Helpers/Thread.hpp"
+
+namespace Bloom::Events
+{
+
+    class TargetControllerStateChanged: public Event
+    {
+    private:
+        ThreadState state;
+    public:
+        TargetControllerStateChanged(ThreadState state) : state(state) {
+
+        };
+
+        static inline const std::string name = "TargetControllerStateChanged";
+
+        std::string getName() const override {
+            return TargetControllerStateChanged::name;
+        }
+
+        ThreadState getState() const {
+            return this->state;
+        }
+    };
+}

src/EventManager/Events/TargetControllerStopped.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <src/Exceptions/Exception.hpp>
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class TargetControllerStopped: public Event
+    {
+    private:
+        bool stoppedAbruptly = false;
+        std::optional<Exceptions::Exception> caughtException;
+
+    public:
+        static inline const std::string name = "TargetControllerStoppedEvent";
+
+        std::string getName() const override {
+            return TargetControllerStopped::name;
+        }
+    };
+}

src/EventManager/Events/TargetDescriptorExtracted.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetDescriptor.hpp"
+
+namespace Bloom::Events
+{
+    class TargetDescriptorExtracted: public Event
+    {
+    public:
+        static inline const std::string name = "TargetDescriptorExtracted";
+        Targets::TargetDescriptor targetDescriptor;
+
+        std::string getName() const override {
+            return TargetDescriptorExtracted::name;
+        }
+    };
+}

src/EventManager/Events/TargetExecutionResumed.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class TargetExecutionResumed: public Event
+    {
+    public:
+        static inline const std::string name = "TargetExecutionResumed";
+
+        TargetExecutionResumed() = default;
+
+        std::string getName() const override {
+            return TargetExecutionResumed::name;
+        }
+    };
+}

src/EventManager/Events/TargetExecutionStopped.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/Target.hpp"
+
+namespace Bloom::Events
+{
+    using Targets::TargetBreakCause;
+
+    class TargetExecutionStopped: public Event
+    {
+    public:
+        static inline const std::string name = "TargetExecutionStopped";
+        std::uint32_t programCounter;
+        TargetBreakCause breakCause;
+
+        TargetExecutionStopped(std::uint32_t programCounter, TargetBreakCause breakCause) :
+        programCounter(programCounter), breakCause(breakCause) {}
+
+        std::string getName() const override {
+            return TargetExecutionStopped::name;
+        }
+    };
+}

src/EventManager/Events/TargetIoPortsUpdated.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class TargetIoPortsUpdated: public Event
+    {
+    public:
+        static inline const std::string name = "TargetIoPortsUpdated";
+
+        std::string getName() const override {
+            return TargetIoPortsUpdated::name;
+        }
+    };
+}

src/EventManager/Events/TargetPinStatesRetrieved.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+#include <map>
+
+#include "Event.hpp"
+#include "src/Targets/TargetPinDescriptor.hpp"
+
+namespace Bloom::Events
+{
+    class TargetPinStatesRetrieved: public Event
+    {
+    public:
+        static inline const std::string name = "TargetPinStatesRetrieved";
+        int variantId;
+        std::map<int, Targets::TargetPinState> pinSatesByNumber;
+
+        std::string getName() const override {
+            return TargetPinStatesRetrieved::name;
+        }
+    };
+}

src/EventManager/Events/WriteMemoryToTarget.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstdint>
+
+#include "Event.hpp"
+#include "src/Targets/TargetMemory.hpp"
+
+namespace Bloom::Events
+{
+    using Bloom::Targets::TargetMemoryBuffer;
+
+    class WriteMemoryToTarget: public Event
+    {
+    public:
+        static inline const std::string name = "WriteMemoryToTarget";
+        TargetMemoryType memoryType;
+        std::uint32_t startAddress;
+        TargetMemoryBuffer buffer;
+
+        std::string getName() const override {
+            return WriteMemoryToTarget::name;
+        }
+
+        WriteMemoryToTarget() = default;
+        WriteMemoryToTarget(TargetMemoryType memoryType, std::uint32_t startAddress, const TargetMemoryBuffer& buffer)
+        : memoryType(memoryType), startAddress(startAddress), buffer(buffer) {};
+    };
+}

src/EventManager/Events/WriteRegistersToTarget.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <set>
+
+#include "Event.hpp"
+#include "src/Targets/TargetRegister.hpp"
+
+namespace Bloom::Events
+{
+    using Bloom::Targets::TargetRegister;
+
+    class WriteRegistersToTarget: public Event
+    {
+    public:
+        static inline const std::string name = "WriteRegistersToTarget";
+        TargetRegisters registers;
+
+        std::string getName() const override {
+            return WriteRegistersToTarget::name;
+        }
+
+        WriteRegistersToTarget() = default;
+        WriteRegistersToTarget(const TargetRegisters& registers) : registers(registers) {};
+    };
+}