util.h

#ifndef UVW_UTIL_INCLUDE_H
#define UVW_UTIL_INCLUDE_H
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
#include <uv.h>
#include "config.h"
 
namespace uvw {
 
namespace details {
 
enum class uvw_handle_type : std::underlying_type_t<uv_handle_type> {
    UNKNOWN = UV_UNKNOWN_HANDLE,
    ASYNC = UV_ASYNC,
    CHECK = UV_CHECK,
    FS_EVENT = UV_FS_EVENT,
    FS_POLL = UV_FS_POLL,
    HANDLE = UV_HANDLE,
    IDLE = UV_IDLE,
    PIPE = UV_NAMED_PIPE,
    POLL = UV_POLL,
    PREPARE = UV_PREPARE,
    PROCESS = UV_PROCESS,
    STREAM = UV_STREAM,
    TCP = UV_TCP,
    TIMER = UV_TIMER,
    TTY = UV_TTY,
    UDP = UV_UDP,
    SIGNAL = UV_SIGNAL,
    FILE = UV_FILE
};
 
enum class uvw_clock_id : std::underlying_type_t<uv_clock_id> {
    MONOTONIC = UV_CLOCK_MONOTONIC,
    REALTIME = UV_CLOCK_REALTIME
};
 
template<typename T>
struct uv_type_wrapper {
    using Type = T;
 
    constexpr uv_type_wrapper()
        : value{} {}
 
    constexpr uv_type_wrapper(Type val)
        : value{val} {}
 
    constexpr operator Type() const noexcept {
        return value;
    }
 
    bool operator==(uv_type_wrapper other) const noexcept {
        return value == other.value;
    }
 
private:
    const Type value;
};
 
template<typename T>
bool operator==(uv_type_wrapper<T> lhs, uv_type_wrapper<T> rhs) {
    return !(lhs == rhs);
}
 
} // namespace details

struct win_size {
    int width;  
    int height; 
};
 
using handle_type = details::uvw_handle_type;                     
using handle_category = details::uv_type_wrapper<uv_handle_type>; 
using file_handle = details::uv_type_wrapper<uv_file>;            
using os_socket_handle = details::uv_type_wrapper<uv_os_sock_t>;  
using os_file_descriptor = details::uv_type_wrapper<uv_os_fd_t>;  
using pid_type = details::uv_type_wrapper<uv_pid_t>;              
using clock_id = details::uvw_clock_id;                           
 
constexpr file_handle std_in{0};  
constexpr file_handle std_out{1}; 
constexpr file_handle std_err{2}; 
 
using time_spec = uv_timespec_t; 
using file_info = uv_stat_t;     
using fs_info = uv_statfs_t;     
using uid_type = uv_uid_t;       
using gid_type = uv_gid_t;       
 
using timeval = uv_timeval_t;       
using timeval64 = uv_timeval64_t;   
using timespec64 = uv_timespec64_t; 
using resource_usage = uv_rusage_t; 

struct passwd_info {
    passwd_info(std::shared_ptr<uv_passwd_t> pwd);

    std::string username() const noexcept;

    decltype(uv_passwd_t::uid) uid() const noexcept;

    decltype(uv_passwd_t::gid) gid() const noexcept;

    std::string shell() const noexcept;

    std::string homedir() const noexcept;

    operator bool() const noexcept;
 
private:
    std::shared_ptr<uv_passwd_t> value;
};

struct uts_name {
    uts_name(std::shared_ptr<uv_utsname_t> init);

    std::string sysname() const noexcept;

    std::string release() const noexcept;

    std::string version() const noexcept;

    std::string machine() const noexcept;
 
private:
    std::shared_ptr<uv_utsname_t> uname;
};

struct ipv4 {};

struct ipv6 {};

struct socket_address {
    std::string ip;    
    unsigned int port; 
};

struct cpu_info {
    using cpu_time = decltype(uv_cpu_info_t::cpu_times);
 
    std::string model; 
    int speed;         

