Event.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
#pragma once
 
#include "CeresEngine/Foundation/Coroutine.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Tuple.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
#include "CeresEngine/Foundation/Threading/Threading.hpp"
 
#include <algorithm>
#include <cassert>
#include <functional>
#include <iterator>
#include <mutex>
#include <thread>
#include <type_traits>
#include <utility>
 
namespace CeresEngine {
 
    template<typename P, typename T, template<typename> typename F> class TEvent;
 
    struct EventDisconnector {
        virtual void operator()(std::size_t index) const = 0;
        virtual ~EventDisconnector() noexcept = default;
    };
 
    class WeakEventConnection final {
    public:
        WeakEventConnection() noexcept : index() {}
 
        // Connection are not copy constructible or copy assignable
        WeakEventConnection(WeakEventConnection const&) = delete;
 
        WeakEventConnection& operator=(WeakEventConnection const&) = delete;
 
        WeakEventConnection(WeakEventConnection&& other) noexcept : weakDisconnector(std::move(other.weakDisconnector)), index(other.index) {}
 
        WeakEventConnection& operator=(WeakEventConnection&& other) noexcept {
            weakDisconnector = std::move(other.weakDisconnector);
            index = other.index;
            return *this;
        }
 
        [[nodiscard]] bool connected() const noexcept { return !weakDisconnector.expired(); }
 
        void disconnect();
 
    private:
        template<typename P, typename T, template<typename> typename F> friend class TEvent;
 
        WeakEventConnection(SPtr<EventDisconnector> const& sharedDisconnector, const std::size_t index) : weakDisconnector(sharedDisconnector), index(index) {}
 
        WPtr<EventDisconnector> weakDisconnector;
        std::size_t index;
    };
 
    class EventConnection final {
    public:
        EventConnection() noexcept = default;
 
        EventConnection(EventConnection const&) = delete;
 
        EventConnection& operator=(EventConnection const&) = delete;
 
        EventConnection(EventConnection&& other) noexcept : connection(std::move(other.connection)) {}
 
        EventConnection& operator=(EventConnection&& other) noexcept {
            reset(std::move(other.connection));
            return *this;
        }
 
        EventConnection(WeakEventConnection&& c) noexcept // NOLINT
                : connection(std::forward<WeakEventConnection>(c)) {}
 
        ~EventConnection() { disconnect(); }
 
        EventConnection& operator=(WeakEventConnection&& c) {
            reset(std::forward<WeakEventConnection>(c));
            return *this;
        }
 
        void reset(WeakEventConnection&& c = {}) {
            disconnect();
            connection = std::move(c);
        }
 
        [[nodiscard]] WeakEventConnection release() noexcept {
            WeakEventConnection c = std::move(connection);
            connection = WeakEventConnection{};
            return c;
        }
 
        [[nodiscard]] bool connected() const noexcept { return connection.connected(); }
 
        void disconnect() { connection.disconnect(); }
 
    private:
        WeakEventConnection connection;
    };
 
    struct MultithreadPolicy final {
        using MutexType = Mutex;
        using MutexLockType = UniqueLock<MutexType>;
 
        static void yield() noexcept { std::this_thread::yield(); }
    };
 
    struct SinglethreadPolicy final {
        struct MutexType {};
 
        struct MutexLockType {
            explicit constexpr MutexLockType(const MutexType&) noexcept {}
        };
 
        static constexpr void yield() noexcept {}
    };
 
    template<typename S, typename T, typename F, typename... A> class EventAccumulator final {
    public:
        using ResultType = decltype(std::declval<F>()(std::declval<T>(), std::declval<typename S::SlotType::result_type>()));
 
        //
        EventAccumulator(S const& event, T init, F func) : event(event), init(init), func(func) {}
 
        ResultType operator()(A&&... args) const { return event.triggerWithAccumulator(init, func, std::forward<A>(args)...); }
 
    private:
        S const& event;
 
        T init;
 
        F func;
    };
 
