string_utils.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cctype>
#include <format>
#include <ranges>
#include <regex>
#include <string>
 
#include "porytiles/utilities/dynamic_cased_name.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
[[nodiscard]] inline bool check_full_string_match(const std::string &str, const std::string &pattern)
{
    try {
        const std::regex re{pattern};
        return std::regex_match(str, re);
    }
    catch (const std::regex_error &e) {
        panic(std::string{"regex error: "} + std::string{e.what()});
    }
}
 
[[nodiscard]] inline std::string trim_prefix(const std::string &str, const std::string &prefix)
{
    if (str.starts_with(prefix)) {
        return str.substr(prefix.size());
    }
    return str;
}
 
inline void trim(std::string &string)
{
    // Trim blank space from the beginning
    string.erase(
        string.begin(), std::ranges::find_if(string, [](const unsigned char ch) { return !std::isspace(ch); }));
 
    // Trim blank space from the end
    string.erase(
        std::ranges::find_if(string.rbegin(), string.rend(), [](const unsigned char ch) { return !std::isspace(ch); })
            .base(),
        string.end());
}
 
[[nodiscard]] inline std::vector<std::string> split(std::string input, const std::string &delimiter)
{
    std::vector<std::string> result;
    size_t pos;
    while ((pos = input.find(delimiter)) != std::string::npos) {
        std::string token = input.substr(0, pos);
        result.push_back(token);
        input.erase(0, pos + delimiter.length());
    }
    result.push_back(input);
    return result;
}
 
[[nodiscard]] inline std::string &trim_line_ending(std::string &line)
{
    while (!line.empty() && (line.back() == '\r' || line.back() == '\n')) {
        line.pop_back();
    }
    return line;
}
 
[[nodiscard]] inline std::string trim_line_ending(const std::string &line)
{
    std::string result = line;
    while (!result.empty() && (result.back() == '\r' || result.back() == '\n')) {
        result.pop_back();
    }
    return result;
}
 
template <typename T>
[[nodiscard]] std::string int_to_hex_str(T t)
{
    return std::format("0x{:x}", t);
}
 
template <typename T>
[[nodiscard]] std::string pad_two_digits(T t)
{
    return std::format("{:02}", t);
}
 
[[nodiscard]] inline std::string to_string(const std::string &str)
{
    return str;
}
 
[[nodiscard]] inline std::string to_string(bool value)
{
    return value ? "true" : "false";
}
 
template <typename T>
[[nodiscard]] std::string to_string(const std::vector<T> &vec)
{
    std::string result = "{";
    for (std::size_t i = 0; i < vec.size(); ++i) {
        if (i > 0) {
            result += ", ";
        }
        result += to_string(vec[i]);
    }
    result += "}";
    return result;
}
 
[[nodiscard]] inline std::string to_pascal_case(const std::string &s)
{
    if (s.empty()) {
        return s;
    }
 
    std::string result;
    result.reserve(s.size());
 
    bool capitalize_next = true;
    for (const char c : s) {
        if (c == '_' || c == '-' || c == ' ') {
            capitalize_next = true;
        }
        else {
            if (capitalize_next) {
                result += static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
                capitalize_next = false;
            }
            else {
                result += c;
            }
        }
    }
 
    return result;
}
 
[[nodiscard]] inline std::string to_snake_case(const std::string &s)
{
    if (s.empty()) {
        return s;
    }
 
    std::string result;
    result.reserve(s.size() + s.size() / 4); // Reserve extra for underscores
 
    for (std::size_t i = 0; i < s.size(); ++i) {
        const char c = s[i];
 
        // Handle separators: convert to underscore
        if (c == '_' || c == '-' || c == ' ') {
            // Avoid leading underscore or consecutive underscores
            if (!result.empty() && result.back() != '_') {
                result += '_';
            }
            continue;
        }
 
        // Handle uppercase letters
        if (std::isupper(static_cast<unsigned char>(c))) {
            // Insert underscore before uppercase if:
            // 1. Not at the start
            // 2. Previous char wasn't an underscore
            // 3. Either previous char was lowercase, OR next char is lowercase (for acronyms like XMLParser)
            if (!result.empty() && result.back() != '_') {
                const bool prev_is_lower = i > 0 && std::islower(static_cast<unsigned char>(s[i - 1]));
                const bool next_is_lower = i + 1 < s.size() && std::islower(static_cast<unsigned char>(s[i + 1]));
                if (prev_is_lower || next_is_lower) {
                    result += '_';
                }
            }
            result += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
        }
        else {
            result += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
        }
    }
 
    // Remove trailing underscore if present
    if (!result.empty() && result.back() == '_') {
        result.pop_back();
    }
 
    return result;
}
 
[[nodiscard]] inline std::string to_lower_str(const std::string &input)
{
    std::string output;
    std::ranges::transform(input, std::back_inserter(output), [](const unsigned char c) {
        // Use unsigned char to avoid issues with negative char values
        return std::tolower(c);
    });
    return output;
}
 
[[nodiscard]] inline std::string pal_filename(std::size_t pal_index)
{
    return pad_two_digits(pal_index) + ".pal";
}
 
[[nodiscard]] inline std::string extract_tileset_shorthand(const std::string &tileset_name)
{
    constexpr std::string_view prefix = "gTileset_";
    if (tileset_name.starts_with(prefix)) {
        return tileset_name.substr(prefix.size());
    }
    return tileset_name;
}
 
[[nodiscard]] inline DynamicCasedName extract_tileset_cased_name(const std::string &tileset_name)
{
    return DynamicCasedName{extract_tileset_shorthand(tileset_name)};
}
 
} // namespace porytiles