util.hpp

#pragma once


#include <string_view>
#include <type_traits>
#include <algorithm>
#include <stdexcept>
#include <cstddef>
#include <utility>
#include <string>
#include <vector>
#include <memory>
#include <array>
#include <uv.h>


namespace uvw {


namespace details {


enum class UVHandleType: 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
};


template<typename T>
struct UVTypeWrapper {
    using Type = T;

    constexpr UVTypeWrapper(): value{} {}
    constexpr UVTypeWrapper(Type val): value{val} {}

    constexpr operator Type() const noexcept { return value; }

    bool operator==(UVTypeWrapper other) const noexcept {
        return value == other.value;
    }

private:
    const Type value;
};


template<typename T>
bool operator==(UVTypeWrapper<T> lhs, UVTypeWrapper<T> rhs) {
    return !(lhs == rhs);
}


}


template<typename E>
class Flags final {
    using InnerType = std::underlying_type_t<E>;

    constexpr InnerType toInnerType(E flag) const noexcept { return static_cast<InnerType>(flag); }

public:
    using Type = InnerType;

    template<E... V>
    static constexpr Flags<E> from() {
        return (Flags<E>{} | ... | V);
    }

    constexpr Flags(E flag) noexcept: flags{toInnerType(flag)} {}

    constexpr Flags(Type f): flags{f} {}

    constexpr Flags(): flags{} {}

    constexpr Flags(const Flags &f) noexcept: flags{f.flags} {  }
    constexpr Flags(Flags &&f) noexcept: flags{std::move(f.flags)} {  }

    ~Flags() noexcept { static_assert(std::is_enum_v<E>); }

    constexpr Flags & operator=(const Flags &f) noexcept {
        flags = f.flags;
        return *this;
    }

    constexpr Flags & operator=(Flags &&f) noexcept {
        flags = std::move(f.flags);
        return *this;
    }

    constexpr Flags operator|(const Flags &f) const noexcept { return Flags{flags | f.flags}; }

    constexpr Flags operator|(E flag) const noexcept { return Flags{flags | toInnerType(flag)}; }

    constexpr Flags operator&(const Flags &f) const noexcept { return Flags{flags & f.flags}; }

    constexpr Flags operator&(E flag) const noexcept { return Flags{flags & toInnerType(flag)}; }

    explicit constexpr operator bool() const noexcept { return !(flags == InnerType{}); }

    constexpr operator Type() const noexcept { return flags; }

private:
    InnerType flags;
};


struct WinSize {
    int width; 
    int height; 
};


using HandleType = details::UVHandleType; 
using HandleCategory = details::UVTypeWrapper<uv_handle_type>; 
using FileHandle = details::UVTypeWrapper<uv_file>; 
using OSSocketHandle = details::UVTypeWrapper<uv_os_sock_t>; 
using OSFileDescriptor = details::UVTypeWrapper<uv_os_fd_t>; 
using PidType = details::UVTypeWrapper<uv_pid_t>; 
constexpr FileHandle StdIN{0}; 
constexpr FileHandle StdOUT{1}; 
constexpr FileHandle StdERR{2}; 
using TimeSpec = uv_timespec_t; 
using Stat = uv_stat_t; 
using Statfs = uv_statfs_t; 
using Uid = uv_uid_t; 
using Gid = uv_gid_t; 
using TimeVal = uv_timeval_t; 
using TimeVal64 = uv_timeval64_t; 
using RUsage = uv_rusage_t; 
struct Passwd {
    Passwd(std::shared_ptr<uv_passwd_t> pwd): passwd{pwd} {}

    std::string username() const noexcept {
        return ((passwd && passwd->username) ? passwd->username : "");
    }

    auto uid() const noexcept {
        return (passwd ? passwd->uid : decltype(uv_passwd_t::uid){});
    }

    auto gid() const noexcept {
        return (passwd ?  passwd->gid : decltype(uv_passwd_t::gid){});
    }

    std::string shell() const noexcept {
        return ((passwd && passwd->shell) ? passwd->shell : "");
    }

    std::string homedir() const noexcept {
        return ((passwd && passwd->homedir) ? passwd->homedir: "");
    }

    operator bool() const noexcept {
        return static_cast<bool>(passwd);
    }

private:
    std::shared_ptr<uv_passwd_t> passwd;
};


struct UtsName {
    UtsName(std::shared_ptr<uv_utsname_t> utsname): utsname{utsname} {}

    std::string sysname() const noexcept {
        return utsname ? utsname->sysname : "";
    }

    std::string release() const noexcept {
        return utsname ? utsname->release : "";
    }

    std::string version() const noexcept {
        return utsname ? utsname->version : "";
    }

    std::string machine() const noexcept {
        return utsname ? utsname->machine : "";
    }

private:
    std::shared_ptr<uv_utsname_t> utsname;
};


