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 "emitter.h"
#include "util.h"
 
namespace uvw {
 
class AsyncHandle;
class CheckHandle;
class FsEventHandle;
class FsPollHandle;
class IdleHandle;
class PipeHandle;
class PollHandle;
class PrepareHandle;
class ProcessHandle;
class SignalHandle;
class TCPHandle;
class TimerHandle;
class TTYHandle;
class UDPHandle;
 
namespace details {
 
enum class UVLoopOption : std::underlying_type_t<uv_loop_option> {
    BLOCK_SIGNAL = UV_LOOP_BLOCK_SIGNAL,
    IDLE_TIME = UV_METRICS_IDLE_TIME
};
 
enum class UVRunMode : std::underlying_type_t<uv_run_mode> {
    DEFAULT = UV_RUN_DEFAULT,
    ONCE = UV_RUN_ONCE,
    NOWAIT = UV_RUN_NOWAIT
};
 
} // namespace details
 
class Loop final: public Emitter<Loop>, public std::enable_shared_from_this<Loop> {
    using Deleter = void (*)(uv_loop_t *);
 
    template<typename, typename>
    friend class Resource;
 
    template<typename R, typename... Args>
    auto create_resource(int, Args &&...args) -> decltype(std::declval<R>().init(), std::shared_ptr<R>{}) {
        auto ptr = R::create(shared_from_this(), std::forward<Args>(args)...);
        ptr = ptr->init() ? ptr : nullptr;
        return ptr;
    }
 
    template<typename R, typename... Args>
    std::shared_ptr<R> create_resource(char, Args &&...args) {
        return R::create(shared_from_this(), std::forward<Args>(args)...);
    }
 
    Loop(std::unique_ptr<uv_loop_t, Deleter> ptr) noexcept;
 
public:
    using Time = std::chrono::duration<uint64_t, std::milli>;
    using Configure = details::UVLoopOption;
    using Mode = details::UVRunMode;
 
    static std::shared_ptr<Loop> create();
 
    static std::shared_ptr<Loop> create(uv_loop_t *loop);
 
    static std::shared_ptr<Loop> getDefault();
 
    Loop(const Loop &) = delete;
    Loop(Loop &&other) = delete;
 
    Loop &operator=(const Loop &) = delete;
    Loop &operator=(Loop &&other) = delete;
 
    ~Loop() noexcept;
 
    template<typename... Args>
    void configure(Configure flag, Args &&...args) {
        auto option = static_cast<std::underlying_type_t<Configure>>(flag);
        auto err = uv_loop_configure(loop.get(), static_cast<uv_loop_option>(option), std::forward<Args>(args)...);
        if(err) { publish(ErrorEvent{err}); }
    }
 
    template<typename R, typename... Args>
    std::shared_ptr<R> resource(Args &&...args) {
        return create_resource<R>(0, std::forward<Args>(args)...);
    }
 
    void close();
 
    template<Mode mode = Mode::DEFAULT>
    bool run() noexcept;
 
    bool alive() const noexcept;
 
    void stop() noexcept;
 
    int descriptor() const noexcept;
 
    std::pair<bool, Time> timeout() const noexcept;
 
    Time idleTime() const noexcept;
 
    Time now() const noexcept;
 
    void update() const noexcept;
 
    template<typename Func>
    void walk(Func callback) {
        auto func = [](uv_handle_t *handle, void *func) {
            if(handle->data) {
                auto &cb = *static_cast<Func *>(func);
 
                switch(Utilities::guessHandle(HandleCategory{handle->type})) {
                case HandleType::ASYNC:
                    cb(*static_cast<AsyncHandle *>(handle->data));
                    break;
                case HandleType::CHECK:
                    cb(*static_cast<CheckHandle *>(handle->data));
                    break;
                case HandleType::FS_EVENT:
                    cb(*static_cast<FsEventHandle *>(handle->data));
                    break;
                case HandleType::FS_POLL:
                    cb(*static_cast<FsPollHandle *>(handle->data));
                    break;
                case HandleType::IDLE:
                    cb(*static_cast<IdleHandle *>(handle->data));
                    break;
                case HandleType::PIPE:
                    cb(*static_cast<PipeHandle *>(handle->data));
                    break;
                case HandleType::POLL:
                    cb(*static_cast<PollHandle *>(handle->data));
                    break;
                case HandleType::PREPARE:
                    cb(*static_cast<PrepareHandle *>(handle->data));
                    break;
                case HandleType::PROCESS:
                    cb(*static_cast<ProcessHandle *>(handle->data));
                    break;
                case HandleType::SIGNAL:
                    cb(*static_cast<SignalHandle *>(handle->data));
                    break;
                case HandleType::TCP:
                    cb(*static_cast<TCPHandle *>(handle->data));
                    break;
                case HandleType::TIMER:
                    cb(*static_cast<TimerHandle *>(handle->data));
                    break;
                case HandleType::TTY:
                    cb(*static_cast<TTYHandle *>(handle->data));
                    break;
                case HandleType::UDP:
                    cb(*static_cast<UDPHandle *>(handle->data));
                    break;
                default:
                    // this handle isn't managed by uvw, let it be...
                    break;
                }
            }
        };
 
        uv_walk(loop.get(), func, &callback);
    }
 
    void fork() noexcept;
 
    template<typename R = void>
    std::shared_ptr<R> data() const {
        return std::static_pointer_cast<R>(userData);
    }
 
    void data(std::shared_ptr<void> uData);
 
    const uv_loop_t *raw() const noexcept;
 
    uv_loop_t *raw() noexcept;
 
private:
    std::unique_ptr<uv_loop_t, Deleter> loop;
    std::shared_ptr<void> userData{nullptr};
};
 
// (extern) explicit instantiations
#ifdef UVW_AS_LIB
extern template bool Loop::run<Loop::Mode::DEFAULT>() noexcept;
extern template bool Loop::run<Loop::Mode::ONCE>() noexcept;
extern template bool Loop::run<Loop::Mode::NOWAIT>() noexcept;
#endif // UVW_AS_LIB
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "loop.cpp"
#endif
 
#endif // UVW_LOOP_INCLUDE_H