String.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <algorithm>
#include <charconv>
#include <cstring>
#include <cctype>
#include <functional>
#include <optional>
#include <ranges>
#include <string>
#include <vector>
 
namespace SlHelpers {

class GetLine {
public:
    GetLine(std::string_view str) noexcept : m_str(str) {}

    std::optional<std::string_view> get() noexcept {
        if (m_str.empty())
            return std::nullopt;
 
        const auto eol = m_str.find('\n');
        const auto last = eol == std::string_view::npos;
        auto line = last ? m_str : m_str.substr(0, eol);
 
        m_str.remove_prefix(last ? m_str.size() : eol + 1);
 
        return line;
    }
private:
    std::string_view m_str;
};

class String {
public:
    inline static constinit const auto npos = std::string_view::npos;
    static_assert(std::string_view::npos == std::string::npos);
 
    String() = delete;

    template <typename I = unsigned>
    requires std::is_integral_v<I>
    static std::optional<I> toNum(std::string_view str, int base = 10) noexcept
    {
        I num;
        if (std::from_chars(str.data(), str.data() + str.size(), num, base).ec != std::errc())
            return std::nullopt;
        return num;
    }

    static bool constexpr iEqual(unsigned char a, unsigned char b) noexcept {
        return std::tolower(a) == std::tolower(b);
    }

    static constexpr std::string_view::size_type
    iFind(std::string_view str, std::string_view sub) noexcept {
        if (str.empty() && sub.empty())
            return 0;
        const auto it = std::search(str.begin(), str.end(), sub.begin(), sub.end(), iEqual);
        if (it == str.end())
            return npos;
        return it - str.begin();
    }

    static constexpr bool
    iStartsWith(std::string_view str, std::string_view prefix) noexcept {
        if (str.size() < prefix.size())
            return false;
 
        return std::ranges::equal(str | std::views::take(prefix.size()), prefix, iEqual);
    }

    static constexpr bool
    iEndsWith(std::string_view str, std::string_view suffix) noexcept {
        if (str.size() < suffix.size())
            return false;
 
        return std::ranges::equal(str | std::views::drop(str.size() - suffix.size()),
                      suffix, iEqual);
    }

    static std::vector<std::string_view>
    splitSV(std::string_view str,
        std::string_view delim,
        std::optional<char> comment = std::nullopt) noexcept
    {
        std::vector<std::string_view> res;
        std::size_t end = 0;
 
        do {
            const auto start = str.find_first_not_of(delim, end);
            if (start == npos)
                break;
 
            end = str.find_first_of(delim, start);
            const auto len = (end == npos) ? (str.length() - start) : (end - start);
            auto token = str.substr(start, len);
            if (comment && token.starts_with(*comment))
                break;
 
            res.push_back(token);
        } while (end != npos);
 
        return res;
    }

    template <typename T>
    static constexpr T trim(const T &line) noexcept
    {
        constexpr const std::string_view spaces{" \n\t\r"};
        const auto pos1 = line.find_first_not_of(spaces);
        const auto pos2 = line.find_last_not_of(spaces);
 
        if (pos1 == npos)
            return {};
 
        return line.substr(pos1, pos2 - pos1 + 1);
    }

    static constexpr bool isHex(std::string_view s) noexcept {
        return std::all_of(s.cbegin(), s.cend(), ::isxdigit);
    }

    template <std::ranges::input_range Range, typename Output>
    requires requires(std::ostream &out, Output output,
              std::ranges::range_reference_t<Range> e) {
        std::invoke(output, out, e);
    }
    static void join(std::ostream &out, Range &&iterable, Output output,
             std::string_view sep = ", ") {
        bool first = true;
        for (auto &&e: iterable) {
            if (!first)
                out << sep;
            first = false;
 
            std::invoke(output, out, e);
        }
    }

    template <std::ranges::input_range Range>
    static void join(std::ostream &out, Range &&iterable, std::string_view sep = ", ",
             std::string_view quote = "") {
        join(out, std::forward<Range>(iterable),
             [quote](auto &out, const auto &x) { out << quote << x << quote; },
             sep);
    }

    struct Hash {
        using is_transparent = void;

        auto hash(std::string_view sv) const noexcept {
            return std::hash<std::string_view>{}(sv);
        }

        size_t operator()(const char *charp) const noexcept { return hash(charp); }

        size_t operator()(std::string_view sv) const noexcept { return hash(sv); }

        size_t operator()(const std::string &s) const noexcept { return hash(s); }
    };

    struct Eq {
        using is_transparent = void;

        bool operator()(std::string_view a, std::string_view b) const noexcept {
            return a == b;
        }
    };
};
 
}