    cpu_time times;
};

struct interface_address {
    std::string name;       
    char physical[6];       
    bool internal;          
    socket_address address; 
    socket_address netmask; 
};
 
namespace details {
 
static constexpr std::size_t DEFAULT_SIZE = 128;
 
template<typename F, typename... Args>
std::string try_read(F &&f, Args &&...args) noexcept {
    std::size_t size = DEFAULT_SIZE;
    char buf[DEFAULT_SIZE];
    std::string str{};
    auto err = std::forward<F>(f)(args..., buf, &size);
 
    if(UV_ENOBUFS == err) {
        std::unique_ptr<char[]> data{new char[size]};
        err = std::forward<F>(f)(args..., data.get(), &size);
 
        if(0 == err) {
            str = data.get();
        }
    } else if(0 == err) {
        str.assign(buf, size);
    }
 
    return str;
}
 
void common_alloc_callback(uv_handle_t *, std::size_t suggested, uv_buf_t *buf);
 
template<typename Type, auto Alloc>
void common_alloc_callback(uv_handle_t *handle, std::size_t suggested, uv_buf_t *buf) {
    auto [alloc, size] = Alloc(*static_cast<const Type *>(handle->data), suggested);
    *buf = uv_buf_init(alloc, static_cast<unsigned int>(size));
}
 
sockaddr ip_addr(const char *addr, unsigned int port);
socket_address sock_addr(const sockaddr_in &addr);
socket_address sock_addr(const sockaddr_in6 &addr);
socket_address sock_addr(const sockaddr &addr);
socket_address sock_addr(const sockaddr_storage &storage);
 
} // namespace details

struct utilities {
    using malloc_func_type = void *(*)(size_t);
    using realloc_func_type = void *(*)(void *, size_t);
    using calloc_func_type = void *(*)(size_t, size_t);
    using free_func_type = void (*)(void *);

    struct os {
        static pid_type pid() noexcept;

        static pid_type ppid() noexcept;

        static std::string homedir() noexcept;

        static std::string tmpdir() noexcept;

        static std::string env(const std::string &name) noexcept;

        static bool env(const std::string &name, const std::string &value) noexcept;

        template<typename Func>
        static std::enable_if_t<std::is_invocable_v<Func, std::string_view, std::string_view>, bool>
        env(Func func) noexcept {
            uv_env_item_t *items = nullptr;
            int count{};
 
            const bool ret = (uv_os_environ(&items, &count) == 0);
 
            if(ret) {
                for(int pos = 0; pos < count; ++pos) {
                    func(std::string_view{items[pos].name}, std::string_view{items[pos].value});
                }
 
                uv_os_free_environ(items, count);
            }
 
            return ret;
        }

        static std::string hostname() noexcept;

        static uts_name uname() noexcept;

        static passwd_info passwd() noexcept;

        static int priority(pid_type pid);

        static bool priority(pid_type pid, int prio);
    };

    static handle_type guess_handle(handle_category category) noexcept;

    static handle_type guess_handle(file_handle file) noexcept;

    static std::vector<cpu_info> cpu() noexcept;

    static std::vector<interface_address> interface_addresses() noexcept;

    static std::string index_to_name(unsigned int index) noexcept;

    static std::string index_to_iid(unsigned int index) noexcept;

    static bool replace_allocator(malloc_func_type malloc_func, realloc_func_type realloc_func, calloc_func_type calloc_func, free_func_type free_func) noexcept;

    static std::array<double, 3> load_average() noexcept;

    static char **setup_args(int argc, char **argv);

    static std::string process_title();

    static bool process_title(const std::string &title);

    static uint64_t total_memory() noexcept;

    static uint64_t constrained_memory() noexcept;

    static uint64_t available_memory() noexcept;

    static double uptime() noexcept;

    static resource_usage rusage() noexcept;

    static timespec64 gettime(clock_id source) noexcept;

    static uint64_t hrtime() noexcept;

    static std::string path() noexcept;

    static std::string cwd() noexcept;

    static bool chdir(const std::string &dir) noexcept;

    static timeval64 time_of_day() noexcept;

    static void sleep(unsigned int msec) noexcept;

    static unsigned int available_parallelism() noexcept;
};

template<class... Func>
struct overloaded: Func... {
    using Func::operator()...;
};

template<class... Func>
overloaded(Func...) -> overloaded<Func...>;
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "util.cpp"
#endif
 
#endif // UVW_UTIL_INCLUDE_H