loop.h

#ifndef UVW_LOOP_INCLUDE_H
#define UVW_LOOP_INCLUDE_H
 
#ifdef _WIN32
#    include <ciso646>
#endif
 
#include <chrono>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
#include <uv.h>
#include "config.h"
#include "emitter.h"
#include "util.h"
 
namespace uvw {
 
class async_handle;
class check_handle;
class fs_event_handle;
class fs_poll_handle;
class idle_handle;
class pipe_handle;
class poll_handle;
class prepare_handle;
class process_handle;
class signal_handle;
class tcp_handle;
class timer_handle;
class tty_handle;
class udp_handle;
 
namespace details {
 
enum class uvw_loop_option : std::underlying_type_t<uv_loop_option> {
    BLOCK_SIGNAL = UV_LOOP_BLOCK_SIGNAL,
    IDLE_TIME = UV_METRICS_IDLE_TIME
};
 
enum class uvw_run_mode : std::underlying_type_t<uv_run_mode> {
    DEFAULT = UV_RUN_DEFAULT,
    ONCE = UV_RUN_ONCE,
    NOWAIT = UV_RUN_NOWAIT
};
 
} // namespace details
 
using metrics_type = uv_metrics_t; 
class loop final: public emitter<loop>, public std::enable_shared_from_this<loop> {
    using deleter = void (*)(uv_loop_t *);
 
    template<typename, typename, typename...>
    friend class resource;
 
    class uv_token {
        friend class loop;
        explicit uv_token(int) {}
    };
 
    loop(std::unique_ptr<uv_loop_t, deleter> ptr) noexcept;
 
public:
    using token = uv_token;
    using time = std::chrono::duration<uint64_t, std::milli>;
    using option = details::uvw_loop_option;
    using run_mode = details::uvw_run_mode;
 
    static std::shared_ptr<loop> create();
 
    static std::shared_ptr<loop> create(uv_loop_t *res);
 
    static std::shared_ptr<loop> get_default();
 
    loop(const loop &) = delete;
    loop(loop &&other) = delete;
 
    loop &operator=(const loop &) = delete;
    loop &operator=(loop &&other) = delete;
 
    ~loop() noexcept;
 
    template<typename... Args>
    int configure(option flag, Args &&...args) {
        return uv_loop_configure(uv_loop.get(), static_cast<uv_loop_option>(flag), std::forward<Args>(args)...);
    }
 
    template<typename R, typename... Args>
    std::shared_ptr<R> resource(Args &&...args) {
        auto ptr = uninitialized_resource<R>(std::forward<Args>(args)...);
        ptr = (ptr->init() == 0) ? ptr : nullptr;
        return ptr;
    }
 
    template<typename R, typename... Args>
    std::shared_ptr<R> uninitialized_resource(Args &&...args) {
        return std::make_shared<R>(token{0}, shared_from_this(), std::forward<Args>(args)...);
    }
 
    int close();
 
    int run(run_mode mode = run_mode::DEFAULT) noexcept;
 
    bool alive() const noexcept;
 
    void stop() noexcept;
 
    int descriptor() const noexcept;
 
    std::pair<bool, time> timeout() const noexcept;
 
    time idle_time() const noexcept;
 
    metrics_type metrics() const noexcept;
 
    time now() const noexcept;
 
    void update() const noexcept;
 
    template<typename Func>
    void walk(Func callback) {
        auto func = [](uv_handle_t *hndl, void *func) {
            if(hndl->data) {
                auto &cb = *static_cast<Func *>(func);
 
                switch(utilities::guess_handle(handle_category{hndl->type})) {
                case handle_type::ASYNC:
                    cb(*static_cast<async_handle *>(hndl->data));
                    break;
                case handle_type::CHECK:
                    cb(*static_cast<check_handle *>(hndl->data));
                    break;
                case handle_type::FS_EVENT:
                    cb(*static_cast<fs_event_handle *>(hndl->data));
                    break;
                case handle_type::FS_POLL:
                    cb(*static_cast<fs_poll_handle *>(hndl->data));
                    break;
                case handle_type::IDLE:
                    cb(*static_cast<idle_handle *>(hndl->data));
                    break;
                case handle_type::PIPE:
                    cb(*static_cast<pipe_handle *>(hndl->data));
                    break;
                case handle_type::POLL:
                    cb(*static_cast<poll_handle *>(hndl->data));
                    break;
                case handle_type::PREPARE:
                    cb(*static_cast<prepare_handle *>(hndl->data));
                    break;
                case handle_type::PROCESS:
                    cb(*static_cast<process_handle *>(hndl->data));
                    break;
                case handle_type::SIGNAL:
                    cb(*static_cast<signal_handle *>(hndl->data));
                    break;
                case handle_type::TCP:
                    cb(*static_cast<tcp_handle *>(hndl->data));
                    break;
                case handle_type::TIMER:
                    cb(*static_cast<timer_handle *>(hndl->data));
                    break;
                case handle_type::TTY:
                    cb(*static_cast<tty_handle *>(hndl->data));
                    break;
                case handle_type::UDP:
                    cb(*static_cast<udp_handle *>(hndl->data));
                    break;
                default:
                    // this handle isn't managed by uvw, let it be...
                    break;
                }
            }
        };
 
        uv_walk(uv_loop.get(), func, &callback);
    }
 
    int fork() noexcept;
 
    template<typename R = void>
    std::shared_ptr<R> data() const {
        return std::static_pointer_cast<R>(user_data);
    }
 
    void data(std::shared_ptr<void> ud);
 
    const uv_loop_t *raw() const noexcept;
 
    uv_loop_t *raw() noexcept;
 
private:
    std::unique_ptr<uv_loop_t, deleter> uv_loop;
    std::shared_ptr<void> user_data{nullptr};
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "loop.cpp"
#endif
 
#endif // UVW_LOOP_INCLUDE_H