writer_argument.hpp

#pragma once
 
template <size_t N>
constexpr size_t Writer::BoundedTextLength(const char (&text)[N]) noexcept
{
  size_t size = 0;
  while (size < N && text[size] != '\0')
  {
    ++size;
  }
  ASSERT(size < N);
  return size;
}
 
template <typename T>
constexpr std::string_view Writer::ToStringView(const T& text)
{
  using Traits = Detail::FormatArgument::TypeTraits<T>;
 
  if constexpr (std::is_same_v<typename Traits::Decayed, std::string_view>)
  {
    return text;
  }
  else if constexpr (std::is_same_v<typename Traits::Decayed, std::string>)
  {
    return std::string_view(text.data(), text.size());
  }
  else if constexpr (std::is_same_v<typename Traits::Decayed, const char*> ||
                     std::is_same_v<typename Traits::Decayed, char*>)
  {
    if (text == nullptr)
    {
      return "(null)";
    }
    return std::string_view(text, std::strlen(text));
  }
  else if constexpr (Traits::is_char_array)
  {
    return std::string_view(text, BoundedTextLength(text));
  }
  else
  {
    return {};
  }
}
 
template <FormatPackKind pack, typename T>
constexpr auto Writer::PackValue(T&& value)
{
  using Traits = Detail::FormatArgument::TypeTraits<T>;
  using Normalized = typename Traits::Normalized;
 
  if constexpr (pack == FormatPackKind::I32)
  {
    if constexpr (Traits::is_signed_integer)
    {
      return static_cast<int32_t>(static_cast<Normalized>(value));
    }
  }
  else if constexpr (pack == FormatPackKind::I64)
  {
    if constexpr (Traits::is_signed_integer)
    {
      return static_cast<int64_t>(static_cast<Normalized>(value));
    }
  }
  else if constexpr (pack == FormatPackKind::U32)
  {
    if constexpr (std::is_same_v<Normalized, bool>)
    {
      return static_cast<uint32_t>(value ? 1U : 0U);
    }
    else if constexpr (std::is_integral_v<Normalized>)
    {
      return static_cast<uint32_t>(static_cast<std::make_unsigned_t<Normalized>>(
          static_cast<Normalized>(value)));
    }
  }
  else if constexpr (pack == FormatPackKind::U64)
  {
    if constexpr (std::is_same_v<Normalized, bool>)
    {
      return static_cast<uint64_t>(value ? 1U : 0U);
    }
    else if constexpr (std::is_integral_v<Normalized>)
    {
      return static_cast<uint64_t>(static_cast<std::make_unsigned_t<Normalized>>(
          static_cast<Normalized>(value)));
    }
  }
  else if constexpr (pack == FormatPackKind::Pointer)
  {
    if constexpr (Traits::is_pointer_like)
    {
      if constexpr (std::is_same_v<typename Traits::Decayed, std::nullptr_t>)
      {
        return static_cast<uintptr_t>(0);
      }
      else
      {
        return (value == nullptr) ? static_cast<uintptr_t>(0)
                                  : reinterpret_cast<uintptr_t>(value);
      }
    }
  }
  else if constexpr (pack == FormatPackKind::Character)
  {
    if constexpr (Traits::is_character_like)
    {
      return static_cast<char>(static_cast<Normalized>(value));
    }
  }
  else if constexpr (pack == FormatPackKind::StringView)
  {
    if constexpr (Traits::is_string_like)
    {
      return ToStringView(value);
    }
  }
  else if constexpr (pack == FormatPackKind::F32)
  {
    if constexpr (std::is_arithmetic_v<Normalized>)
    {
      return static_cast<float>(value);
    }
  }
  else if constexpr (pack == FormatPackKind::F64)
  {
    if constexpr (std::is_arithmetic_v<Normalized>)
    {
      return static_cast<double>(value);
    }
  }
  else if constexpr (pack == FormatPackKind::LongDouble)
  {
    if constexpr (std::is_arithmetic_v<Normalized>)
    {
      return static_cast<long double>(value);
    }
  }
  else
  {
    static_assert(
        dependent_false_v<pack>,
        "LibXR::Print::Writer::PackValue: unsupported packed argument kind");
  }
}
 
template <typename T>
void Writer::StoreArgument(uint8_t*& out, const T& value)
{
  std::memcpy(out, &value, sizeof(T));
  out += sizeof(T);
}
 
template <auto ArgumentInfoList>
consteval size_t Writer::PackedArgumentBytes()
{
  size_t bytes = 0;
  for (const auto& argument : ArgumentInfoList)
  {
    bytes += FormatArgumentBytes(argument.pack);
  }
  return bytes;
}
 
template <auto ArgumentInfoList, auto ArgumentOrder, typename Tuple>
void Writer::StoreArgumentsOrdered(uint8_t*& out, Tuple& tuple)
{
  [&]<size_t... I>(std::index_sequence<I...>) {
    (StoreArgument(out, PackValue<ArgumentInfoList[I].pack>(
                            std::get<ArgumentOrder[I]>(tuple))),
     ...);
  }(std::make_index_sequence<ArgumentInfoList.size()>{});
}