string.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef CPP_TOOLBOX_CONTAINER_STRING_HPP
#  define CPP_TOOLBOX_CONTAINER_STRING_HPP
 
#  include <limits>
#  include <stdexcept>
#  include <string>
#  include <string_view>
#  include <vector>
 
#  include <cpp-toolbox/core/export.hpp>
 
namespace toolbox::container::string
{
CPP_TOOLBOX_EXPORT auto split(std::string_view str, std::string_view delimiter)
    -> std::vector<std::string>;
 
CPP_TOOLBOX_EXPORT auto split(std::string_view str, char delimiter)
    -> std::vector<std::string>;
 
CPP_TOOLBOX_EXPORT auto join(const std::vector<std::string>& parts,
                             std::string_view glue) -> std::string;
 
CPP_TOOLBOX_EXPORT auto join(const std::vector<std::string_view>& parts,
                             std::string_view glue) -> std::string;
 
CPP_TOOLBOX_EXPORT auto trim_left(std::string_view str) -> std::string;
 
CPP_TOOLBOX_EXPORT auto trim_right(std::string_view str) -> std::string;
 
CPP_TOOLBOX_EXPORT auto trim(std::string_view str) -> std::string;
 
CPP_TOOLBOX_EXPORT auto starts_with(std::string_view s, std::string_view prefix)
    -> bool;
 
CPP_TOOLBOX_EXPORT auto ends_with(std::string_view s, std::string_view suffix)
    -> bool;
 
CPP_TOOLBOX_EXPORT auto contains(std::string_view s, std::string_view substring)
    -> bool;
 
CPP_TOOLBOX_EXPORT auto is_empty_or_whitespace(std::string_view s) -> bool;
 
CPP_TOOLBOX_EXPORT auto is_numeric(std::string_view s) -> bool;
 
CPP_TOOLBOX_EXPORT auto is_integer(std::string_view s) -> bool;
 
CPP_TOOLBOX_EXPORT auto is_float(std::string_view s) -> bool;
 
CPP_TOOLBOX_EXPORT auto replace(
    std::string_view s,
    std::string_view old_value,
    std::string_view new_value,
    std::size_t count = std::numeric_limits<std::size_t>::max()) -> std::string;
 
CPP_TOOLBOX_EXPORT auto replace_all(std::string_view s,
                                    std::string_view old_value,
                                    std::string_view new_value) -> std::string;
 
CPP_TOOLBOX_EXPORT auto replace_by_nth(std::string_view s,
                                       std::string_view old_value,
                                       std::string_view new_value,
                                       std::size_t n) -> std::string;
 
CPP_TOOLBOX_EXPORT auto remove_nth(std::string_view s,
                                   std::string_view from,
                                   std::size_t n) -> std::string;
 
CPP_TOOLBOX_EXPORT auto remove(
    std::string_view s,
    std::string_view value,
    std::size_t count = std::numeric_limits<std::size_t>::max()) -> std::string;
 
CPP_TOOLBOX_EXPORT auto remove_all(std::string_view s, std::string_view value)
    -> std::string;
 
CPP_TOOLBOX_EXPORT auto remove_all(std::string_view s, char value)
    -> std::string;
 
CPP_TOOLBOX_EXPORT auto to_lower(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto to_upper(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto to_string(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto left_pad(std::string_view s,
                                 std::size_t width,
                                 char pad_char = ' ') -> std::string;
 
CPP_TOOLBOX_EXPORT auto right_pad(std::string_view s,
                                  std::size_t width,
                                  char pad_char = ' ') -> std::string;
 
CPP_TOOLBOX_EXPORT auto pad(std::string_view s,
                            std::size_t width,
                            char pad_char = ' ',
                            std::size_t position = 0) -> std::string;
 
CPP_TOOLBOX_EXPORT auto reverse(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto try_parse_int(std::string_view s, int& out) -> bool;
 
CPP_TOOLBOX_EXPORT auto try_parse_double(std::string_view s, double& out)
    -> bool;
 
CPP_TOOLBOX_EXPORT auto try_parse_float(std::string_view s, float& out) -> bool;
 
CPP_TOOLBOX_EXPORT auto levenshtein_distance(std::string_view s1,
                                             std::string_view s2)
    -> std::size_t;
 
CPP_TOOLBOX_EXPORT auto longest_common_subsequence_length(std::string_view s1,
                                                          std::string_view s2)
    -> std::size_t;
 
CPP_TOOLBOX_EXPORT auto longest_common_substring_length(std::string_view s1,
                                                        std::string_view s2)
    -> std::size_t;
 
CPP_TOOLBOX_EXPORT auto url_encode(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto url_decode(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto base64_encode(std::string_view data) -> std::string;
 
CPP_TOOLBOX_EXPORT auto base64_decode(std::string_view encoded_data)
    -> std::string;
 
CPP_TOOLBOX_EXPORT auto slugify(std::string_view s) -> std::string;
 
CPP_TOOLBOX_EXPORT auto hexview(const char* data,
                                std::size_t size,
                                bool with_prefix = true) -> std::string;
 
CPP_TOOLBOX_EXPORT auto hexview(const std::string& data,
                                bool with_prefix = true) -> std::string;
 
CPP_TOOLBOX_EXPORT auto hexview(const std::vector<char>& data,
                                bool with_prefix = true) -> std::string;
 
CPP_TOOLBOX_EXPORT auto hexview(const std::vector<std::byte>& data,
                                bool with_prefix = true) -> std::string;
 
template<typename T>
auto hex_to_integral(const std::string& hex_str, bool with_prefix = true) -> T
{
  static_assert(std::is_integral_v<T>,
                "T 必须是整型/T must be an integral type");
  std::string_view s(hex_str);
  // 跳过可选的 "0x" 或 "0X" 前缀/Skip optional "0x" or "0X" prefix
  if (with_prefix && s.size() >= 2 && s[0] == '0'
      && (s[1] == 'x' || s[1] == 'X'))
  {
    s.remove_prefix(2);
  }
  if (s.empty()) {  // Simplified empty check after prefix removal
    throw std::invalid_argument(
        "非法的十六进制字符串: 空字符串或只有前缀/Invalid hex string: empty or "
        "only prefix");
  }
  // 十六进制字符串长度必须是偶数，除非它是单个 '0' / Hex string length must be
  // even, unless it's a single '0'
  if (s.size() % 2 != 0 && s != "0") {  // 允许单个 "0" / Allow single "0"
    throw std::invalid_argument(
        "非法的十六进制字符串长度 (必须是偶数，除非是'0')/Invalid hex string "
        "length (must be even, unless it's '0')");
  }
 
  // 使用 std::stoull 自动处理 base 参数/Use std::stoull to handle base
  // parameter automatically
  size_t pos = 0;  // To check how many characters were consumed
  unsigned long long tmp = 0;
  try {
    tmp = std::stoull(std::string(s), &pos, 16);
  } catch (const std::invalid_argument& e) {
    // Re-throw with a potentially more informative message if needed, or just
    // let it propagate
    throw std::invalid_argument("非法的十六进制字符/Invalid hex character(s)");
  } catch (const std::out_of_range& e) {
    // Let std::out_of_range propagate
    throw;
  }
 
  // 检查是否所有字符都被消耗/Check if all characters were consumed
  if (pos != s.length()) {
    throw std::invalid_argument(
        "包含非法十六进制字符或尾随字符/Contains invalid hex or trailing "
        "characters");
  }
 
  // Check for potential overflow when casting back to T (stoull checks against
  // ULLONG_MAX) This is a bit tricky, especially for signed types. A simple
  // check for unsigned types:
  if constexpr (std::is_unsigned_v<T>) {
    if (tmp > static_cast<unsigned long long>(std::numeric_limits<T>::max())) {
      throw std::out_of_range(
          "值超出目标类型范围/Value out of range for target type");
    }
  } else {  // For signed types
    // This comparison logic needs careful consideration of T's range
    // For simplicity, we might rely on the static_cast behavior or add more
    // complex checks if needed. E.g., check if tmp fits within both min and max
    // of T if (tmp > static_cast<unsigned long
    // long>(std::numeric_limits<T>::max()) &&
    //     (tmp > -static_cast<long long>(std::numeric_limits<T>::min()) ) ) {
    //     ... }
    // Simpler check: If the original string wasn't negative and result is >
    // max, it's overflow
    if (tmp > static_cast<unsigned long long>(std::numeric_limits<T>::max())) {
      // Check if it could represent a negative number within range if T is
      // signed This might require more robust two's complement handling
      // depending on exact needs. For now, let's assume stoull parsed correctly
      // and cast might overflow. A safer approach might involve parsing
      // differently for signed types. Let's keep the basic check for now.
      if (tmp > static_cast<unsigned long long>(std::numeric_limits<T>::max()))
      {
        throw std::out_of_range(
            "值超出目标类型范围/Value out of range for target type");
      }
    }
  }
 
  return static_cast<T>(tmp);
}
 
template<typename Container>
auto hex_to_bytes(const std::string& hex_str, bool with_prefix = true)
    -> Container
{
  using Byte = typename Container::value_type;
  std::string_view s(hex_str);
  if (with_prefix && s.size() >= 2 && s[0] == '0'
      && (s[1] == 'x' || s[1] == 'X'))
  {
    s.remove_prefix(2);
  }
  if (s.size() % 2 != 0) {
    throw std::invalid_argument(
        "十六进制字符串长度必须是偶数/Hex string length must be even");
  }
  Container output;
  output.clear();
  output.reserve(s.size() / 2);
  for (size_t i = 0; i < s.size(); i += 2) {
    auto hi = s[i];
    auto lo = s[i + 1];
    if (!std::isxdigit(hi) || !std::isxdigit(lo)) {
      throw std::invalid_argument(
          "包含非法十六进制字符/Contains invalid hex characters");
    }
    Byte byte = static_cast<Byte>(
        ((std::isdigit(hi) ? hi - '0' : std::toupper(hi) - 'A' + 10) * 16)
        + (std::isdigit(lo) ? lo - '0' : std::toupper(lo) - 'A' + 10));
    output.push_back(byte);
  }
  return output;
}
 
}  // namespace toolbox::container::string
#endif  // CPP_TOOLBOX_CONTAINER_STRING_HPP