libxr_string.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <limits>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
 
#include "libxr_def.hpp"
#include "print.hpp"
 
namespace LibXR
{
template <Print::Text Source, typename... Args>
class RuntimeStringView;
 
namespace Detail
{
 
template <typename... Values>
struct RuntimeStringTypeList
{
};
 
template <typename T, bool IsEnum = std::is_enum_v<T>>
struct RuntimeStringNormalized
{
  using Type = T;
};
 
template <typename T>
struct RuntimeStringNormalized<T, true>
{
  using Type = std::underlying_type_t<T>;
};
 
template <typename T>
static constexpr bool runtime_string_always_false = false;
 
inline constexpr size_t runtime_string_unbounded_capacity =
    std::numeric_limits<size_t>::max();
inline constexpr size_t runtime_string_max_field_width =
    std::numeric_limits<uint8_t>::max();
 
[[nodiscard]] constexpr size_t RuntimeStringFieldCapacity(Print::FormatPackKind pack)
{
  constexpr size_t width = runtime_string_max_field_width;
  constexpr size_t precision = runtime_string_max_field_width;
 
  switch (pack)
  {
    case Print::FormatPackKind::I32:
      return 1U + precision;
    case Print::FormatPackKind::I64:
      return 1U + precision;
    case Print::FormatPackKind::U32:
      return 2U + precision;
    case Print::FormatPackKind::U64:
      return 2U + precision;
    case Print::FormatPackKind::Pointer:
      return 2U +
             (precision > 2U * sizeof(uintptr_t) ? precision : 2U * sizeof(uintptr_t));
    case Print::FormatPackKind::Character:
      return width;
    case Print::FormatPackKind::StringView:
      return runtime_string_unbounded_capacity;
    case Print::FormatPackKind::F32:
      return 1U + static_cast<size_t>(std::numeric_limits<float>::max_exponent10) + 2U +
             1U + precision;
    case Print::FormatPackKind::F64:
      return 1U + static_cast<size_t>(std::numeric_limits<double>::max_exponent10) + 2U +
             1U + precision;
    case Print::FormatPackKind::LongDouble:
      return 1U + static_cast<size_t>(std::numeric_limits<long double>::max_exponent10) +
             2U + 1U + precision;
  }
 
  return runtime_string_unbounded_capacity;
}
 
[[nodiscard]] constexpr bool RuntimeStringAddCapacity(size_t& total, size_t value)
{
  if (value == runtime_string_unbounded_capacity ||
      runtime_string_unbounded_capacity - total < value)
  {
    return false;
  }
  total += value;
  return true;
}
 
template <typename Built>
[[nodiscard]] consteval size_t RuntimeStringMaxFormattedSize(size_t source_size)
{
  size_t total = source_size;
  for (const auto& argument : Built::ArgumentList())
  {
    if (!RuntimeStringAddCapacity(total, RuntimeStringFieldCapacity(argument.pack)))
    {
      return runtime_string_unbounded_capacity;
    }
  }
  return total;
}
 
template <typename T>
struct RuntimeStringArgumentTraits
{
  using Decayed = std::remove_cvref_t<T>;
  using Normalized = typename RuntimeStringNormalized<Decayed>::Type;
 
  static constexpr bool is_text =
      std::is_array_v<Decayed> || std::is_same_v<Decayed, char*> ||
      std::is_same_v<Decayed, const char*> || std::is_same_v<Decayed, std::string> ||
      std::is_same_v<Decayed, std::string_view>;
 
  static constexpr bool is_pointer =
      std::is_pointer_v<Decayed> && !std::is_function_v<std::remove_pointer_t<Decayed>>;
 
  static constexpr bool has_static_capacity =
      !is_text &&
      (std::is_same_v<Decayed, std::nullptr_t> || is_pointer ||
       std::is_integral_v<Normalized> || std::is_floating_point_v<Normalized>);
};
 
template <typename... Args>
struct RuntimeStringArgumentTypes
{
  template <typename... CallArgs>
  static constexpr bool matches = std::is_same_v<
      RuntimeStringTypeList<typename RuntimeStringArgumentTraits<CallArgs>::Decayed...>,
      RuntimeStringTypeList<Args...>>;
};
 
struct RuntimeStringTextPart
{
  std::string_view view;
  ErrorCode status = ErrorCode::OK;
};
 
template <typename T>
struct RuntimeStringViewTag : std::false_type
{
};
 
template <Print::Text Source, typename... Args>
struct RuntimeStringViewTag<RuntimeStringView<Source, Args...>> : std::true_type
{
};
 
template <typename T>
inline constexpr bool runtime_string_is_view_v =
    RuntimeStringViewTag<std::remove_cvref_t<T>>::value;
 
struct RuntimeStringBufferSink
{
  char* data = nullptr;
  size_t capacity = 0;
  size_t size = 0;
 