    template<typename P, typename R, template<typename> typename F, typename... A> class TEvent<P, R(A...), F> final {
    public:
        TEvent(TEvent const&) = delete;
 
        TEvent& operator=(TEvent const&) = delete;
 
        TEvent() noexcept : slotCount(0) {}
 
        // Destruct the event object.
        ~TEvent() { invalidateDisconnector(); }
 
        using SlotType = F<R(A...)>;
 
        using SizeType = typename Vector<SlotType>::size_type;
 
        template<typename T> [[nodiscard]] WeakEventConnection connect(T&& slot) {
            MutexLockType lock{mutex};
            slots.push_back(std::forward<T>(slot));
            const std::size_t index = slots.size() - 1;
            if(sharedDisconnector == nullptr) {
                disconnector = Disconnector{this};
                sharedDisconnector = SPtr<EventDisconnector>(&disconnector, [](auto) {});
            }
            ++slotCount;
            return WeakEventConnection{sharedDisconnector, index};
        }
 
        template<typename T, typename Func> [[nodiscard]] WeakEventConnection connect(T* target, Func&& ptr) {
            return connect([target, ptr](A&&... args) { return (target->*ptr)(std::forward<A>(args)...); });
        }
 
        void operator()(A const&... args) const {
            for(const SlotType& slot : copySlots()) {
                if(slot) {
                    slot(args...);
                }
            }
        }
 
        template<typename T, typename O> [[nodiscard]] EventAccumulator<TEvent, T, O, A...> accumulate(T init, O op) const {
            static_assert(!std::is_same<R, void>::value,
                "Unable to accumulate slot return values "
                "with 'void' as return type.");
            return {*this, init, op};
        }
 
        template<typename C> [[nodiscard]] C aggregate(A const&... args) const {
            static_assert(!std::is_same<R, void>::value,
                "Unable to aggregate slot return values "
                "with 'void' as return type.");
            C container;
            auto iterator = std::back_inserter(container);
            for(const SlotType& slot : copySlots()) {
                if(slot) {
                    (*iterator) = slot(args...);
                }
            }
            return container;
        }
 
        [[nodiscard]] SizeType getSlotCount() const noexcept { return slotCount; }
 
        [[nodiscard]] bool empty() const noexcept { return getSlotCount() == 0; }
 
        void disconnectAllSlots() {
            MutexLockType lock{mutex};
            slots.clear();
            slotCount = 0;
            invalidateDisconnector();
        }
 
    private:
        template<typename, typename, typename, typename...> friend class EventAccumulator;
        using ThreadPolicy = P;
 
        using MutexType = typename ThreadPolicy::MutexType;
 
        using MutexLockType = typename ThreadPolicy::MutexLockType;
 
        void invalidateDisconnector() noexcept {
            // If we are unlucky, some of the connected slots
            // might be in the process of disconnecting from other threads.
            // If this happens, we are risking to destruct the disconnector
            // object managed by our shared pointer before they are done
            // disconnecting. This would be bad. To solve this problem, we
            // discard the shared pointer (that is pointing to the disconnector
            // object within our own instance), but keep a weak pointer to that
            // instance. We then stall the destruction until all other weak
            // pointers have released their "lock" (indicated by the fact that
            // we will get a nullptr when locking our weak pointer).
            const WPtr<EventDisconnector> weak{sharedDisconnector};
            sharedDisconnector.reset();
            while(weak.lock() != nullptr) {
                // we just yield here, allowing the OS to reschedule. We do
                // this until all threads has released the disconnector object.
                ThreadPolicy::yield();
            }
        }
 
        [[nodiscard]] Vector<SlotType> copySlots() const {
            MutexLockType lock{mutex};
            return slots;
        }
 
        template<typename T, typename O>
        [[nodiscard]] typename EventAccumulator<TEvent, T, O, A...>::ResultType triggerWithAccumulator(T value, O& func, A const&... args) const {
            for(const SlotType& slot : copySlots()) {
                if(slot) {
                    value = func(value, slot(args...));
                }
            }
            return value;
        }
 
        void disconnect(std::size_t index) {
            MutexLockType lock(mutex);
            assert(slots.size() > index);
            if(slots[index] != nullptr) {
                --slotCount;
            }
            slots[index] = SlotType{};
            while(!slots.empty() && !slots.back()) {
                slots.pop_back();
            }
        }
 
        struct Disconnector final : EventDisconnector {
            Disconnector() noexcept : ptr(nullptr) {}
 
            explicit Disconnector(TEvent<P, R(A...), F>* ptr) noexcept : ptr(ptr) {}
 
            void operator()(const std::size_t index) const override {
                if(ptr) {
                    ptr->disconnect(index);
                }
            }
 
            TEvent<P, R(A...), F>* ptr;
        };
 
        mutable MutexType mutex;
 
        Vector<SlotType> slots;
 
        SizeType slotCount;
 
        Disconnector disconnector;
 
        SPtr<EventDisconnector> sharedDisconnector;
    };
 
