poll.hpp

#pragma once


#include <type_traits>
#include <utility>
#include <memory>
#include <uv.h>
#include "handle.hpp"
#include "util.hpp"


namespace uvw {


namespace details {


enum class UVPollEvent: std::underlying_type_t<uv_poll_event> {
    READABLE = UV_READABLE,
    WRITABLE = UV_WRITABLE,
    DISCONNECT = UV_DISCONNECT,
    PRIORITIZED = UV_PRIORITIZED
};


}


struct PollEvent {
    explicit PollEvent(Flags<details::UVPollEvent> events) noexcept
        : flags{std::move(events)}
    {}

    Flags<details::UVPollEvent> flags;
};


class PollHandle final: public Handle<PollHandle, uv_poll_t> {
    static void startCallback(uv_poll_t *handle, int status, int events) {
        PollHandle &poll = *(static_cast<PollHandle*>(handle->data));
        if(status) { poll.publish(ErrorEvent{status}); }
        else { poll.publish(PollEvent{static_cast<std::underlying_type_t<Event>>(events)}); }
    }

public:
    using Event = details::UVPollEvent;

    explicit PollHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref, int desc)
        : Handle{ca, std::move(ref)}, tag{FD}, fd{desc}
    {}

    explicit PollHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref, OSSocketHandle sock)
        : Handle{ca, std::move(ref)}, tag{SOCKET}, socket{sock}
    {}

    bool init() {
        return (tag == SOCKET)
                ? initialize(&uv_poll_init_socket, socket)
                : initialize(&uv_poll_init, fd);
    }

    void start(Flags<Event> flags) {
        invoke(&uv_poll_start, get(), flags, &startCallback);
    }

    void start(Event event) {
        start(Flags<Event>{event});
    }

    void stop() {
        invoke(&uv_poll_stop, get());
    }

private:
    enum { FD, SOCKET } tag;
    union {
        int fd;
        OSSocketHandle::Type socket;
    };
};


}