  [[nodiscard]] ErrorCode Write(std::string_view chunk)
  {
    if (capacity - size < chunk.size())
    {
      return ErrorCode::OUT_OF_RANGE;
    }
    if (!chunk.empty())
    {
      std::memcpy(data + size, chunk.data(), chunk.size());
      size += chunk.size();
    }
    return ErrorCode::OK;
  }
};
 
}  // namespace Detail
 
template <Print::Text Source = "", typename... Args>
class RuntimeStringView
{
 public:
  static_assert((std::is_same_v<
                     Args, typename Detail::RuntimeStringArgumentTraits<Args>::Decayed> &&
                 ...),
                "LibXR::RuntimeStringView argument types must be unqualified "
                "value types");
  static_assert((Detail::RuntimeStringArgumentTraits<Args>::has_static_capacity && ...),
                "LibXR::RuntimeStringView formatted arguments cannot contain "
                "runtime strings; use RuntimeStringView<> for text concatenation");
 
  constexpr RuntimeStringView() = default;
 
  RuntimeStringView(const RuntimeStringView&) = delete;
  RuntimeStringView& operator=(const RuntimeStringView&) = delete;
 
  RuntimeStringView(RuntimeStringView&& other) noexcept
      : data_(other.data_),
        size_(other.size_),
        capacity_(other.capacity_),
        status_(other.status_)
  {
    other.data_ = nullptr;
    other.size_ = 0;
    other.capacity_ = 0;
    other.status_ = ErrorCode::OK;
  }
 
  RuntimeStringView& operator=(RuntimeStringView&&) = delete;
 
  explicit RuntimeStringView(std::string_view text)
    requires(Source.Size() == 0 && sizeof...(Args) == 0)
  {
    static_cast<void>(AssignCopy(text));
  }
 
  template <size_t N>
  explicit RuntimeStringView(char (&text)[N])
    requires(Source.Size() == 0 && sizeof...(Args) == 0)
  {
    static_cast<void>(AssignCopy(std::string_view(text, BoundedTextLength(text, N))));
  }
 
  template <size_t N>
  explicit RuntimeStringView(const char (&text)[N])
    requires(Source.Size() == 0 && sizeof...(Args) == 0)
  {
    static_cast<void>(AssignCopy(std::string_view(text, BoundedTextLength(text, N))));
  }
 
  template <typename CharPtr>
    requires(Source.Size() == 0 && sizeof...(Args) == 0 &&
             (std::is_same_v<CharPtr, char*> || std::is_same_v<CharPtr, const char*>))
  explicit RuntimeStringView(CharPtr text)
  {
    static_cast<void>(AssignCopy(text));
  }
 
  explicit RuntimeStringView(std::nullptr_t text)
    requires(Source.Size() == 0 && sizeof...(Args) == 0)
  {
    static_cast<void>(AssignCopy(static_cast<const char*>(text)));
  }
 
  template <typename First, typename Second, typename... Rest>
  explicit RuntimeStringView(First&& first, Second&& second, Rest&&... rest)
    requires(Source.Size() == 0 && sizeof...(Args) == 0)
  {
    static_cast<void>(AssignConcat(std::forward<First>(first),
                                   std::forward<Second>(second),
                                   std::forward<Rest>(rest)...));
  }
 
  template <typename... CallArgs>
  [[nodiscard]] ErrorCode Reformat(CallArgs&&... args)
    requires((Source.Size() != 0 || sizeof...(Args) != 0) &&
             Detail::RuntimeStringArgumentTypes<Args...>::template matches<CallArgs...>)
  {
    static_assert(LibXR::Format<Source>::template Matches<Args...>(),
                  "LibXR::RuntimeStringView format argument types do not match "
                  "the format");
    using Built = typename LibXR::Format<Source>::template Compiled<Args...>;
    static constexpr size_t max_size =
        Detail::RuntimeStringMaxFormattedSize<Built>(Source.Size());
    static_assert(max_size != Detail::runtime_string_unbounded_capacity,
                  "LibXR::RuntimeStringView cannot retain unbounded formatted "
                  "runtime strings");
 
    return AssignFormatted(
        max_size, [&](auto& sink)
        { return Print::FormatTo<Source>(sink, std::forward<CallArgs>(args)...); });
  }
 
