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

Removed all using declarations and directives from header files

Browse Source
This commit is contained in:
Nav
2021-05-24 20:58:49 +01:00
parent d39ca609bc
commit ce480a996c
96 changed files with 415 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/EventManager/EventListener.cpp
View File

@@ -1,7 +1,7 @@
#include <sys/eventfd.h>
#include "EventListener.hpp"
using namespace Bloom;
using namespace Bloom::Events;
std::set<std::string> EventListener::getRegisteredEventTypeNames() {
return this->registeredEventTypes.getValue();

56
src/EventManager/EventListener.hpp
View File

@@ -19,8 +19,6 @@
namespace Bloom
{
using namespace Events;
/**
* The EventListener allows specific threads the ability to handle any events, from other threads, that
* are of interest.
@@ -65,7 +63,7 @@ namespace Bloom
* Events are grouped by event type name, and removed from their queue just *before* the dispatching to
* registered handlers begins.
*/
SyncSafe<std::map<std::string, std::queue<GenericEventPointer>>> eventQueueByEventType;
SyncSafe<std::map<std::string, std::queue<Events::GenericEventPointer>>> eventQueueByEventType;
std::condition_variable eventQueueByEventTypeCV;
/**
@@ -75,12 +73,12 @@ namespace Bloom
* Each callback will be passed an std::shared_ptr<const EventType> of the event (we downcast the events in
* EventListener::waiteAndDispatch() before dispatching them).
*/
SyncSafe<std::map<std::string, std::vector<std::function<void(GenericEventPointer)>>>> eventTypeToCallbacksMapping;
SyncSafe<std::map<std::string, std::vector<std::function<void(Events::GenericEventPointer)>>>> eventTypeToCallbacksMapping;
SyncSafe<std::set<std::string>> registeredEventTypes;
std::shared_ptr<EventNotifier> interruptEventNotifier = nullptr;
std::vector<GenericEventPointer> getEvents();
std::vector<Events::GenericEventPointer> getEvents();
public:
explicit EventListener(const std::string& name): name(name) {};
@@ -105,7 +103,7 @@ namespace Bloom
*
* @param event
*/
void registerEvent(GenericEventPointer event);
void registerEvent(Events::GenericEventPointer event);
void setInterruptEventNotifier(std::shared_ptr<EventNotifier> interruptEventNotifier) {
this->interruptEventNotifier = interruptEventNotifier;
@@ -121,8 +119,8 @@ namespace Bloom
template<class EventType>
void registerCallbackForEventType(std::function<void(std::shared_ptr<const EventType>)> callback) {
// We encapsulate the callback in a lambda to handle the downcasting.
std::function<void(GenericEventPointer)> parentCallback =
[callback] (GenericEventPointer event) {
std::function<void(Events::GenericEventPointer)> parentCallback =
[callback] (Events::GenericEventPointer event) {
// Downcast the event to the expected type
callback(std::dynamic_pointer_cast<const EventType>(event));
}
@@ -139,9 +137,9 @@ namespace Bloom
* the type name to callback vector mapping.
*/
mapping.insert(
std::pair<std::string, std::vector<std::function<void(GenericEventPointer)>>>(
std::pair<std::string, std::vector<std::function<void(Events::GenericEventPointer)>>>(
EventType::name,
std::vector<std::function<void(GenericEventPointer)>>()
std::vector<std::function<void(Events::GenericEventPointer)>>()
)
);
}
@@ -177,20 +175,20 @@ namespace Bloom
std::optional<int> correlationId = std::nullopt
) {
// Different return types, depending on how many event type arguments are passed in.
using MonoType = std::optional<EventPointer<EventTypeA>>;
using MonoType = std::optional<Events::EventPointer<EventTypeA>>;
using BiVariantType = std::optional<
std::variant<
std::monostate,
EventPointer<EventTypeA>,
EventPointer<EventTypeB>
Events::EventPointer<EventTypeA>,
Events::EventPointer<EventTypeB>
>
>;
using TriVariantType = std::optional<
std::variant<
std::monostate,
EventPointer<EventTypeA>,
EventPointer<EventTypeB>,
EventPointer<EventTypeC>
Events::EventPointer<EventTypeA>,
Events::EventPointer<EventTypeB>,
Events::EventPointer<EventTypeC>
>
>;
using ReturnType = typename std::conditional<
@@ -211,12 +209,18 @@ namespace Bloom
auto eventTypeNamesToDeRegister = std::set<std::string>();
if constexpr (!std::is_same_v<EventTypeA, EventTypeB>) {
static_assert(std::is_base_of_v<Event, EventTypeB>, "All event types must be derived from the Event base class.");
static_assert(
std::is_base_of_v<Events::Event, EventTypeB>,
"All event types must be derived from the Event base class."
);
eventTypeNames.insert(EventTypeB::name);
}
if constexpr (!std::is_same_v<EventTypeB, EventTypeC>) {
static_assert(std::is_base_of_v<Event, EventTypeC>, "All event types must be derived from the Event base class.");
static_assert(
std::is_base_of_v<Events::Event, EventTypeC>,
"All event types must be derived from the Event base class."
);
eventTypeNames.insert(EventTypeC::name);
}
@@ -232,7 +236,7 @@ namespace Bloom
}
}
GenericEventPointer foundEvent = nullptr;
Events::GenericEventPointer foundEvent = nullptr;
auto eventsFound = [&eventTypeNames, &eventQueueByType, &correlationId, &foundEvent]() -> bool {
for (const auto& eventTypeName : eventTypeNames) {
if (eventQueueByType.find(eventTypeName) != eventQueueByType.end()
@@ -279,17 +283,23 @@ namespace Bloom
// If we're looking for multiple event types, use an std::variant.
if constexpr (!std::is_same_v<EventTypeA, EventTypeB> || !std::is_same_v<EventTypeB, EventTypeC>) {
if (foundEvent->getName() == EventTypeA::name) {
output = std::optional<typename decltype(output)::value_type>(std::dynamic_pointer_cast<const EventTypeA>(foundEvent));
output = std::optional<typename decltype(output)::value_type>(
std::dynamic_pointer_cast<const EventTypeA>(foundEvent)
);
} else if constexpr (!std::is_same_v<EventTypeA, EventTypeB>) {
if (foundEvent->getName() == EventTypeB::name) {
output = std::optional<typename decltype(output)::value_type>(std::dynamic_pointer_cast<const EventTypeB>(foundEvent));
output = std::optional<typename decltype(output)::value_type>(
std::dynamic_pointer_cast<const EventTypeB>(foundEvent)
);
}
}
if constexpr (!std::is_same_v<EventTypeB, EventTypeC>) {
if (foundEvent->getName() == EventTypeC::name) {
output = std::optional<typename decltype(output)::value_type>(std::dynamic_pointer_cast<const EventTypeC>(foundEvent));
output = std::optional<typename decltype(output)::value_type>(
std::dynamic_pointer_cast<const EventTypeC>(foundEvent)
);
}
}
@@ -311,7 +321,7 @@ namespace Bloom
*/
void waitAndDispatch(int msTimeout = 0);
void dispatchEvent(GenericEventPointer event);
void dispatchEvent(Events::GenericEventPointer event);
void dispatchCurrentEvents();

2
src/EventManager/EventManager.hpp
View File

@@ -53,7 +53,7 @@ namespace Bloom
*
* @param event
*/
void triggerEvent(GenericEventPointer event);
void triggerEvent(Events::GenericEventPointer event);
};
}

3
src/EventManager/Events/MemoryRetrievedFromTarget.hpp
View File

@@ -7,12 +7,11 @@
namespace Bloom::Events
{
using Targets::TargetMemoryBuffer;
class MemoryRetrievedFromTarget: public Event
{
public:
static inline const std::string name = "MemoryRetrievedFromTarget";
TargetMemoryBuffer data;
Targets::TargetMemoryBuffer data;
std::string getName() const override {
return MemoryRetrievedFromTarget::name;

2
src/EventManager/Events/MemoryWrittenToTarget.hpp
View File

@@ -5,8 +5,6 @@
namespace Bloom::Events
{
using Bloom::Targets::TargetMemoryBuffer;
class MemoryWrittenToTarget: public Event
{
public:

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

@@ -7,13 +7,11 @@
namespace Bloom::Events
{
using Targets::TargetRegisters;
class RegistersRetrievedFromTarget: public Event
{
public:
static inline const std::string name = "RegistersRetrievedFromTarget";
TargetRegisters registers;
Targets::TargetRegisters registers;
std::string getName() const override {
return RegistersRetrievedFromTarget::name;

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

@@ -7,14 +7,12 @@
namespace Bloom::Events
{
using Targets::TargetBreakpoint;
class RemoveBreakpointOnTarget: public Event
{
public:
static inline const std::string name = "RemoveBreakpointOnTarget";
std::uint32_t address;
TargetBreakpoint breakpoint;
Targets::TargetBreakpoint breakpoint;
std::string getName() const override {
return RemoveBreakpointOnTarget::name;

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

@@ -7,13 +7,11 @@
namespace Bloom::Events
{
using Targets::TargetMemoryType;
class RetrieveMemoryFromTarget: public Event
{
public:
static inline const std::string name = "RetrieveMemoryFromTarget";
TargetMemoryType memoryType = TargetMemoryType::RAM;
Targets::TargetMemoryType memoryType = Targets::TargetMemoryType::RAM;
std::uint32_t startAddress;
std::uint32_t bytes;

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

@@ -7,13 +7,11 @@
namespace Bloom::Events
{
using Bloom::Targets::TargetRegisterDescriptors;
class RetrieveRegistersFromTarget: public Event
{
public:
static inline const std::string name = "RetrieveRegistersFromTarget";
TargetRegisterDescriptors descriptors;
Targets::TargetRegisterDescriptors descriptors;
std::string getName() const override {
return RetrieveRegistersFromTarget::name;

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

@@ -7,14 +7,12 @@
namespace Bloom::Events
{
using Targets::TargetBreakpoint;
class SetBreakpointOnTarget: public Event
{
public:
static inline const std::string name = "SetBreakpointOnTarget";
std::uint32_t address;
TargetBreakpoint breakpoint;
Targets::TargetBreakpoint breakpoint;
std::string getName() const override {
return SetBreakpointOnTarget::name;

6
src/EventManager/Events/TargetExecutionStopped.hpp
View File

@@ -7,16 +7,14 @@
namespace Bloom::Events
{
using Targets::TargetBreakCause;
class TargetExecutionStopped: public Event
{
public:
static inline const std::string name = "TargetExecutionStopped";
std::uint32_t programCounter;
TargetBreakCause breakCause;
Targets::TargetBreakCause breakCause;
TargetExecutionStopped(std::uint32_t programCounter, TargetBreakCause breakCause) :
TargetExecutionStopped(std::uint32_t programCounter, Targets::TargetBreakCause breakCause) :
programCounter(programCounter), breakCause(breakCause) {}
std::string getName() const override {

13
src/EventManager/Events/WriteMemoryToTarget.hpp
View File

@@ -7,22 +7,23 @@
namespace Bloom::Events
{
using Bloom::Targets::TargetMemoryBuffer;
class WriteMemoryToTarget: public Event
{
public:
static inline const std::string name = "WriteMemoryToTarget";
TargetMemoryType memoryType;
Targets::TargetMemoryType memoryType;
std::uint32_t startAddress;
TargetMemoryBuffer buffer;
Targets::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) {};
WriteMemoryToTarget(
Targets::TargetMemoryType memoryType,
std::uint32_t startAddress,
const Targets::TargetMemoryBuffer& buffer
): memoryType(memoryType), startAddress(startAddress), buffer(buffer) {};
};
}

6
src/EventManager/Events/WriteRegistersToTarget.hpp
View File

@@ -7,19 +7,17 @@
namespace Bloom::Events
{
using Bloom::Targets::TargetRegister;
class WriteRegistersToTarget: public Event
{
public:
static inline const std::string name = "WriteRegistersToTarget";
TargetRegisters registers;
Targets::TargetRegisters registers;
std::string getName() const override {
return WriteRegistersToTarget::name;
}
WriteRegistersToTarget() = default;
WriteRegistersToTarget(const TargetRegisters& registers): registers(registers) {};
WriteRegistersToTarget(const Targets::TargetRegisters& registers): registers(registers) {};
};
}