util.h

#ifndef UVW_UTIL_INCLUDE_H
#define UVW_UTIL_INCLUDE_H
 
#include <array>
#include <cstddef>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
#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);
}
 
} // namespace details
 
template<typename E>
class Flags final {
    static_assert(std::is_enum_v<E>);
 
    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)} {}
 
    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);
 
    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> passwd;
};
 
struct UtsName {
    UtsName(std::shared_ptr<uv_utsname_t> utsname);
 
    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> 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);
 
    inline static const AddrFuncType addrFunc = &uv_ip4_addr;
    inline static const 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);
 
    inline static const AddrFuncType addrFunc = &uv_ip6_addr;
    inline static const 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;
}
 
} // namespace details
 
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;
 
        static PidType parent() 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 UtsName uname() noexcept;
 
        static Passwd passwd() noexcept;
 
        static int priority(PidType pid);
 
        static bool priority(PidType pid, int prio);
    };
 
    static HandleType guessHandle(HandleCategory category) noexcept;
 
    static HandleType guessHandle(FileHandle file) noexcept;
 
    static std::vector<CPUInfo> cpuInfo() noexcept;
 
    static std::vector<InterfaceAddress> interfaceAddresses() noexcept;
 
    static std::string indexToName(unsigned int index) noexcept;
 
    static std::string indexToIid(unsigned int index) noexcept;
 
    static bool replaceAllocator(MallocFuncType mallocFunc, ReallocFuncType reallocFunc, CallocFuncType callocFunc, FreeFuncType freeFunc) noexcept;
 
    static std::array<double, 3> loadAverage() noexcept;
 
    static char **setupArgs(int argc, char **argv);
 
    static std::string processTitle();
 
    static bool processTitle(const std::string &title);
 
    static uint64_t totalMemory() noexcept;
 
    static uint64_t constrainedMemory() noexcept;
 
    static double uptime() noexcept;
 
    static RUsage rusage() 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 timeOfDay() noexcept;
 
    static void sleep(unsigned int msec) noexcept;
 
    static unsigned int availableParallelism() 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