struct IPv4 {};


struct IPv6 {};


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


struct CPUInfo {
    using CPUTime = decltype(uv_cpu_info_t::cpu_times);

    std::string model; 
    int speed; 
    CPUTime times;
};


struct InterfaceAddress {
    std::string name; 
    char physical[6]; 
    bool internal; 
    Addr address; 
    Addr netmask; 
};


namespace details {


static constexpr std::size_t DEFAULT_SIZE = 128;


template<typename>
struct IpTraits;


template<>
struct IpTraits<IPv4> {
    using Type = sockaddr_in;
    using AddrFuncType = int(*)(const char *, int, Type *);
    using NameFuncType = int(*)(const Type *, char *, std::size_t);
    static constexpr AddrFuncType addrFunc = &uv_ip4_addr;
    static constexpr NameFuncType nameFunc = &uv_ip4_name;
    static constexpr auto sinPort(const Type *addr) { return addr->sin_port; }
};


template<>
struct IpTraits<IPv6> {
    using Type = sockaddr_in6;
    using AddrFuncType = int(*)(const char *, int, Type *);
    using NameFuncType = int(*)(const Type *, char *, std::size_t);
    static constexpr AddrFuncType addrFunc = &uv_ip6_addr;
    static constexpr NameFuncType nameFunc = &uv_ip6_name;
    static constexpr auto sinPort(const Type *addr) { return addr->sin6_port; }
};


template<typename I>
Addr address(const typename details::IpTraits<I>::Type *aptr) noexcept {
    Addr addr;
    char name[DEFAULT_SIZE];

    int err = details::IpTraits<I>::nameFunc(aptr, name, DEFAULT_SIZE);

    if(0 == err) {
        addr.port = ntohs(details::IpTraits<I>::sinPort(aptr));
        addr.ip = std::string{name};
    }

    return addr;
}


template<typename I, typename F, typename H>
Addr address(F &&f, const H *handle) noexcept {
    sockaddr_storage ssto;
    int len = sizeof(ssto);
    Addr addr{};

    int err = std::forward<F>(f)(handle, reinterpret_cast<sockaddr *>(&ssto), &len);

    if(0 == err) {
        typename IpTraits<I>::Type *aptr = reinterpret_cast<typename IpTraits<I>::Type *>(&ssto);
        addr = address<I>(aptr);
    }

    return addr;
}


template<typename F, typename... Args>
std::string tryRead(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;
}


}


struct Utilities {
    using MallocFuncType = void*(*)(size_t);
    using ReallocFuncType = void*(*)(void*, size_t);
    using CallocFuncType = void*(*)(size_t, size_t);
    using FreeFuncType = void(*)(void*);

    struct OS {
        static PidType pid() noexcept {
            return uv_os_getpid();
        }

        static PidType parent() noexcept {
            return uv_os_getppid();
        }

        static std::string homedir() noexcept {
            return details::tryRead(&uv_os_homedir);
        }

        static std::string tmpdir() noexcept {
            return details::tryRead(&uv_os_tmpdir);
        }

        static std::string env(const std::string &name) noexcept {
            return details::tryRead(&uv_os_getenv, name.c_str());
        }

        static bool env(const std::string &name, const std::string &value) noexcept {
            return (0 == (value.empty() ? uv_os_unsetenv(name.c_str()) : uv_os_setenv(name.c_str(), value.c_str())));
        }

        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 {
            return details::tryRead(&uv_os_gethostname);
        }

        static UtsName uname() noexcept {
            auto ptr = std::make_shared<uv_utsname_t>();
            uv_os_uname(ptr.get());
            return ptr;
        }

        static Passwd passwd() noexcept {
            auto deleter = [](uv_passwd_t *passwd){
                uv_os_free_passwd(passwd);
                delete passwd;
            };

            std::shared_ptr<uv_passwd_t> ptr{new uv_passwd_t, std::move(deleter)};
            uv_os_get_passwd(ptr.get());
            return ptr;
        }
    };

    static int osPriority(PidType pid) {
        int prio = 0;

        if(uv_os_getpriority(pid, &prio)) {
            prio = UV_PRIORITY_LOW + 1;
        }

        return prio;
    }

    static bool osPriority(PidType pid, int prio) {
        return 0 == uv_os_setpriority(pid, prio);
    }

