writer_executor_value.hpp

#pragma once
 
template <OutputSink Sink, FormatProfile Profile>
template <std::signed_integral Int>
char Writer::Executor<Sink, Profile>::ResolveSignChar(Int value, const Spec& spec)
{
  if (value < 0)
  {
    return '-';
  }
  if (spec.ForceSign())
  {
    return '+';
  }
  if (spec.SpaceSign())
  {
    return ' ';
  }
  return '\0';
}
 
template <OutputSink Sink, FormatProfile Profile>
template <typename T>
char Writer::Executor<Sink, Profile>::ResolveFloatSignChar(T value, const Spec& spec)
{
  if (std::signbit(value))
  {
    return '-';
  }
  if (spec.ForceSign())
  {
    return '+';
  }
  if (spec.SpaceSign())
  {
    return ' ';
  }
  return '\0';
}
 
template <OutputSink Sink, FormatProfile Profile>
template <std::signed_integral Int>
ErrorCode Writer::Executor<Sink, Profile>::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, FormatProfile Profile>
template <uint8_t Base, bool UpperCase, bool InlineAlternateOctal,
          std::unsigned_integral UInt>
ErrorCode Writer::Executor<Sink, Profile>::WriteUnsignedDigits(std::string_view prefix,
                                                               const Spec& spec,
                                                               UInt value)
{
  char digit_buffer[UnsignedDigitCapacity<UInt, Base>() +
                    (InlineAlternateOctal ? 1U : 0U)];
  size_t digit_count = AppendUnsigned<Base, UpperCase>(digit_buffer, value);
 
  if constexpr (InlineAlternateOctal)
  {
    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, FormatProfile Profile>
template <FormatType Type, std::unsigned_integral UInt>
ErrorCode Writer::Executor<Sink, Profile>::WriteUnsigned(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, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::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, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::WriteCharacter(const Spec& spec, char ch)
{
  return WriteTextField(std::string_view(&ch, 1), spec);
}
 
template <OutputSink Sink, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::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);
}
 
template <OutputSink Sink, FormatProfile Profile>
template <typename T>
ErrorCode Writer::Executor<Sink, Profile>::WriteFloat(FormatType type,
                                                      const Spec& spec, T value)
{
  if (!UsesFloatTextBackend(type))
  {
    return ErrorCode::ARG_ERR;
  }
 
  char sign_char = ResolveFloatSignChar(value, spec);
  T magnitude = std::signbit(value) ? -static_cast<T>(value) : static_cast<T>(value);
  uint8_t precision = spec.HasPrecision() ? spec.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 = (magnitude == 0) ? 0 : NormalizeDecimal(magnitude).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, spec, magnitude, output_buffer, output_size))
  {
    return ErrorCode::NO_BUFF;
  }
 
  return WriteFloatField(sign_char, std::string_view(output_buffer, output_size), spec);
}
 
template <OutputSink Sink, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::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, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::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, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::WriteStringRaw(std::string_view text)
{
  return WriteRaw(text);
}
 
template <OutputSink Sink, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::WriteF32FixedPrec(uint8_t precision,
                                                             float value)
{
  char sign_char = std::signbit(value) ? '-' : '\0';
  float magnitude = std::signbit(value) ? -value : value;
  if (ExceedsFixedIntegerDigits(magnitude, precision))
  {
    return ErrorCode::OUT_OF_RANGE;
  }
  char output_buffer[float_buffer_capacity];
  size_t output_size = 0;
  if (!FormatF32FixedPrecText(magnitude, precision, output_buffer, output_size))
  {
    return ErrorCode::NO_BUFF;
  }
 
  if (sign_char != '\0')
  {
    if (auto ec = WriteRaw(std::string_view(&sign_char, 1)); ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  return WriteRaw(std::string_view(output_buffer, output_size));
}
 
template <OutputSink Sink, FormatProfile Profile>
ErrorCode Writer::Executor<Sink, Profile>::WriteF64FixedPrec(uint8_t precision,
                                                             double value)
{
  return WriteFloat(FormatType::DoubleFixed, Spec{.precision = precision}, value);
}