emitter.h

#ifndef UVW_EMITTER_INCLUDE_H
#define UVW_EMITTER_INCLUDE_H
 
 
#include <type_traits>
#include <functional>
#include <algorithm>
#include <utility>
#include <cstddef>
#include <vector>
#include <memory>
#include <list>
#include <uv.h>
 
 
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{};
    };
 
    static std::size_t next_type() noexcept {
        static std::size_t counter = 0;
        return counter++;
    }
 
    template<typename>
    static std::size_t event_type() noexcept {
        static std::size_t value = next_type();
        return value;
    }
 
    template<typename E>
    Handler<E> & handler() noexcept {
        std::size_t type = event_type<E>();
 
        if(!(type < handlers.size())) {
            handlers.resize(type+1);
        }
 
        if(!handlers[type]) {
           handlers[type] = std::make_unique<Handler<E>>();
        }
 
        return static_cast<Handler<E>&>(*handlers[type]);
    }
 
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) { hdlr->clear(); } });
    }
 
    template<typename E>
    bool empty() const noexcept {
        std::size_t type = event_type<E>();
 
        return (!(type < handlers.size()) ||
                !handlers[type] ||
                static_cast<Handler<E>&>(*handlers[type]).empty());
    }
 
    bool empty() const noexcept {
        return std::all_of(handlers.cbegin(), handlers.cend(),
                           [](auto &&hdlr){ return !hdlr || hdlr->empty(); });
    }
 
private:
    std::vector<std::unique_ptr<BaseHandler>> handlers{};
};
 
 
}
 
 
#ifndef UVW_AS_LIB
#include "emitter.cpp"
#endif
 
#endif // UVW_EMITTER_INCLUDE_H