handle.hpp

#ifndef UVW_HANDLE_INCLUDE_H
#define UVW_HANDLE_INCLUDE_H
 
#include <cstddef>
#include <memory>
#include <utility>
#include <uv.h>
#include "resource.hpp"
#include "util.h"
 
namespace uvw {
 
struct CloseEvent {};
 
template<typename T, typename U>
class Handle: public Resource<T, U> {
protected:
    static void closeCallback(uv_handle_t *handle) {
        Handle<T, U> &ref = *(static_cast<T *>(handle->data));
        [[maybe_unused]] auto ptr = ref.shared_from_this();
        ref.reset();
        ref.publish(CloseEvent{});
    }
 
    static void allocCallback(uv_handle_t *, std::size_t suggested, uv_buf_t *buf) {
        auto size = static_cast<unsigned int>(suggested);
        *buf = uv_buf_init(new char[size], size);
    }
 
    template<typename F, typename... Args>
    bool initialize(F &&f, Args &&...args) {
        if(!this->self()) {
            if(auto err = std::forward<F>(f)(this->parent(), this->get(), std::forward<Args>(args)...); err) {
                this->publish(ErrorEvent{err});
            } else {
                this->leak();
            }
        }
 
        return this->self();
    }
 
    template<typename F, typename... Args>
    void invoke(F &&f, Args &&...args) {
        auto err = std::forward<F>(f)(std::forward<Args>(args)...);
        if(err) { Emitter<T>::publish(ErrorEvent{err}); }
    }
 
public:
    using Resource<T, U>::Resource;
 
    HandleCategory category() const noexcept {
        return HandleCategory{this->template get<uv_handle_t>()->type};
    }
 
    HandleType type() const noexcept {
        return Utilities::guessHandle(category());
    }
 
    bool active() const noexcept {
        return !(uv_is_active(this->template get<uv_handle_t>()) == 0);
    }
 
    bool closing() const noexcept {
        return !(uv_is_closing(this->template get<uv_handle_t>()) == 0);
    }
 
    void close() noexcept {
        if(!closing()) {
            uv_close(this->template get<uv_handle_t>(), &Handle<T, U>::closeCallback);
        }
    }
 
    void reference() noexcept {
        uv_ref(this->template get<uv_handle_t>());
    }
 
    void unreference() noexcept {
        uv_unref(this->template get<uv_handle_t>());
    }
 
    bool referenced() const noexcept {
        return !(uv_has_ref(this->template get<uv_handle_t>()) == 0);
    }
 
    std::size_t size() const noexcept {
        return uv_handle_size(this->template get<uv_handle_t>()->type);
    }
 
    int sendBufferSize() {
        int value = 0;
        auto err = uv_send_buffer_size(this->template get<uv_handle_t>(), &value);
        return err ? 0 : value;
    }
 
    bool sendBufferSize(int value) {
        return (0 == uv_send_buffer_size(this->template get<uv_handle_t>(), &value));
    }
 
    int recvBufferSize() {
        int value = 0;
        auto err = uv_recv_buffer_size(this->template get<uv_handle_t>(), &value);
        return err ? 0 : value;
    }
 
    bool recvBufferSize(int value) {
        return (0 == uv_recv_buffer_size(this->template get<uv_handle_t>(), &value));
    }
 
    OSFileDescriptor fd() const {
        uv_os_fd_t fd;
        uv_fileno(this->template get<uv_handle_t>(), &fd);
        return fd;
    }
};
 
} // namespace uvw
 
#endif // UVW_HANDLE_INCLUDE_H