text.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <cstdarg>
#include <cstddef>
#include <cstring>
#include <filesystem>
#include <format>
#include <string>
#include <string.h>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include <rex/memory/endian.h>
#include <rex/platform.h>
#include <rex/types.h>
 
#if !REX_PLATFORM_WIN32
#include <strings.h>
#endif
 
namespace rex::string {

inline i32 CompareIgnoreCase(const char* string1, const char* string2) {
#if REX_PLATFORM_WIN32
  return _stricmp(string1, string2);
#else
  return strcasecmp(string1, string2);
#endif
}

inline i32 CompareIgnoreCaseN(const char* string1, const char* string2, size_t count) {
#if REX_PLATFORM_WIN32
  return _strnicmp(string1, string2, count);
#else
  return strncasecmp(string1, string2, count);
#endif
}
 
namespace detail {
 
template <typename CharT>
inline constexpr CharT kWhitespaceChars[] = {static_cast<CharT>(' '), static_cast<CharT>('\t'),
                                             static_cast<CharT>('\r'), static_cast<CharT>('\n')};
 
}  // namespace detail

template <typename CharT>
inline constexpr std::basic_string_view<CharT> kWhitespaceOf{detail::kWhitespaceChars<CharT>, 4};

inline constexpr std::string_view kWhitespace = kWhitespaceOf<char>;

template <typename CharT>
inline std::basic_string_view<CharT> TrimLeft(
    std::basic_string_view<CharT> sv, std::basic_string_view<CharT> chars = kWhitespaceOf<CharT>) {
  auto start = sv.find_first_not_of(chars);
  return start == std::basic_string_view<CharT>::npos ? std::basic_string_view<CharT>{}
                                                      : sv.substr(start);
}

template <typename CharT>
inline std::basic_string_view<CharT> TrimRight(
    std::basic_string_view<CharT> sv, std::basic_string_view<CharT> chars = kWhitespaceOf<CharT>) {
  auto end = sv.find_last_not_of(chars);
  return end == std::basic_string_view<CharT>::npos ? std::basic_string_view<CharT>{}
                                                    : sv.substr(0, end + 1);
}

template <typename CharT>
inline std::basic_string_view<CharT> Trim(
    std::basic_string_view<CharT> sv, std::basic_string_view<CharT> chars = kWhitespaceOf<CharT>) {
  return TrimRight(TrimLeft(sv, chars), chars);
}

inline std::string_view TrimLeft(std::string_view sv, std::string_view chars = kWhitespace) {
  return TrimLeft<char>(sv, chars);
}

inline std::string_view TrimRight(std::string_view sv, std::string_view chars = kWhitespace) {
  return TrimRight<char>(sv, chars);
}

inline std::string_view Trim(std::string_view sv, std::string_view chars = kWhitespace) {
  return Trim<char>(sv, chars);
}

inline std::string TrimString(std::string_view sv, std::string_view chars = kWhitespace) {
  return std::string(Trim(sv, chars));
}

inline char* Duplicate(const char* source) {
#if REX_PLATFORM_WIN32
  return _strdup(source);
#else
  return strdup(source);
#endif
}

inline size_t CopyTruncating(char* dest, const std::string_view source, size_t dest_buffer_count) {
  if (!dest_buffer_count) {
    return 0;
  }
  size_t chars_copied = std::min(source.size(), dest_buffer_count - static_cast<size_t>(1));
  std::memcpy(dest, source.data(), chars_copied);
  dest[chars_copied] = '\0';
  return chars_copied;
}

inline size_t CopyTruncating(char16_t* dest, const std::u16string_view source,
                             size_t dest_buffer_count) {
  if (!dest_buffer_count) {
    return 0;
  }
  size_t chars_copied = std::min(source.size(), dest_buffer_count - static_cast<size_t>(1));
  std::memcpy(dest, source.data(), chars_copied * sizeof(char16_t));
  dest[chars_copied] = u'\0';
  return chars_copied;
}

inline size_t CopyAndSwapTruncating(char16_t* dest, const std::u16string_view source,
                                    size_t dest_buffer_count) {
  if (!dest_buffer_count) {
    return 0;
  }
  size_t chars_copied = std::min(source.size(), dest_buffer_count - static_cast<size_t>(1));
  const std::u16string_view head = source.substr(0, chars_copied);
  memory::copy_and_swap(dest, head.data(), head.size());
  dest[chars_copied] = u'\0';
  return chars_copied;
}

inline size_t CopyUnterminated(char* dest, const std::string_view source,
                               size_t dest_buffer_count) {
  if (!dest_buffer_count) {
    return 0;
  }
  size_t chars_copied = std::min(source.size(), dest_buffer_count);
  std::memcpy(dest, source.data(), chars_copied);
  return chars_copied;
}

REX_API std::string utf8_lower_ascii(const std::string_view view);

REX_API std::string utf8_upper_ascii(const std::string_view view);

REX_API size_t utf8_hash_fnv1a(const std::string_view view);

REX_API size_t utf8_hash_fnv1a_case(const std::string_view view);

REX_API std::vector<std::string_view> utf8_split(const std::string_view haystack,
                                                 const std::string_view needles,
                                                 bool remove_empty = false);

REX_API bool utf8_equal_z(const std::string_view left, const std::string_view right);
 
REX_API bool utf8_equal_case(const std::string_view left, const std::string_view right);

REX_API bool utf8_equal_case_z(const std::string_view left, const std::string_view right);

REX_API std::string_view::size_type utf8_find_any_of(const std::string_view haystack,
                                                     const std::string_view needles);

REX_API std::string_view::size_type utf8_find_any_of_case(const std::string_view haystack,
                                                          const std::string_view needles);

REX_API std::string_view::size_type utf8_find_first_of(const std::string_view haystack,
                                                       const std::string_view needle);

REX_API std::string_view::size_type utf8_find_first_of_case(const std::string_view haystack,
                                                            const std::string_view needle);

REX_API bool utf8_starts_with(const std::string_view haystack, const std::string_view needle);

REX_API bool utf8_starts_with_case(const std::string_view haystack, const std::string_view needle);

REX_API bool utf8_ends_with(const std::string_view haystack, const std::string_view needle);

REX_API bool utf8_ends_with_case(const std::string_view haystack, const std::string_view needle);

REX_API std::string ToUTF8(const std::u16string_view source);

REX_API std::u16string ToUTF16(const std::string_view source);

REX_API std::wstring ToWideString(const std::string_view source);

REX_API std::string ToUTF8(const std::wstring_view source);

REX_API std::string ShiftJISToUTF8(const std::string_view source);

REX_API std::string UTF8ToShiftJIS(const std::string_view source);

REX_API std::string PathToUTF8(const std::filesystem::path& path);

REX_API std::u16string PathToUTF16(const std::filesystem::path& path);

REX_API std::filesystem::path to_path(const std::string_view source);

REX_API std::filesystem::path to_path(const std::u16string_view source);

REX_API size_t utf8_count(const std::string_view view);

class REX_API StringBuffer {
 public:
  explicit StringBuffer(size_t initial_capacity = 0);
  ~StringBuffer();

