text.h

#ifndef SOURCEMETA_CORE_TEXT_H_
#define SOURCEMETA_CORE_TEXT_H_
 
#ifndef SOURCEMETA_CORE_TEXT_EXPORT
#include <sourcemeta/core/text_export.h>
#endif
 
#include <algorithm>   // std::max
#include <array>       // std::array
#include <charconv>    // std::to_chars
#include <concepts>    // std::same_as, std::integral
#include <cstddef>     // std::size_t
#include <cstdint>     // std::int8_t, std::uint64_t
#include <filesystem>  // std::filesystem::path
#include <ios>         // std::streamsize
#include <limits>      // std::numeric_limits
#include <optional>    // std::optional
#include <ostream>     // std::ostream
#include <string>      // std::string
#include <string_view> // std::string_view
#include <type_traits> // std::is_nothrow_copy_constructible_v, std::is_nothrow_invocable_r_v, std::remove_cv_t
#include <utility>     // std::pair
#include <vector>      // std::vector

 
namespace sourcemeta::core {

SOURCEMETA_CORE_TEXT_EXPORT
auto to_title_case(std::string &value) -> void;

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto to_lowercase(const Character character) noexcept -> Character {
  return (character >= 'A' && character <= 'Z')
             ? static_cast<Character>(character + ('a' - 'A'))
             : character;
}

template <typename Character, typename Traits, typename Allocator>
  requires requires(Character character) {
    { to_lowercase(character) } -> std::same_as<Character>;
  }
inline auto to_lowercase(std::basic_string<Character, Traits, Allocator> &value)
    -> void {
  for (auto &character : value) {
    character = to_lowercase(character);
  }
}

SOURCEMETA_CORE_TEXT_EXPORT
auto to_lowercase(std::filesystem::path &value) -> void;

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto is_lowercase(const Character character) noexcept -> bool {
  return character < 'A' || character > 'Z';
}

template <typename String>
  requires requires(const String &value) {
    { is_lowercase(*value.begin()) } -> std::same_as<bool>;
  }
inline auto is_lowercase(const String &value) noexcept -> bool {
  for (const auto character : value) {
    if (!is_lowercase(character)) {
      return false;
    }
  }
  return true;
}

SOURCEMETA_CORE_TEXT_EXPORT
auto is_lowercase(const std::filesystem::path &value) noexcept -> bool;

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto is_alpha(const Character character) noexcept -> bool {
  return (character >= 'a' && character <= 'z') ||
         (character >= 'A' && character <= 'Z');
}

constexpr auto is_alpha(const std::string_view value) noexcept -> bool {
  if (value.empty()) {
    return false;
  }
  for (const auto character : value) {
    if (!is_alpha(character)) {
      return false;
    }
  }
  return true;
}

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto is_digit(const Character character) noexcept -> bool {
  return character >= '0' && character <= '9';
}

constexpr auto is_digit(const std::string_view value) noexcept -> bool {
  if (value.empty()) {
    return false;
  }
  for (const auto character : value) {
    if (!is_digit(character)) {
      return false;
    }
  }
  return true;
}

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto is_alphanum(const Character character) noexcept -> bool {
  return is_alpha(character) || is_digit(character);
}

constexpr auto is_alphanum(const std::string_view value) noexcept -> bool {
  if (value.empty()) {
    return false;
  }
  for (const auto character : value) {
    if (!is_alphanum(character)) {
      return false;
    }
  }
  return true;
}

template <typename Character>
  requires std::same_as<Character, char> ||
           std::same_as<Character, signed char> ||
           std::same_as<Character, unsigned char> ||
           std::same_as<Character, wchar_t>
constexpr auto is_punctuation(const Character character) noexcept -> bool {
  return (character >= '!' && character <= '/') ||
         (character >= ':' && character <= '@') ||
         (character >= '[' && character <= '`') ||
         (character >= '{' && character <= '~');
}

SOURCEMETA_CORE_TEXT_EXPORT
auto truncate(std::string &input, const std::size_t maximum_length,
              const std::string_view marker) -> void;

SOURCEMETA_CORE_TEXT_EXPORT
auto replace(const std::string_view input, const std::string_view target,
             const std::string_view replacement) -> std::string;

SOURCEMETA_CORE_TEXT_EXPORT
auto trim(const std::string_view input) noexcept -> std::string_view;

SOURCEMETA_CORE_TEXT_EXPORT
auto strip_left(const std::string_view input, const char character) noexcept
    -> std::string_view;

SOURCEMETA_CORE_TEXT_EXPORT
auto strip_right(const std::string_view input, const char character) noexcept
    -> std::string_view;

template <typename Predicate>
  requires std::predicate<Predicate &, char>
constexpr auto
strip_left(const std::string_view input, Predicate predicate) noexcept(
    std::is_nothrow_invocable_r_v<bool, Predicate &, char> &&
    std::is_nothrow_copy_constructible_v<Predicate>) -> std::string_view {
  std::string_view result{input};
  while (!result.empty() && predicate(result.front())) {
    result.remove_prefix(1);
  }
 
  return result;
}

template <typename Predicate>
  requires std::predicate<Predicate &, char>
constexpr auto
strip_right(const std::string_view input, Predicate predicate) noexcept(
    std::is_nothrow_invocable_r_v<bool, Predicate &, char> &&
    std::is_nothrow_copy_constructible_v<Predicate>) -> std::string_view {
  std::string_view result{input};
  while (!result.empty() && predicate(result.back())) {
    result.remove_suffix(1);
  }
 
  return result;
}

template <typename Predicate>
  requires std::predicate<Predicate &, char>
constexpr auto trim(const std::string_view input, Predicate predicate) noexcept(
    std::is_nothrow_invocable_r_v<bool, Predicate &, char> &&
    std::is_nothrow_copy_constructible_v<Predicate>) -> std::string_view {
  return strip_right(strip_left(input, predicate), predicate);
}

constexpr auto unquote(const std::string_view input, const char quote) noexcept
    -> std::string_view {
  if (input.size() < 2 || input.front() != quote || input.back() != quote) {
    return input;
  }
 
  auto inner{input};
  inner.remove_prefix(1);
  inner.remove_suffix(1);
  return inner;
}

SOURCEMETA_CORE_TEXT_EXPORT
auto pad_left(const std::string_view input, const std::size_t width,
              const char character) -> std::string;

SOURCEMETA_CORE_TEXT_EXPORT
auto take_until(const std::string_view input, const char marker) noexcept
    -> std::string_view;

SOURCEMETA_CORE_TEXT_EXPORT
auto split_once(const std::string_view input, const char delimiter) noexcept
    -> std::optional<std::pair<std::string_view, std::string_view>>;

SOURCEMETA_CORE_TEXT_EXPORT
auto split_once(const std::string_view input,
                const std::string_view delimiter) noexcept
    -> std::optional<std::pair<std::string_view, std::string_view>>;

SOURCEMETA_CORE_TEXT_EXPORT
auto rsplit_once(const std::string_view input, const char delimiter) noexcept
    -> std::optional<std::pair<std::string_view, std::string_view>>;

template <typename Callback>
auto split(const std::string_view input, const char delimiter,
           Callback callback) -> void {
  std::string_view rest{input};
  while (true) {
    const auto next{sourcemeta::core::split_once(rest, delimiter)};
    if (!next.has_value()) {
      callback(rest);
      return;
    }
    callback(next->first);
    rest = next->second;
  }
}

inline auto split(const std::string_view input, const char delimiter)
    -> std::vector<std::string_view> {
  std::vector<std::string_view> parts;
  sourcemeta::core::split(
      input, delimiter,
      [&parts](const std::string_view part) -> void { parts.push_back(part); });
  return parts;
}

template <typename Range>
auto join(const Range &items, const std::string_view separator) -> std::string {
  std::string result;
  bool first{true};
  for (const auto &item : items) {
    if (!first) {
      result.append(separator);
    }
 
    result.append(item);
    first = false;
  }
 
  return result;
}

template <typename Range>
auto join_to(std::ostream &stream, const Range &items,
             const std::string_view separator) -> void {
  bool first{true};
  for (const auto &item : items) {
    if (!first) {
      stream << separator;
    }
    stream << item;
    first = false;
  }
}

template <typename Type>
concept text_spellable_integer =
    std::integral<Type> && !std::same_as<std::remove_cv_t<Type>, bool> &&
    sizeof(Type) <= sizeof(std::uint64_t);

template <typename Integer>
  requires text_spellable_integer<Integer>
inline constexpr std::size_t DIGITS_CAPACITY{
    static_cast<std::size_t>(std::numeric_limits<Integer>::digits10) + 1 +
    (std::numeric_limits<Integer>::is_signed ? 1U : 0U)};

using DigitsBuffer = std::array<char, std::max(DIGITS_CAPACITY<std::uint64_t>,
                                               DIGITS_CAPACITY<std::int64_t>)>;

template <typename Integer, std::size_t Capacity>
  requires text_spellable_integer<Integer> &&
           (Capacity >= DIGITS_CAPACITY<Integer>)
inline auto digits_view(const Integer value,
                        std::array<char, Capacity> &buffer) noexcept
    -> std::string_view {
  const auto result{
      std::to_chars(buffer.data(), buffer.data() + buffer.size(), value)};
  return {buffer.data(), static_cast<std::size_t>(result.ptr - buffer.data())};
}

template <typename Output, typename Integer>
  requires text_spellable_integer<Integer>
inline auto digits_append(Output &output, const Integer value) -> void {
  std::array<char, DIGITS_CAPACITY<Integer>> buffer;
  const auto digits{digits_view(value, buffer)};
  output.append(digits.data(), digits.size());
}

template <typename CharT, typename Traits, typename Integer>
  requires text_spellable_integer<Integer>
inline auto digits_write(std::basic_ostream<CharT, Traits> &stream,
                         const Integer value) -> void {
  std::array<char, DIGITS_CAPACITY<Integer>> buffer;
  const auto digits{digits_view(value, buffer)};
  stream.write(digits.data(), static_cast<std::streamsize>(digits.size()));
}

inline auto hex_digit_value(const char character) noexcept -> std::int8_t {
  // Indexed by byte value: ASCII '0'-'9', 'A'-'F', and 'a'-'f' map to their
  // hexadecimal value, everything else to -1
  static constexpr std::array<std::int8_t, 256> TABLE{
      {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,
       6,  7,  8,  9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
       -1, -1, -1, -1}};
  return TABLE[static_cast<unsigned char>(character)];
}

inline auto is_hex_digit(const char character) noexcept -> bool {
  return hex_digit_value(character) >= 0;
}

inline auto is_percent_triplet(const std::string_view input,
                               const std::size_t position) noexcept -> bool {
  return input.size() >= 3 && position < input.size() - 2 &&
         input[position] == '%' && is_hex_digit(input[position + 1]) &&
         is_hex_digit(input[position + 2]);
}

SOURCEMETA_CORE_TEXT_EXPORT
auto hex_to_bytes(const std::string_view input,
                  const bool allow_odd_length = false)
    -> std::optional<std::string>;

SOURCEMETA_CORE_TEXT_EXPORT
auto bytes_to_hex(const std::string_view input) -> std::string;

inline auto equals_ignore_case(const std::string_view left,
                               const std::string_view right) noexcept -> bool {
  if (left.size() != right.size()) {
    return false;
  }
 
  for (std::size_t index{0}; index < left.size(); ++index) {
    if (to_lowercase(left[index]) != to_lowercase(right[index])) {
      return false;
    }
  }
 
  return true;
}

inline auto starts_with_ignore_case(const std::string_view value,
                                    const std::string_view prefix) noexcept
    -> bool {
  if (value.size() < prefix.size()) {
    return false;
  }
 
  for (std::size_t index{0}; index < prefix.size(); ++index) {
    if (to_lowercase(value[index]) != to_lowercase(prefix[index])) {
      return false;
    }
  }
 
  return true;
}

inline auto less_ignore_case(const std::string_view left,
                             const std::string_view right) noexcept -> bool {
  const auto length{left.size() < right.size() ? left.size() : right.size()};
  for (std::size_t index{0}; index < length; ++index) {
    const auto left_lower{to_lowercase(left[index])};
    const auto right_lower{to_lowercase(right[index])};
    if (left_lower != right_lower) {
      return left_lower < right_lower;
    }
  }
 
  return left.size() < right.size();
}

SOURCEMETA_CORE_TEXT_EXPORT
auto squeeze(const std::string_view input, const char character) -> std::string;

template <typename Output>
auto squeeze(const std::string_view input, const char character, Output &output)
    -> void {
  bool in_run{false};
  for (const auto value : input) {
    if (value == character) {
      if (!in_run) {
        output.push_back(value);
      }
 
      in_run = true;
    } else {
      output.push_back(value);
      in_run = false;
    }
  }
}

SOURCEMETA_CORE_TEXT_EXPORT
auto remove_suffix_ignore_case(const std::string_view input,
                               const std::string_view suffix) noexcept
    -> std::string_view;
 
} // namespace sourcemeta::core
 
#endif