  template <typename... CallArgs>
  [[nodiscard]] ErrorCode Reprintf(CallArgs&&... args)
    requires((Source.Size() != 0 || sizeof...(Args) != 0) &&
             Detail::RuntimeStringArgumentTypes<Args...>::template matches<CallArgs...>)
  {
    static_assert(Print::Printf::Matches<Source, Args...>(),
                  "LibXR::RuntimeStringView printf argument types do not match "
                  "the format");
    using Built = Print::Printf::Compiled<Source>;
    static constexpr size_t max_size =
        Detail::RuntimeStringMaxFormattedSize<Built>(Source.Size());
    static_assert(max_size != Detail::runtime_string_unbounded_capacity,
                  "LibXR::RuntimeStringView cannot retain unbounded formatted "
                  "runtime strings");
 
    return AssignFormatted(
        max_size, [&](auto& sink)
        { return Print::PrintfTo<Source>(sink, std::forward<CallArgs>(args)...); });
  }
 
  [[nodiscard]] constexpr std::string_view View() const
  {
    return data_ == nullptr ? std::string_view{} : std::string_view(data_, size_);
  }
 
  [[nodiscard]] const char* CStr() const { return data_ == nullptr ? "" : data_; }
  [[nodiscard]] constexpr size_t Size() const { return size_; }
  [[nodiscard]] constexpr bool Empty() const { return size_ == 0; }
  [[nodiscard]] constexpr ErrorCode Status() const { return status_; }
  [[nodiscard]] constexpr operator std::string_view() const { return View(); }
  [[nodiscard]] operator const char*() const { return CStr(); }
 
 private:
  [[nodiscard]] ErrorCode SetFailure(ErrorCode status)
  {
    if (data_ != nullptr)
    {
      data_[0] = '\0';
    }
    size_ = 0;
    status_ = status;
    return status_;
  }
 
  [[nodiscard]] ErrorCode EnsureCapacity(size_t payload_size)
  {
    if (payload_size == std::numeric_limits<size_t>::max())
    {
      return ErrorCode::OUT_OF_RANGE;
    }
    if (payload_size <= capacity_ && data_ != nullptr)
    {
      return ErrorCode::OK;
    }
    if (data_ != nullptr)
    {
      return ErrorCode::OUT_OF_RANGE;
    }
    if (payload_size == 0)
    {
      return ErrorCode::OK;
    }
 
    data_ = new char[payload_size + 1U];
    capacity_ = payload_size;
    return ErrorCode::OK;
  }
 
  [[nodiscard]] ErrorCode AssignCopy(std::string_view text)
  {
    ErrorCode status = EnsureCapacity(text.size());
    if (status != ErrorCode::OK)
    {
      return SetFailure(status);
    }
    if (!text.empty())
    {
      std::memcpy(data_, text.data(), text.size());
    }
    if (data_ != nullptr)
    {
      data_[text.size()] = '\0';
    }
    size_ = text.size();
    status_ = ErrorCode::OK;
    return status_;
  }
 
  [[nodiscard]] ErrorCode AssignCopy(const char* text)
  {
    return text == nullptr ? SetFailure(ErrorCode::PTR_NULL)
                           : AssignCopy(std::string_view(text, std::strlen(text)));
  }
 
