handle.hpp

#ifndef UVW_HANDLE_INCLUDE_H
#define UVW_HANDLE_INCLUDE_H
 
#include <cstddef>
#include <memory>
#include <utility>
#include <uv.h>
#include "config.h"
#include "resource.hpp"
#include "util.h"
 
namespace uvw {
 
struct close_event {};
 
template<typename T, typename U, typename... E>
class handle: public resource<T, U, close_event, E...> {
protected:
    static void close_callback(uv_handle_t *hndl) {
        handle<T, U, E...> &ref = *(static_cast<T *>(hndl->data));
        [[maybe_unused]] auto ptr = ref.shared_from_this();
        ref.self_reset();
        ref.publish(close_event{});
    }
 
    uv_handle_t *as_uv_handle() {
        return reinterpret_cast<uv_handle_t *>(this->raw());
    }
 
    const uv_handle_t *as_uv_handle() const {
        return reinterpret_cast<const uv_handle_t *>(this->raw());
    }
 
public:
    using resource<T, U, close_event, E...>::resource;
 
    handle_category category() const noexcept {
        return handle_category{as_uv_handle()->type};
    }
 
    handle_type type() const noexcept {
        return utilities::guess_handle(category());
    }
 
    bool active() const noexcept {
        return !!uv_is_active(as_uv_handle());
    }
 
    bool closing() const noexcept {
        return !!uv_is_closing(as_uv_handle());
    }
 
    void close() noexcept {
        if(!closing()) {
            uv_close(as_uv_handle(), &handle<T, U, E...>::close_callback);
        }
    }
 
    void reference() noexcept {
        uv_ref(as_uv_handle());
    }
 
    void unreference() noexcept {
        uv_unref(as_uv_handle());
    }
 
    bool referenced() const noexcept {
        return !!uv_has_ref(as_uv_handle());
    }
 
    std::size_t size() const noexcept {
        return uv_handle_size(as_uv_handle()->type);
    }
 
    int send_buffer_size() {
        int value = 0;
        auto err = uv_send_buffer_size(as_uv_handle(), &value);
        return err ? err : value;
    }
 
    int send_buffer_size(int value) {
        return uv_send_buffer_size(as_uv_handle(), &value);
    }
 
    int recv_buffer_size() {
        int value = 0;
        auto err = uv_recv_buffer_size(as_uv_handle(), &value);
        return err ? err : value;
    }
 
    int recv_buffer_size(int value) {
        return uv_recv_buffer_size(as_uv_handle(), &value);
    }
 
    os_file_descriptor fd() const {
        uv_os_fd_t fd;
        uv_fileno(as_uv_handle(), &fd);
        return fd;
    }
};
 
} // namespace uvw
 
#endif // UVW_HANDLE_INCLUDE_H