writer_executor_value.hpp

#pragma once
 
template <OutputSink Sink>
template <std::signed_integral Int>
char Writer::Executor<Sink>::ResolveSignChar(Int value, const Spec& spec)
{
  if (value < 0)
  {
    return '-';
  }
  if (spec.ForceSign())
  {
    return '+';
  }
  if (spec.SpaceSign())
  {
    return ' ';
  }
  return '\0';
}
 
#if LIBXR_PRINT_ENABLE_FLOAT
template <OutputSink Sink>
template <typename T>
char Writer::Executor<Sink>::ResolveFloatSignChar(T value, const Spec& spec)
{
  if (std::isnan(value))
  {
    // NaN signbit is implementation-defined and platform-dependent.
    // Derive sign from the explicit format flag only so output is stable
    // across platforms and FPU implementations:
    //   {:f}  -> "nan"   {:+f} -> "+nan"   {: f} -> " nan"
    return spec.ForceSign() ? '+' : spec.SpaceSign() ? ' ' : '\0';
  }
  if (std::signbit(value))
  {
    return '-';
  }
  if (spec.ForceSign())
  {
    return '+';
  }
  if (spec.SpaceSign())
  {
    return ' ';
  }
  return '\0';
}
#endif
 
template <OutputSink Sink>
template <std::signed_integral Int>
ErrorCode Writer::Executor<Sink>::WriteSigned(const Spec& spec, Int value)
{
  using UInt = std::make_unsigned_t<Int>;
  char digit_buffer[UnsignedDigitCapacity<UInt, 10>()];
  UInt bits = static_cast<UInt>(value);
  UInt magnitude = (value < 0) ? (UInt{0} - bits) : bits;
  size_t digit_count = AppendUnsigned<10>(digit_buffer, magnitude);
 
  std::string_view digits(digit_buffer, digit_count);
  if (value == 0 && spec.precision == 0)
  {
    digits = {};
  }
 
  return WriteIntegerField(ResolveSignChar(value, spec), {}, digits, spec);
}
 
template <OutputSink Sink>
template <uint8_t Base, bool UpperCase, bool PrependOctalZero,
          std::unsigned_integral UInt>
ErrorCode Writer::Executor<Sink>::WriteUnsignedDigits(std::string_view prefix,
                                                      const Spec& spec, UInt value)
{
  char digit_buffer[UnsignedDigitCapacity<UInt, Base>() + (PrependOctalZero ? 1U : 0U)];
  size_t digit_count = AppendUnsigned<Base, UpperCase>(digit_buffer, value);
 
  if constexpr (PrependOctalZero)
  {
    digit_count = ApplyAlternateOctal(digit_buffer, digit_count, spec, value);
  }
  else if (value == 0 && spec.precision == 0)
  {
    digit_count = 0;
  }
 
  return WriteIntegerField('\0', prefix, std::string_view(digit_buffer, digit_count),
                           spec);
}
 
