emitter.h

#ifndef UVW_EMITTER_INCLUDE_H
#define UVW_EMITTER_INCLUDE_H
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <list>
#include <memory>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <uv.h>
#include "config.h"
#include "type_info.hpp"
 
namespace uvw {

struct error_event {
    template<typename Type, typename = std::enable_if_t<std::is_integral_v<Type>>>
    explicit error_event(Type 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 Elem, typename... Event>
class emitter {
public:
    template<typename Type>
    using listener_t = std::function<void(Type &, Elem &)>;
 
private:
    template<typename Type>
    const auto &handler() const noexcept {
        return std::get<listener_t<Type>>(handlers);
    }
 
    template<typename Type>
    auto &handler() noexcept {
        return std::get<listener_t<Type>>(handlers);
    }
 
protected:
    template<typename Type>
    void publish(Type event) {
        if(auto &listener = handler<Type>(); listener) {
            listener(event, *static_cast<Elem *>(this));
        }
    }
 
public:
    virtual ~emitter() noexcept {
        static_assert(std::is_base_of_v<emitter<Elem, Event...>, Elem>);
    }

    template<typename Type>
    void on(listener_t<Type> f) {
        handler<Type>() = std::move(f);
    }

    template<typename Type>
    void reset() noexcept {
        handler<Type>() = nullptr;
    }

    void reset() noexcept {
        reset<error_event>();
        (reset<Event>(), ...);
    }

    template<typename Type>
    bool has() const noexcept {
        return static_cast<bool>(handler<Type>());
    }
 
private:
    std::tuple<listener_t<error_event>, listener_t<Event>...> handlers{};
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "emitter.cpp"
#endif
 
#endif // UVW_EMITTER_INCLUDE_H