Misc.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <iomanip>
#include <optional>
#include <sstream>
#include <string>
 
#include "String.h"
 
namespace SlHelpers {

struct Version {
    Version() = delete;

    static auto versionSplit(std::string_view version) noexcept {
        return String::splitSV(version, ".-");
    }

    static unsigned versionPart(std::string_view version, bool rc = false) noexcept {
        if (rc && version.starts_with("rc"))
            version.remove_prefix(2);
        if (const auto verPart = String::toNum(version))
            return *verPart;
        return 0;
    }

    static unsigned versionSum(std::string_view version) noexcept {
        const auto arr = Version::versionSplit(version);
        unsigned ret = 0;
        for (auto i = 0U; i < 3; ++i) {
            ret <<= 8;
            if (i < arr.size())
                ret += Version::versionPart(arr[i], i == 2);
        }
        return ret;
    }
 
};

struct CmpVersions {
    bool operator()(std::string_view ver1, std::string_view ver2) const noexcept
    {
        const auto arr1 = Version::versionSplit(ver1);
        const auto arr2 = Version::versionSplit(ver2);
        for (auto i = 0U; i < 2U; ++i) {
            auto ver1 = Version::versionPart(arr1[i]);
            auto ver2 = Version::versionPart(arr2[i]);
            if (ver1 != ver2)
                return ver1 < ver2;
            const auto arr1Last = arr1.size() == i + 1;
            const auto arr2Last = arr2.size() == i + 1;
            if (arr1Last && arr2Last)
                return false;
            if (arr1Last || arr2Last)
                return arr1Last;
        }
 
        return Version::versionPart(arr1[2], true) < Version::versionPart(arr2[2], true);
    }
};

struct Env {
    template <typename T = std::string>
    static std::optional<T> get(const std::string &name) noexcept {
        if (const auto env = std::getenv(name.c_str()))
            return env;
        return std::nullopt;
    }
};

template <typename Rep = double, typename Period = std::milli>
class Measure {
    using Clock = std::chrono::steady_clock;
    using TimePoint = Clock::time_point;
    using Dur = std::chrono::duration<Rep, Period>;
public:
    Measure() noexcept : m_start(Clock::now()) {}

    void reset(TimePoint point = Clock::now()) noexcept { m_start = point; }

    Dur elapsed() const noexcept {
        return std::chrono::duration_cast<Dur>(Clock::now() - m_start);
    }

    Dur lap() noexcept {
        auto now = Clock::now();
        auto ret = std::chrono::duration_cast<Dur>(now - m_start);
        reset(now);
        return ret;
    }

    template <typename Func, typename... Args>
    static Dur profile(Func &&func, Args&&... args) {
        Measure m;
        std::forward<Func>(func)(std::forward<Args>(args)...);
        return m.elapsed();
    }
private:
    TimePoint m_start;
};

struct Unit {
    static std::string human(const size_t bytes, const unsigned precision = 2,
                 const bool fixed = true) noexcept {
        static constexpr const std::string_view units[] {
            "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
        };
 
        auto unit = 0U;
        auto bytesD = static_cast<double>(bytes);
        while (bytesD >= 1024.) {
            bytesD /= 1024.;
            unit++;
        }
 
        std::ostringstream s;
        if (fixed)
            s << std::fixed << std::setprecision(precision);
        s << bytesD << ' ' << units[unit];
        return s.str();
    }
};
 
}