pipe.hpp

#pragma once


#include <type_traits>
#include <utility>
#include <memory>
#include <string>
#include <uv.h>
#include "request.hpp"
#include "stream.hpp"
#include "util.hpp"
#include "loop.hpp"


namespace uvw {


class PipeHandle final: public StreamHandle<PipeHandle, uv_pipe_t> {
public:
    explicit PipeHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref, bool pass = false)
        : StreamHandle{ca, std::move(ref)}, ipc{pass}
    {}

    bool init() {
        return initialize(&uv_pipe_init, ipc);
    }

    void open(FileHandle file) {
        invoke(&uv_pipe_open, get(), file);
    }

    void bind(std::string name) {
        invoke(&uv_pipe_bind, get(), name.data());
    }

    void connect(std::string name) {
        auto listener = [ptr = shared_from_this()](const auto &event, const auto &) {
            ptr->publish(event);
        };

        auto connect = loop().resource<details::ConnectReq>();
        connect->once<ErrorEvent>(listener);
        connect->once<ConnectEvent>(listener);
        connect->connect(&uv_pipe_connect, get(), name.data());
    }

    std::string sock() const noexcept {
        return details::tryRead(&uv_pipe_getsockname, get());
    }

    std::string peer() const noexcept {
        return details::tryRead(&uv_pipe_getpeername, get());
    }

    void pending(int count) noexcept {
        uv_pipe_pending_instances(get(), count);
    }

    int pending() noexcept {
        return uv_pipe_pending_count(get());
    }

    HandleType receive() noexcept {
        HandleCategory category = uv_pipe_pending_type(get());
        return Utilities::guessHandle(category);
    }

private:
    bool ipc;
};


}