  char* GetBuffer() const { return buffer_; }

  size_t GetLength() const { return length_; }

  void Reset();
 
  void Append(char c);

  void Append(char c, size_t count);
 
  void Append(const char* value);
 
  void Append(const std::string_view value);

  template <typename... Args>
  void AppendFormat(std::format_string<const Args&...> format, const Args&... args) {
    Append(std::format(format, args...));
  }

  void AppendVarargs(const char* format, va_list args);
 
  void AppendBytes(const u8* buffer, size_t length);
 
  std::string ToString();

  std::string_view ToStringView() const;

  std::vector<u8> ToBytes() const;
 
 private:
  void Grow(size_t additional_length);
 
  char* buffer_ = nullptr;
  size_t length_ = 0;
  size_t buffer_capacity_ = 0;
};
 
namespace detail {
 
struct StringKeyBase {
 private:
  std::variant<std::string, std::string_view> value_;
 
 public:
  explicit StringKeyBase(const std::string_view value) : value_(value) {}
  explicit StringKeyBase(std::string value) : value_(std::move(value)) {}
 
  std::string_view GetView() const {
    if (const auto* owned = std::get_if<std::string>(&value_)) {
      return *owned;
    }
    const auto* borrowed = std::get_if<std::string_view>(&value_);
    return borrowed ? *borrowed : std::string_view();
  }
};
 
}  // namespace detail

struct StringKey : detail::StringKeyBase {
 public:
  explicit StringKey(const std::string_view value) : StringKeyBase(value) {}

  explicit StringKey(std::string value) : StringKeyBase(std::move(value)) {}

  static StringKey Create(const std::string_view value) { return StringKey(std::string(value)); }

  static StringKey Create(std::string value) { return StringKey(std::move(value)); }

  bool operator==(const StringKey& other) const { return other.GetView() == GetView(); }

  size_t hash() const { return rex::string::utf8_hash_fnv1a(GetView()); }
 
  struct Hash {
    size_t operator()(const StringKey& t) const { return t.hash(); }
  };
};

struct StringKeyIgnoreCase : detail::StringKeyBase {
 public:
  explicit StringKeyIgnoreCase(const std::string_view value) : StringKeyBase(value) {}

  explicit StringKeyIgnoreCase(std::string value) : StringKeyBase(std::move(value)) {}

  static StringKeyIgnoreCase Create(const std::string_view value) {
    return StringKeyIgnoreCase(std::string(value));
  }

  static StringKeyIgnoreCase Create(std::string value) {
    return StringKeyIgnoreCase(std::move(value));
  }

  bool operator==(const StringKeyIgnoreCase& other) const {
    return rex::string::utf8_equal_case(other.GetView(), GetView());
  }

  size_t hash() const { return rex::string::utf8_hash_fnv1a_case(GetView()); }
 
  struct Hash {
    size_t operator()(const StringKeyIgnoreCase& t) const { return t.hash(); }
  };
};
 
}  // namespace rex::string
 
namespace std {
template <>
struct hash<rex::string::StringKey> {
  std::size_t operator()(const rex::string::StringKey& t) const { return t.hash(); }
};
 
template <>
struct hash<rex::string::StringKeyIgnoreCase> {
  std::size_t operator()(const rex::string::StringKeyIgnoreCase& t) const { return t.hash(); }
};
}  // namespace std