    // Implementation of the disconnect operation of the connection class
    inline void WeakEventConnection::disconnect() {
        if(const auto ptr = weakDisconnector.lock()) {
            (*ptr)(index);
        }
        weakDisconnector.reset();
    }
 
    template<typename P, template<typename> typename F> auto operator co_await(TEvent<P, void(), F>& event) noexcept {
        class Awaiter {
        private:
            TEvent<P, void(), F>& mEvent;
 
            WeakEventConnection mConnection;
 
        public:
            explicit constexpr Awaiter(TEvent<P, void(), F>& event) noexcept : mEvent(event) {}
 
            ~Awaiter() noexcept { mConnection.disconnect(); }
 
            [[nodiscard]] static bool await_ready() { // NOLINT(readability-identifier-naming)
                return false;
            }
 
            [[nodiscard]] bool await_suspend( // NOLINT(readability-identifier-naming)
                CoroutineHandle<> coroutineHandle) {
                mConnection = mEvent.connect([this, coroutineHandle]() mutable {
                    coroutineHandle.resume();
                    mConnection.disconnect();
                });
                return true;
            }
 
            static void await_resume() {} // NOLINT(readability-identifier-naming)
        };
 
        // Create a new awaitable and return to the user.
        return Awaiter{event};
    }
 
    template<typename P, template<typename> typename F, typename... A> auto operator co_await(TEvent<P, void(A...), F>& event) noexcept {
        class Awaiter {
        private:
            using ValueType = Tuple<A...>;
 
            TEvent<P, void(A...), F>& mEvent;
 
            EventConnection mConnection;
 
            ValueType* mValue;
 
        public:
            explicit constexpr Awaiter(TEvent<P, void(A...), F>& event) noexcept : mEvent(event) {}
 
            ~Awaiter() noexcept { mConnection.disconnect(); }
 
            [[nodiscard]] static bool await_ready() { // NOLINT(readability-identifier-naming)
                return false;
            }
 
            [[nodiscard]] bool await_suspend( // NOLINT(readability-identifier-naming)
                CoroutineHandle<> coroutineHandle) {
                mConnection = mEvent.connect([this, coroutineHandle](A... args) mutable {
                    ValueType value = std::tie(args...);
                    mValue = &value;
                    coroutineHandle.resume();
                    mConnection.disconnect();
                });
                return true;
            }
 
            [[nodiscard]] decltype(auto) await_resume() { // NOLINT(readability-identifier-naming)
                if constexpr(sizeof...(A) == 1) {
                    return std::get<0>(*mValue);
                } else {
                    return *mValue;
                }
            }
        };
 
        // Create a new awaitable and return to the user.
        return Awaiter{event};
    }
 
    template<typename T, template<typename> typename F = std::function> using Event = TEvent<MultithreadPolicy, T, F>;
 
    template<typename T, template<typename> typename F = std::function> using UnsafeEvent = TEvent<SinglethreadPolicy, T, F>;
 
} // namespace CeresEngine