template <OutputSink Sink>
template <FormatType Type, std::unsigned_integral UInt>
ErrorCode Writer::Executor<Sink>::DispatchUnsigned(const Spec& spec, UInt value)
{
  auto prefix = IntegerPrefix(Type, spec, value);
 
  if constexpr (Type == FormatType::Unsigned32 || Type == FormatType::Unsigned64)
  {
    return WriteUnsignedDigits<10>(prefix, spec, value);
  }
  if constexpr (Type == FormatType::Binary32 || Type == FormatType::Binary64)
  {
    return WriteUnsignedDigits<2>(prefix, spec, value);
  }
  if constexpr (Type == FormatType::Octal32 || Type == FormatType::Octal64)
  {
    return WriteUnsignedDigits<8, false, true>(prefix, spec, value);
  }
  if constexpr (Type == FormatType::HexLower32 || Type == FormatType::HexLower64)
  {
    return WriteUnsignedDigits<16>(prefix, spec, value);
  }
  if constexpr (Type == FormatType::HexUpper32 || Type == FormatType::HexUpper64)
  {
    return WriteUnsignedDigits<16, true>(prefix, spec, value);
  }
 
  return ErrorCode::ARG_ERR;
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WritePointer(const Spec& spec, uintptr_t value)
{
  char digit_buffer[UnsignedDigitCapacity<uintptr_t, 16>()];
  size_t digit_count = AppendUnsigned<16>(digit_buffer, value);
  Spec actual = spec;
 
  if (!actual.HasPrecision() || actual.precision == 0)
  {
    actual.precision = 1;
  }
 
  return WriteIntegerField('\0', "0x", std::string_view(digit_buffer, digit_count),
                           actual);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteCharacter(const Spec& spec, char ch)
{
  return WriteTextField(std::string_view(&ch, 1), spec);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteString(const Spec& spec, std::string_view text)
{
  auto view = text;
  if (spec.HasPrecision() && spec.precision < view.size())
  {
    view = view.substr(0, spec.precision);
  }
 
  return WriteTextField(view, spec);
}
 
#if LIBXR_PRINT_ENABLE_FLOAT
template <OutputSink Sink>
template <typename T>
ErrorCode Writer::Executor<Sink>::WriteFloat(FormatType type, const Spec& spec, T value)
{
  if (!UsesFloatTextBackend(type))
  {
    return ErrorCode::ARG_ERR;
  }
 
  Spec actual = spec;
  if (!std::isfinite(value))
  {
    actual.flags &= static_cast<uint8_t>(~static_cast<uint8_t>(FormatFlag::ZeroPad));
  }
 
  char sign_char = ResolveFloatSignChar(value, actual);
  T magnitude = std::signbit(value) ? -static_cast<T>(value) : static_cast<T>(value);
  uint8_t precision = actual.HasPrecision() ? actual.precision : DefaultFloatPrecision();
  if (type == FormatType::FloatFixed || type == FormatType::DoubleFixed ||
      type == FormatType::LongDoubleFixed)
  {
    if (ExceedsFixedIntegerDigits(magnitude, precision))
    {
      return ErrorCode::OUT_OF_RANGE;
    }
  }
  else if (type == FormatType::FloatGeneral || type == FormatType::DoubleGeneral ||
           type == FormatType::LongDoubleGeneral)
  {
    uint8_t significant = precision == 0 ? 1 : precision;
    int exponent =
        RoundScientificDigits(magnitude, static_cast<uint8_t>(significant - 1)).exponent;
    if (!(exponent < -4 || exponent >= significant))
    {
      int fractional_precision = static_cast<int>(significant) - (exponent + 1);
      if (fractional_precision < 0)
      {
        fractional_precision = 0;
      }
      if (ExceedsFixedIntegerDigits(magnitude,
                                    static_cast<uint8_t>(fractional_precision)))
      {
        return ErrorCode::OUT_OF_RANGE;
      }
    }
  }
  char output_buffer[float_buffer_capacity];
  size_t output_size = 0;
  if (!FormatFloatText(type, actual, magnitude, output_buffer, output_size))
  {
    return ErrorCode::NO_BUFF;
  }
 
  return WriteFloatField(sign_char, std::string_view(output_buffer, output_size), actual);
}
#endif
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteU32Dec(uint32_t value)
{
  char digit_buffer[UnsignedDigitCapacity<uint32_t, 10>()];
  size_t digit_count = AppendUnsigned<10>(digit_buffer, value);
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteI32Dec(int32_t value)
{
  using UInt = std::make_unsigned_t<int32_t>;
  char digit_buffer[UnsignedDigitCapacity<UInt, 10>()];
  UInt bits = static_cast<UInt>(value);
  UInt magnitude = (value < 0) ? (UInt{0} - bits) : bits;
  size_t digit_count = AppendUnsigned<10>(digit_buffer, magnitude);
 
  if (value < 0)
  {
    if (auto ec = WriteRaw("-"); ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}
 
template <OutputSink Sink>
template <uint8_t Base, bool UpperCase>
ErrorCode Writer::Executor<Sink>::WriteU32Base(uint32_t value)
{
  char digit_buffer[UnsignedDigitCapacity<uint32_t, Base>()];
  size_t digit_count = AppendUnsigned<Base, UpperCase>(digit_buffer, value);
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteU32ZeroPadWidth(uint8_t width, uint32_t value)
{
  char digit_buffer[UnsignedDigitCapacity<uint32_t, 10>()];
  size_t digit_count = AppendUnsigned<10>(digit_buffer, value);
  size_t zeros = FieldPadding(width, digit_count);
  if (auto ec = WritePadding('0', zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteStringRaw(std::string_view text)
{
  return WriteRaw(text);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteCharacterRaw(char ch)
{
  return WriteRaw(std::string_view(&ch, 1));
}