Initial Commit

Author: LK-Simon

CMakeLists.txt

@@ -8,4 +8,4 @@ set(COMPONENT_ADD_INCLUDEDIRS
 
 register_component()
 
-target_compile_options(${COMPONENT_TARGET} PRIVATE -fno-rtti)
+target_compile_options(${COMPONENT_TARGET} PRIVATE -frtti)

src/ESPressio_Event.hpp

@@ -1 +1,70 @@
-#pragma once
+#pragma once
+
+#include <cstdint>
+
+#include <ESPressio_ThreadSafe.hpp>
+
+#include "ESPressio_IEvent.hpp"
+#include "ESPressio_EventEnums.hpp"
+#include "ESPressio_EventManager.hpp"
+
+using namespace ESPressio::Base;
+using namespace ESPressio::Threads;
+
+namespace ESPressio {
+
+    namespace Event {
+
+        class Event : public IEvent {
+            private:
+                ReadWriteMutex<unsigned long> _dispatchTime = ReadWriteMutex<unsigned long>(0);
+                Mutex<uint32_t> _refCount = Mutex<uint32_t>(0);
+                bool _wasDispatched = false;
+            public:
+                virtual ~Event() { }
+
+                inline void __ref() override {
+                    _refCount.WithWriteLock([](uint32_t& refCount) {
+                        refCount++;
+                    });
+                }
+
+                inline void __unref() override {
+                    uint32_t cnt = 99;
+                    _refCount.WithWriteLock([&cnt](uint32_t& refCount) {
+                        refCount--;
+                        cnt = refCount;
+                    });
+                    if (cnt == 0) { delete this; }
+                }
+
+                inline void __dispatch() override {
+                    if (_wasDispatched) { return; }
+                    _wasDispatched = true;
+                    _dispatchTime.WithWriteLock([](unsigned long& dispatchTime) {
+                        if (dispatchTime == 0) {
+                            dispatchTime = millis();
+                        }
+                    });
+                }
+
+                void Queue(EventPriority priority = EventPriority::Normal) override {
+                    EventManager::GetInstance()->QueueEvent(this, priority);
+                }
+
+                void Stack(EventPriority priority = EventPriority::Normal) override {
+                    EventManager::GetInstance()->StackEvent(this, priority);
+                }
+
+                inline unsigned long GetDispatchTime() override {
+                    return _dispatchTime.Get();
+                }
+
+                inline unsigned long GetTimeSinceDispatch() override {
+                    return millis() - _dispatchTime.Get();
+                }
+        };
+
+    }
+
+}

src/ESPressio_EventDispatcher.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <vector>
+#include <unordered_map>
+#include <mutex>
+
+#include "ESPressio_IEvent.hpp"
+#include "ESPressio_EventReceiver.hpp"
+
+namespace ESPressio {
+
+    namespace Event {
+
+        /*
+            `IEventDispatcher` is an interface that defines the methods that an event dispatcher should implement.
+            Event Dispatchers act as both an `IEventReceiver`, and an Event-Typed Collection of other `IEventReceiver` objects.
+            Their job is to facilitate the transit of Events from one `IEventReceiver` to another.
+            This is essential for the Event Engine to function.
+        */
+        class IEventDispatcher {
+            public:
+                virtual ~IEventDispatcher() { }
+                /// Registers an `IEventReceiver` to receive Events of a specific type from this `IEventDispatcher`.
+                virtual void RegisterReceiver(std::type_index type, IEventReceiver* receiver) = 0;
+                /// Unregisters an `IEventReceiver` from receiving Events of a specific type from this `IEventDispatcher`.
+                virtual void UnregisterReceiver(std::type_index type, IEventReceiver* receiver) = 0;
+        };
+
+        /// `EventDispatcher` is a concrete implementation of the `IEventDispatcher` interface.
+        class EventDispatcher : public EventReceiver, public IEventDispatcher {
+            private:
+                typedef std::vector<IEventReceiver*> EventReceiverBucket;
+                typedef std::unordered_map<std::type_index, EventReceiverBucket*> EventReceiverTypeMap;
+
+                EventReceiverTypeMap _eventReceivers;
+                std::mutex _eventReceiversMutex; // It's necessary because we're using a shared resource (the `_eventReceivers` map) across multiple threads.
+
+                /// BEWARE: This method doesn't lock the `_eventReceiversMutex`! It's the caller's responsibility to lock it!
+                EventReceiverBucket* GetEventTypeBucket(std::type_index type) {
+                    if (_eventReceivers.find(type) == _eventReceivers.end()) {
+                        _eventReceivers[type] = new EventReceiverBucket();
+                    }
+                    return _eventReceivers[type];
+                }
+            protected:
+                void ClearEventReceivers() {
+                    _eventReceiversMutex.lock();
+                    for (auto it = _eventReceivers.begin(); it != _eventReceivers.end(); it++) {
+                        delete it->second;
+                    }
+                    _eventReceivers.clear();
+                    _eventReceiversMutex.unlock();
+                }
+
+                void DispatchEvents() {
+                    _eventReceiversMutex.lock();
+
+                    WithEvents([&](IEvent* event, EventDispatchMethod dispatchMethod, EventPriority priority) {
+                        std::type_index type = typeid(*event);
+                        EventReceiverBucket* bucket = GetEventTypeBucket(type);
+                        bool wasHandled = false;
+                        for (IEventReceiver* receiver : *bucket) {
+                            if (dispatchMethod == EventDispatchMethod::Queue) {
+                                receiver->QueueEvent(event, priority);
+                            } else {
+                                receiver->StackEvent(event, priority);
+                            }
+                            event->__unref();
+                            wasHandled = true;
+                        }
+                        if (!wasHandled) { event->__unref(); }
+                    });
+
+                    _eventReceiversMutex.unlock();
+                }
+            public:
+                EventDispatcher() { }
+
+                virtual ~EventDispatcher() override {
+                    ClearEventReceivers();
+                }
+
+                void RegisterReceiver(std::type_index type, IEventReceiver* receiver) override {
+                    _eventReceiversMutex.lock();
+                    EventReceiverBucket* bucket = GetEventTypeBucket(type);
+                    for (IEventReceiver* r : *bucket) {
+                        if (r == receiver) {
+                            _eventReceiversMutex.unlock();
+                            return;
+                        }
+                    }
+                    bucket->push_back(receiver);
+                    _eventReceiversMutex.unlock();
+                }
+
+                void UnregisterReceiver(std::type_index type, IEventReceiver* receiver) override {
+                    _eventReceiversMutex.lock();
+                    EventReceiverBucket* bucket = GetEventTypeBucket(type);
+                    for (auto it = bucket->begin(); it != bucket->end(); it++) {
+                        if (*it == receiver) {
+                            bucket->erase(it);
+                            _eventReceiversMutex.unlock();
+                            return;
+                        }
+                    }
+                    _eventReceiversMutex.unlock();
+                }
+        };
+
+    }
+
+}

src/ESPressio_EventEnums.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <functional>
+
+
+namespace ESPressio {
+
+    namespace Event {
+
+        enum EventPriority {
+            Low = 0,
+            Normal = 1,
+            High = 2
+        };
+
+        // ++ operator for EventPriority to move to the next value (and roll over to the beginning if at the end)
+        inline EventPriority& operator++(EventPriority& priority) {
+            priority = static_cast<EventPriority>((static_cast<int>(priority) + 1) % 3);
+            return priority;
+        }
+
+        // -- operator for EventPriority to move to the previous value (and roll over to the end if at the beginning)
+        inline EventPriority& operator--(EventPriority& priority) {
+            priority = static_cast<EventPriority>((static_cast<int>(priority) + 2) % 3);
+            return priority;
+        }
+
+        enum EventListenerInterest {
+            All,
+            YoungerThan,
+            Custom
+        };
+
+        // ++ operator for EventListenerInterest to move to the next value (and roll over to the beginning if at the end)
+        inline EventListenerInterest& operator++(EventListenerInterest& interest) {
+            interest = static_cast<EventListenerInterest>((static_cast<int>(interest) + 1) % 4);
+            return interest;
+        }
+
+        // -- operator for EventListenerInterest to move to the previous value (and roll over to the end if at the beginning)
+        inline EventListenerInterest& operator--(EventListenerInterest& interest) {
+            interest = static_cast<EventListenerInterest>((static_cast<int>(interest) + 3) % 4);
+            return interest;
+        }
+
+        enum EventDispatchMethod {
+            Stack,
+            Queue
+        };
+
+        // ++ operator for EventDispatchMethod to move to the next value (and roll over to the beginning if at the end)
+        inline EventDispatchMethod& operator++(EventDispatchMethod& method) {
+            method = static_cast<EventDispatchMethod>((static_cast<int>(method) + 1) % 2);
+            return method;
+        }
+
+        // -- operator for EventDispatchMethod to move to the previous value (and roll over to the end if at the beginning)
+        inline EventDispatchMethod& operator--(EventDispatchMethod& method) {
+            method = static_cast<EventDispatchMethod>((static_cast<int>(method) + 1) % 2);
+            return method;
+        }
+
+    }
+
+}
+
+using namespace ESPressio::Event;
+
+// Hash specialization for EventPriority enum
+// This enables `EventPriority` to be used as a Key in any set or map type.
+namespace std {
+    template <>
+    struct hash<EventPriority> {
+        std::size_t operator()(const EventPriority& priority) const {
+            return std::hash<int>()(static_cast<int>(priority));
+        }
+    };
+}

src/ESPressio_EventHandler.hpp

@@ -0,0 +1,29 @@
+#include "ESPressio_EventListener.hpp"
+
+#include <functional>
+
+namespace ESPressio {
+
+    namespace Event {
+
+        template <typename EventType>
+        IEventListenerHandler* IEventListener::RegisterListener(
+            std::function<void(
+                IEvent*,
+                EventDispatchMethod dispatchMethod,
+                EventPriority priority)> callback,
+                EventListenerInterest interest,
+                unsigned long maximumTimeSinceDispatch,
+                std::function<bool(IEvent*)> customInterestCallback
+        ) {
+            return RegisterListener(typeid(EventType), callback, interest, maximumTimeSinceDispatch, customInterestCallback);
+        }
+
+        template <typename EventType>
+        void IEventListener::UnregisterListener(IEventListenerHandler* handler) {
+            UnregisterListener(typeid(EventType), handler);
+        }
+
+    }
+
+}