emitter.h

#ifndef UVW_EMITTER_INCLUDE_H
#define UVW_EMITTER_INCLUDE_H
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <list>
#include <memory>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <uv.h>
#include "type_info.hpp"
 
namespace uvw {
 
struct ErrorEvent {
    template<typename U, typename = std::enable_if_t<std::is_integral_v<U>>>
    explicit ErrorEvent(U val) noexcept
        : ec{static_cast<int>(val)} {}
 
    static int translate(int sys) noexcept;
 
    const char *what() const noexcept;
 
    const char *name() const noexcept;
 
    int code() const noexcept;
 
    explicit operator bool() const noexcept;
 
private:
    const int ec;
};
 
template<typename T>
class Emitter {
    struct BaseHandler {
        virtual ~BaseHandler() noexcept = default;
        virtual bool empty() const noexcept = 0;
        virtual void clear() noexcept = 0;
    };
 
    template<typename E>
    struct Handler final: BaseHandler {
        using Listener = std::function<void(E &, T &)>;
        using Element = std::pair<bool, Listener>;
        using ListenerList = std::list<Element>;
        using Connection = typename ListenerList::iterator;
 
        bool empty() const noexcept override {
            auto pred = [](auto &&element) { return element.first; };
 
            return std::all_of(onceL.cbegin(), onceL.cend(), pred) && std::all_of(onL.cbegin(), onL.cend(), pred);
        }
 
        void clear() noexcept override {
            if(publishing) {
                auto func = [](auto &&element) { element.first = true; };
                std::for_each(onceL.begin(), onceL.end(), func);
                std::for_each(onL.begin(), onL.end(), func);
            } else {
                onceL.clear();
                onL.clear();
            }
        }
 
        Connection once(Listener f) {
            return onceL.emplace(onceL.cend(), false, std::move(f));
        }
 
        Connection on(Listener f) {
            return onL.emplace(onL.cend(), false, std::move(f));
        }
 
        void erase(Connection conn) noexcept {
            conn->first = true;
 
            if(!publishing) {
                auto pred = [](auto &&element) { return element.first; };
                onceL.remove_if(pred);
                onL.remove_if(pred);
            }
        }
 
        void publish(E event, T &ref) {
            ListenerList currentL;
            onceL.swap(currentL);
 
            auto func = [&event, &ref](auto &&element) {
                return element.first ? void() : element.second(event, ref);
            };
 
            publishing = true;
 
            std::for_each(onL.rbegin(), onL.rend(), func);
            std::for_each(currentL.rbegin(), currentL.rend(), func);
 
            publishing = false;
 
            onL.remove_if([](auto &&element) { return element.first; });
        }
 
    private:
        bool publishing{false};
        ListenerList onceL{};
        ListenerList onL{};
    };
 
    template<typename E>
    Handler<E> &handler() noexcept {
        auto id = type<E>();
 
        if(!handlers.count(id)) {
            handlers[id] = std::make_unique<Handler<E>>();
        }
 
        return static_cast<Handler<E> &>(*handlers.at(id));
    }
 
protected:
    template<typename E>
    void publish(E event) {
        handler<E>().publish(std::move(event), *static_cast<T *>(this));
    }
 
public:
    template<typename E>
    using Listener = typename Handler<E>::Listener;
 
    template<typename E>
    struct Connection: private Handler<E>::Connection {
        template<typename>
        friend class Emitter;
 
        Connection() = default;
        Connection(const Connection &) = default;
        Connection(Connection &&) = default;
 
        Connection(typename Handler<E>::Connection conn)
            : Handler<E>::Connection{std::move(conn)} {}
 
        Connection &operator=(const Connection &) = default;
        Connection &operator=(Connection &&) = default;
    };
 
    virtual ~Emitter() noexcept {
        static_assert(std::is_base_of_v<Emitter<T>, T>);
    }
 
    template<typename E>
    Connection<E> on(Listener<E> f) {
        return handler<E>().on(std::move(f));
    }
 
    template<typename E>
    Connection<E> once(Listener<E> f) {
        return handler<E>().once(std::move(f));
    }
 
    template<typename E>
    void erase(Connection<E> conn) noexcept {
        handler<E>().erase(std::move(conn));
    }
 
    template<typename E>
    void clear() noexcept {
        handler<E>().clear();
    }
 
    void clear() noexcept {
        std::for_each(handlers.begin(), handlers.end(), [](auto &&hdlr) { if(hdlr.second) { hdlr.second->clear(); } });
    }
 
    template<typename E>
    bool empty() const noexcept {
        auto id = type<E>();
 
        return (!handlers.count(id) || static_cast<Handler<E> &>(*handlers.at(id)).empty());
    }
 
    bool empty() const noexcept {
        return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&hdlr) { return !hdlr.second || hdlr.second->empty(); });
    }
 
private:
    std::unordered_map<std::uint32_t, std::unique_ptr<BaseHandler>> handlers{};
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "emitter.cpp"
#endif
 
#endif // UVW_EMITTER_INCLUDE_H