    static HandleType guessHandle(HandleCategory category) noexcept {
        switch(category) {
        case UV_ASYNC:
            return HandleType::ASYNC;
        case UV_CHECK:
            return HandleType::CHECK;
        case UV_FS_EVENT:
            return HandleType::FS_EVENT;
        case UV_FS_POLL:
            return HandleType::FS_POLL;
        case UV_HANDLE:
            return HandleType::HANDLE;
        case UV_IDLE:
            return HandleType::IDLE;
        case UV_NAMED_PIPE:
            return HandleType::PIPE;
        case UV_POLL:
            return HandleType::POLL;
        case UV_PREPARE:
            return HandleType::PREPARE;
        case UV_PROCESS:
            return HandleType::PROCESS;
        case UV_STREAM:
            return HandleType::STREAM;
        case UV_TCP:
            return HandleType::TCP;
        case UV_TIMER:
            return HandleType::TIMER;
        case UV_TTY:
            return HandleType::TTY;
        case UV_UDP:
            return HandleType::UDP;
        case UV_SIGNAL:
            return HandleType::SIGNAL;
        case UV_FILE:
            return HandleType::FILE;
        default:
            return HandleType::UNKNOWN;
        }
    }

    static HandleType guessHandle(FileHandle file) noexcept {
        HandleCategory category = uv_guess_handle(file);
        return guessHandle(category);
    }


    static std::vector<CPUInfo> cpuInfo() noexcept {
        std::vector<CPUInfo> cpuinfos;

        uv_cpu_info_t *infos;
        int count;

        if(0 == uv_cpu_info(&infos, &count)) {
            std::for_each(infos, infos+count, [&cpuinfos](const auto &info) {
                cpuinfos.push_back({ info.model, info.speed, info.cpu_times });
            });

            uv_free_cpu_info(infos, count);
        }

        return cpuinfos;
    }

    static std::vector<InterfaceAddress> interfaceAddresses() noexcept {
        std::vector<InterfaceAddress> interfaces;

        uv_interface_address_t *ifaces{nullptr};
        int count{0};

        if(0 == uv_interface_addresses(&ifaces, &count)) {
            std::for_each(ifaces, ifaces+count, [&interfaces](const auto &iface) {
                InterfaceAddress interfaceAddress;

                interfaceAddress.name = iface.name;
                std::copy(iface.phys_addr, (iface.phys_addr+6), interfaceAddress.physical);
                interfaceAddress.internal = iface.is_internal == 0 ? false : true;

                if(iface.address.address4.sin_family == AF_INET) {
                    interfaceAddress.address = details::address<IPv4>(&iface.address.address4);
                    interfaceAddress.netmask = details::address<IPv4>(&iface.netmask.netmask4);
                } else if(iface.address.address4.sin_family == AF_INET6) {
                    interfaceAddress.address = details::address<IPv6>(&iface.address.address6);
                    interfaceAddress.netmask = details::address<IPv6>(&iface.netmask.netmask6);
                }

                interfaces.push_back(std::move(interfaceAddress));
            });

            uv_free_interface_addresses(ifaces, count);
        }

        return interfaces;
    }

    static std::string indexToName(unsigned int index) noexcept {
        return details::tryRead(&uv_if_indextoname, index);
    }

    static std::string indexToIid(unsigned int index) noexcept {
        return details::tryRead(&uv_if_indextoiid, index);
    }

    static bool replaceAllocator(MallocFuncType mallocFunc, ReallocFuncType reallocFunc, CallocFuncType callocFunc, FreeFuncType freeFunc) noexcept {
        return (0 == uv_replace_allocator(mallocFunc, reallocFunc, callocFunc, freeFunc));
    }

    static std::array<double, 3> loadAverage() noexcept {
        std::array<double, 3> avg;
        uv_loadavg(avg.data());
        return avg;
    }

    static char ** setupArgs(int argc, char** argv) {
        return uv_setup_args(argc, argv);
    }

    static std::string processTitle() {
        std::size_t size = details::DEFAULT_SIZE;
        char buf[details::DEFAULT_SIZE];
        std::string str{};

        if(0 == uv_get_process_title(buf, size)) {
            str.assign(buf, size);
        }

        return str;
    }

    static bool processTitle(std::string title) {
        return (0 == uv_set_process_title(title.c_str()));
    }

    static uint64_t totalMemory() noexcept {
        return uv_get_total_memory();
    }

    static uint64_t constrainedMemory() noexcept {
        return uv_get_constrained_memory();
    }

    static double uptime() noexcept {
        double ret;

        if(0 != uv_uptime(&ret)) {
            ret = 0;
        }

        return ret;
    }

    static RUsage rusage() noexcept {
        RUsage ru;
        auto err = uv_getrusage(&ru);
        return err ? RUsage{} : ru;
    }

    static uint64_t hrtime() noexcept {
        return uv_hrtime();
    }

    static std::string path() noexcept {
        return details::tryRead(&uv_exepath);
    }

    static std::string cwd() noexcept {
        return details::tryRead(&uv_cwd);
    }

    static bool chdir(const std::string &dir) noexcept {
        return (0 == uv_chdir(dir.data()));
    }

    static TimeVal64 timeOfDay() {
        uv_timeval64_t ret;
        uv_gettimeofday(&ret);
        return ret;
    }
};


}