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 U, typename = std::enable_if_t<std::is_integral_v<U>>>
    explicit error_event(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, typename... E>
class emitter {
public:
    template<typename U>
    using listener_t = std::function<void(U &, T &)>;
 
private:
    template<typename U>
    const auto &handler() const noexcept {
        return std::get<listener_t<U>>(handlers);
    }
 
    template<typename U>
    auto &handler() noexcept {
        return std::get<listener_t<U>>(handlers);
    }
 
protected:
    template<typename U>
    void publish(U event) {
        if(auto &listener = handler<U>(); listener) {
            listener(event, *static_cast<T *>(this));
        }
    }
 
public:
    virtual ~emitter() noexcept {
        static_assert(std::is_base_of_v<emitter<T, E...>, T>);
    }
 
    template<typename U>
    void on(listener_t<U> f) {
        handler<U>() = std::move(f);
    }
 
    template<typename U>
    void reset() noexcept {
        handler<U>() = nullptr;
    }
 
    void reset() noexcept {
        reset<error_event>();
        (reset<E>(), ...);
    }
 
    template<typename U>
    bool has() const noexcept {
        return static_cast<bool>(handler<U>());
    }
 
private:
    std::tuple<listener_t<error_event>, listener_t<E>...> handlers{};
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "emitter.cpp"
#endif
 
#endif // UVW_EMITTER_INCLUDE_H