writer_integer.hpp

#pragma once
 
template <std::unsigned_integral UInt, uint8_t Base>
consteval size_t Writer::UnsignedDigitCapacity()
{
  static_assert(Base == 2 || Base == 8 || Base == 10 || Base == 16,
                "LibXR::Print::Writer only supports base 2, 8, 10, and 16");
 
  UInt value = std::numeric_limits<UInt>::max();
  size_t digits = 1;
  while (value >= static_cast<UInt>(Base))
  {
    value /= static_cast<UInt>(Base);
    ++digits;
  }
  return digits;
}
 
template <uint8_t Base, bool UpperCase, size_t N, std::unsigned_integral UInt>
size_t Writer::AppendUnsigned(char (&out)[N], UInt value)
{
  constexpr char lower_digits[] = "0123456789abcdef";
  constexpr char upper_digits[] = "0123456789ABCDEF";
  static_assert(N >= UnsignedDigitCapacity<UInt, Base>(),
                "LibXR::Print::Writer digit buffer is too small for the selected integer type");
 
  const char* digits = UpperCase ? upper_digits : lower_digits;
  char reverse[UnsignedDigitCapacity<UInt, Base>()];
  size_t count = 0;
 
  if (value == 0)
  {
    out[0] = '0';
    return 1;
  }
 
  while (value != 0)
  {
    reverse[count++] = digits[static_cast<size_t>(value % static_cast<UInt>(Base))];
    value /= static_cast<UInt>(Base);
  }
 
  for (size_t i = 0; i < count; ++i)
  {
    out[i] = reverse[count - i - 1];
  }
 
  return count;
}
 
template <size_t N>
inline size_t Writer::AppendSmallUnsigned(char (&out)[N], uint8_t value)
{
  return AppendUnsigned<10>(out, value);
}
 
constexpr size_t Writer::FieldPadding(uint8_t width, size_t payload_size)
{
  return (width > payload_size) ? static_cast<size_t>(width) - payload_size : 0;
}
 
constexpr size_t Writer::IntegerPrecisionZeros(const Spec& spec, size_t digit_count)
{
  return (spec.HasPrecision() && spec.precision > digit_count)
             ? static_cast<size_t>(spec.precision) - digit_count
             : 0;
}
 
template <std::unsigned_integral UInt>
constexpr std::string_view Writer::IntegerPrefix(FormatType type, const Spec& spec,
                                                 UInt value)
{
  if (!spec.Alternate() || value == 0)
  {
    return {};
  }
  if (type == FormatType::HexLower32 || type == FormatType::HexLower64)
  {
    return "0x";
  }
  if (type == FormatType::HexUpper32 || type == FormatType::HexUpper64)
  {
    return "0X";
  }
  if (type == FormatType::Binary32 || type == FormatType::Binary64)
  {
    return spec.UpperCase() ? "0B" : "0b";
  }
  return {};
}
 
template <std::unsigned_integral UInt>
size_t Writer::ApplyAlternateOctal(char* digits, size_t digit_count, const Spec& spec,
                                   UInt value)
{
  if (!spec.Alternate())
  {
    return (value == 0 && spec.precision == 0) ? 0 : digit_count;
  }
 
  if (value == 0 && spec.precision == 0)
  {
    return 1;
  }
 
  if (value == 0)
  {
    return digit_count;
  }
 
  if (spec.HasPrecision() && spec.precision > digit_count)
  {
    return digit_count;
  }
 
  digits[digit_count++] = '0';
  for (size_t i = digit_count - 1; i > 0; --i)
  {
    digits[i] = digits[i - 1];
  }
  digits[0] = '0';
  return digit_count;
}