StringUtilities.h

#pragma once
 
#include <xrpl/basics/Blob.h>
 
#include <boost/utility/string_view.hpp>
 
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
 
namespace xrpl {

std::string
sqlBlobLiteral(Blob const& blob);
 
namespace detail {
 
template <typename T>
concept SomeChar = std::same_as<std::remove_cvref_t<T>, int8_t> ||
    std::same_as<std::remove_cvref_t<T>, char> || std::same_as<std::remove_cvref_t<T>, uint8_t>;
 
inline constexpr std::array<std::optional<int>, 256> const kDigitLookupTable = []() {
    std::array<std::optional<int>, 256> t{};
 
    for (int i = 0; i < 10; ++i)
        t['0' + i] = i;
 
    for (int i = 0; i < 6; ++i)
    {
        t['A' + i] = 10 + i;
        t['a' + i] = 10 + i;
    }
 
    return t;
}();
 
inline std::optional<int>
hexCharToInt(SomeChar auto hexChar)
{
    return kDigitLookupTable[static_cast<uint8_t>(hexChar)];
}
 
}  // namespace detail
 
template <class Iterator>
std::optional<Blob>
strUnHex(std::size_t strSize, Iterator begin, Iterator end)
{
    Blob out;
 
    out.reserve((strSize + 1) / 2);
 
    auto iter = begin;
 
    if (strSize & 1)
    {
        auto const c = detail::hexCharToInt(*iter++);
        if (!c.has_value())
            return {};
 
        out.push_back(static_cast<unsigned char>(*c));
    }
 
    while (iter != end)
    {
        auto const cHigh = detail::hexCharToInt(*iter++);
 
        if (!cHigh.has_value())
            return {};
 
        auto const cLow = detail::hexCharToInt(*iter++);
 
        if (!cLow.has_value())
            return {};
 
        out.push_back(static_cast<unsigned char>((*cHigh << 4) | *cLow));
    }
 
    return {std::move(out)};
}
 
inline std::optional<Blob>
strUnHex(std::string_view strSrc)
{
    return strUnHex(strSrc.size(), strSrc.cbegin(), strSrc.cend());
}
 
struct ParsedUrl
{
    explicit ParsedUrl() = default;
 
    std::string scheme;
    std::string username;
    std::string password;
    std::string domain;
    std::optional<std::uint16_t> port;
    std::string path;
 
    bool
    operator==(ParsedUrl const& other) const
    {
        return scheme == other.scheme && domain == other.domain && port == other.port &&
            path == other.path;
    }
};
 
bool
parseUrl(ParsedUrl& pUrl, std::string const& strUrl);

std::string
trimWhitespace(std::string str);

std::string
toLower(std::string str);
 
std::optional<std::uint64_t>
toUInt64(std::string const& s);

bool
isProperlyFormedTomlDomain(std::string_view domain);

consteval bool
isNullTerminated(std::string_view str)
{
    if (str.data() == nullptr)
        return false;
 
    // Reading past the view is the point, so the usual data() warning does not
    // apply.
    // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
    return std::string_view{str.data()} == str;
}

class NullTerminatedView
{
public:
    explicit consteval NullTerminatedView(std::string_view view)
        : data_(view.data()), size_(view.size())
    {
        if (!isNullTerminated(view))
            throw "xrpl::NullTerminatedView : view does not reach a null";
    }
 
    constexpr
    operator std::string_view() const noexcept
    {
        return view();
    }

    [[nodiscard]] constexpr std::string_view
    view() const noexcept
    {
        return {data_, size_};
    }

    [[nodiscard]] constexpr char const*
    asCString() const noexcept
    {
        return data_;
    }
 
private:
    char const* data_;
    std::size_t size_;
};
 
}  // namespace xrpl