  template <typename... Parts>
  [[nodiscard]] ErrorCode AssignConcat(Parts&&... parts)
  {
    size_t total_size = 0;
    ErrorCode status = ErrorCode::OK;
 
    auto count = [&](auto&& part)
    {
      if (status != ErrorCode::OK)
      {
        return;
      }
 
      Detail::RuntimeStringTextPart text =
          NormalizeConcatPart(std::forward<decltype(part)>(part));
      if (text.status != ErrorCode::OK)
      {
        status = text.status;
      }
      else if (std::numeric_limits<size_t>::max() - total_size < text.view.size())
      {
        status = ErrorCode::OUT_OF_RANGE;
      }
      else
      {
        total_size += text.view.size();
      }
    };
    (count(std::forward<Parts>(parts)), ...);
 
    if (status != ErrorCode::OK)
    {
      return SetFailure(status);
    }
    status = EnsureCapacity(total_size);
    if (status != ErrorCode::OK)
    {
      return SetFailure(status);
    }
 
    size_t offset = 0;
    auto copy = [&](auto&& part)
    {
      Detail::RuntimeStringTextPart text =
          NormalizeConcatPart(std::forward<decltype(part)>(part));
      if (!text.view.empty())
      {
        std::memcpy(data_ + offset, text.view.data(), text.view.size());
        offset += text.view.size();
      }
    };
    (copy(std::forward<Parts>(parts)), ...);
 
    if (data_ != nullptr)
    {
      data_[total_size] = '\0';
    }
    size_ = total_size;
    status_ = ErrorCode::OK;
    return status_;
  }
 
  template <typename WriteFn>
  [[nodiscard]] ErrorCode AssignFormatted(size_t max_size, WriteFn&& write)
  {
    if (data_ == nullptr)
    {
      ErrorCode status = EnsureCapacity(max_size);
      if (status != ErrorCode::OK)
      {
        return SetFailure(status);
      }
    }
 
    Detail::RuntimeStringBufferSink sink{.data = data_, .capacity = capacity_};
    ErrorCode status = write(sink);
    if (status != ErrorCode::OK)
    {
      return SetFailure(status);
    }
    if (data_ != nullptr)
    {
      data_[sink.size] = '\0';
    }
    size_ = sink.size;
    status_ = ErrorCode::OK;
    return status_;
  }
 
  [[nodiscard]] static constexpr size_t BoundedTextLength(const char* text,
                                                          size_t bound) noexcept
  {
    size_t size = 0;
    while (size < bound && text[size] != '\0')
    {
      ++size;
    }
    return size;
  }
 
  template <typename T>
  [[nodiscard]] static constexpr Detail::RuntimeStringTextPart NormalizeConcatPart(
      T&& text)
  {
    using Bare = std::remove_cvref_t<T>;
    if constexpr (Detail::runtime_string_is_view_v<T>)
    {
      const auto& retained = text;
      return retained.Status() == ErrorCode::OK
                 ? Detail::RuntimeStringTextPart{.view = retained.View()}
                 : Detail::RuntimeStringTextPart{.status = retained.Status()};
    }
    else if constexpr (std::is_array_v<Bare> &&
                       std::is_same_v<std::remove_cv_t<std::remove_extent_t<Bare>>, char>)
    {
      return {.view =
                  std::string_view(text, BoundedTextLength(text, std::extent_v<Bare>))};
    }
    else if constexpr (std::is_same_v<Bare, std::string_view>)
    {
      return {.view = text};
    }
    else if constexpr (std::is_same_v<Bare, std::string>)
    {
      return {.view = std::string_view(text.data(), text.size())};
    }
    else if constexpr (std::is_same_v<Bare, std::nullptr_t>)
    {
      return {.status = ErrorCode::PTR_NULL};
    }
    else if constexpr (std::is_same_v<Bare, char*> || std::is_same_v<Bare, const char*>)
    {
      return text == nullptr
                 ? Detail::RuntimeStringTextPart{.view = {},
                                                 .status = ErrorCode::PTR_NULL}
                 : Detail::RuntimeStringTextPart{
                       .view = std::string_view(text, std::strlen(text))};
    }
    else
    {
      static_assert(Detail::runtime_string_always_false<T>,
                    "RuntimeStringView constructor only accepts text-like parts. "
                    "Use Reformat() or Reprintf() for numeric formatting.");
      return {.status = ErrorCode::ARG_ERR};
    }
  }
 
  char* data_ = nullptr;
  size_t size_ = 0;
  size_t capacity_ = 0;
  ErrorCode status_ = ErrorCode::OK;
};
 
RuntimeStringView(std::string_view) -> RuntimeStringView<>;
RuntimeStringView(const char*) -> RuntimeStringView<>;
 
template <typename First, typename Second, typename... Rest>
RuntimeStringView(First&&, Second&&, Rest&&...) -> RuntimeStringView<>;
 
}  // namespace LibXR