Strings.cpp

Go to the documentation of this file.

#include <VoltMod/Core/Text/Strings.hpp>
#include <algorithm>
#include <cctype>
#include <charconv>
#include <cstring>
#include <limits>
#include <sstream>
#include <string_view>
 
namespace VoltMod
{
 
std::optional<int64_t> ParseInt64(std::string_view text)
{
    int64_t value{};
    auto [ptr, ec] = std::from_chars(text.data(), text.data() + text.size(), value);
    if (ec != std::errc{} || ptr != text.data() + text.size())
    {
        return std::nullopt;
    }
    return value;
}
 
std::optional<uint64_t> ParseUInt64(std::string_view text)
{
    uint64_t value{};
    auto [ptr, ec] = std::from_chars(text.data(), text.data() + text.size(), value);
    if (ec != std::errc{} || ptr != text.data() + text.size())
    {
        return std::nullopt;
    }
    return value;
}
 
int ParseDuration(std::string_view text)
{
    while (!text.empty() && std::isspace(static_cast<unsigned char>(text.front())))
    {
        text.remove_prefix(1);
    }
    while (!text.empty() && std::isspace(static_cast<unsigned char>(text.back())))
    {
        text.remove_suffix(1);
    }
 
    if (text.empty())
    {
        return -1;
    }
 
    std::string lower(text);
    std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c) { return std::tolower(c); });
    if (lower == "0" || lower == "perm" || lower == "permanent")
    {
        return 0;
    }
 
    int64_t multiplier = 1;
    char suffix = lower.back();
    if (!std::isdigit(static_cast<unsigned char>(suffix)))
    {
        switch (suffix)
        {
        case 's':
            multiplier = 1;
            break;
        case 'm':
            multiplier = 60;
            break;
        case 'h':
            multiplier = 3600;
            break;
        case 'd':
            multiplier = 86400;
            break;
        case 'w':
            multiplier = 604800;
            break;
        default:
            return -1;
        }
        lower.pop_back();
    }
 
    int value = 0;
    auto [ptr, ec] = std::from_chars(lower.data(), lower.data() + lower.size(), value);
    if (ec != std::errc{} || ptr != lower.data() + lower.size() || value < 0)
    {
        return -1;
    }
 
    int64_t total = static_cast<int64_t>(value) * multiplier;
    if (total > std::numeric_limits<int>::max())
    {
        return -1;
    }
    return static_cast<int>(total);
}
 
std::string Strings::ToLower(std::string_view str)
{
    std::string result(str);
    std::transform(result.begin(), result.end(), result.begin(), [](unsigned char c) { return std::tolower(c); });
    return result;
}
 
std::string Strings::Trim(std::string_view str)
{
    auto begin = std::find_if(str.begin(), str.end(), [](unsigned char c) { return !std::isspace(c); });
    auto end = std::find_if(str.rbegin(), str.rend(), [](unsigned char c) { return !std::isspace(c); }).base();
    return begin < end ? std::string(begin, end) : std::string();
}
 
std::string Strings::Join(const std::vector<std::string>& parts, std::string_view delimiter)
{
    if (parts.empty())
    {
        return "";
    }
 
    std::string result = parts[0];
    for (size_t i = 1; i < parts.size(); ++i)
    {
        result += delimiter;
        result += parts[i];
    }
    return result;
}
 
std::string Strings::JoinNonEmpty(const std::vector<std::string>& parts, std::string_view delimiter)
{
    std::string result;
    for (const auto& part : parts)
    {
        if (part.empty())
        {
            continue;
        }
        if (!result.empty())
        {
            result += delimiter;
        }
        result += part;
    }
    return result;
}
 
bool Strings::StartsWith(std::string_view str, std::string_view prefix)
{
    return str.starts_with(prefix);
}
 
bool Strings::ContainsIgnoreCase(std::string_view str, std::string_view substr)
{
    return ToLower(str).find(ToLower(substr)) != std::string::npos;
}
 
// SubstituteTokens is the only caller; not public API.
static std::string ReplaceAll(const std::string& str, const std::string& from, const std::string& to)
{
    if (from.empty())
    {
        return str;
    }
 
    std::string result = str;
    size_t pos = 0;
    while ((pos = result.find(from, pos)) != std::string::npos)
    {
        result.replace(pos, from.length(), to);
        pos += to.length();
    }
    return result;
}
 
std::string Strings::SubstituteTokens(std::string text, const Tokens& tokens)
{
    for (const auto& [key, value] : tokens)
    {
        text = ReplaceAll(text, "{" + key + "}", value);
    }
    return text;
}
 
std::string Strings::EscapeHtml(std::string_view text)
{
    std::string out;
    out.reserve(text.size());
    for (char c : text)
    {
        switch (c)
        {
        case '&':
            out += "&amp;";
            break;
        case '<':
            out += "&lt;";
            break;
        case '>':
            out += "&gt;";
            break;
        case '"':
            out += "&quot;";
            break;
        case '\'':
            out += "&#39;";
            break;
        default:
            out += c;
            break;
        }
    }
    return out;
}
 
std::string Strings::QuoteConsoleArg(std::string_view value)
{
    std::string out;
    out.reserve(value.size() + 2);
    out += '"';
    for (char c : value)
    {
        if (c == '"' || c == '\\')
        {
            out += '\\';
        }
        out += c;
    }
    out += '"';
    return out;
}
 
std::string Strings::TruncateUtf8(std::string_view text, std::size_t maxBytes, std::string_view ellipsis)
{
    if (text.size() <= maxBytes)
    {
        return std::string(text);
    }
    std::size_t end = maxBytes;
    // Back up past UTF-8 continuation bytes so the cut never splits a multibyte sequence.
    while (end > 0 && (static_cast<unsigned char>(text[end]) & 0xC0) == 0x80)
    {
        --end;
    }
    return std::string(text.substr(0, end)).append(ellipsis);
}
 
bool Strings::IsNumeric(std::string_view str)
{
    if (str.empty())
    {
        return false;
    }
    return std::all_of(str.begin(), str.end(), [](unsigned char c) { return std::isdigit(c); });
}
 
void Strings::CopyToBuffer(char* buffer, std::size_t size, std::string_view text) noexcept
{
    if (buffer == nullptr || size == 0)
    {
        return;
    }
 
    const std::size_t length = std::min(size - 1, text.size());
    std::memcpy(buffer, text.data(), length);
    buffer[length] = '\0';
}
 
std::string Strings::DisplayNameOr(int64_t id, std::string_view name, std::size_t maxBytes)
{
    // A name is player-controlled and this is row markup, so it is escaped here rather than at
    // each call site: an unescaped '<' would let a player close the row's font tag.
    return name.empty() ? std::to_string(id) : EscapeHtml(TruncateUtf8(name, maxBytes));
}
 
}  // namespace VoltMod