writer_float_runtime.hpp

#pragma once
 
constexpr bool Writer::UsesFloatTextBackend(FormatType type)
{
  switch (type)
  {
    case FormatType::FloatScientific:
    case FormatType::DoubleScientific:
    case FormatType::LongDoubleScientific:
    case FormatType::FloatGeneral:
    case FormatType::DoubleGeneral:
    case FormatType::LongDoubleGeneral:
    case FormatType::FloatFixed:
    case FormatType::DoubleFixed:
    case FormatType::LongDoubleFixed:
      return true;
    default:
      return false;
  }
}
 
constexpr bool Writer::FloatEnabled(FormatType type)
{
  switch (type)
  {
    case FormatType::FloatFixed:
      return Config::enable_float_fixed;
    case FormatType::FloatScientific:
      return Config::enable_float_scientific;
    case FormatType::FloatGeneral:
      return Config::enable_float_general;
    case FormatType::DoubleFixed:
      return Config::enable_float_double && Config::enable_float_fixed;
    case FormatType::DoubleScientific:
      return Config::enable_float_double && Config::enable_float_scientific;
    case FormatType::DoubleGeneral:
      return Config::enable_float_double && Config::enable_float_general;
    case FormatType::LongDoubleFixed:
      return Config::enable_float_long_double && Config::enable_float_fixed;
    case FormatType::LongDoubleScientific:
      return Config::enable_float_long_double && Config::enable_float_scientific;
    case FormatType::LongDoubleGeneral:
      return Config::enable_float_long_double && Config::enable_float_general;
    default:
      return false;
  }
}
 
constexpr uint8_t Writer::DefaultFloatPrecision()
{
  return Config::max_float_precision < 6 ? Config::max_float_precision : 6;
}
 
template <typename Float>
bool Writer::ExceedsFixedIntegerDigits(Float value, uint8_t precision)
{
  if (!std::isfinite(value))
  {
    return false;
  }
 
  Float rounded =
      value + static_cast<Float>(0.5L) * Power10<Float>(-static_cast<int>(precision));
  if (rounded == 0)
  {
    return 1 > Config::max_float_integer_digits;
  }
 
  auto normalized = NormalizeDecimal(rounded);
  size_t integer_digits =
      (normalized.exponent >= 0) ? static_cast<size_t>(normalized.exponent) + 1U : 1U;
  return integer_digits > Config::max_float_integer_digits;
}
 
inline bool Writer::AppendBufferChar(char* buffer, size_t capacity, size_t& size,
                                     char ch)
{
  if (size >= capacity)
  {
    return false;
  }
  buffer[size++] = ch;
  return true;
}
 
inline bool Writer::AppendBufferText(char* buffer, size_t capacity, size_t& size,
                                     std::string_view text)
{
  if (text.size() > capacity - size)
  {
    return false;
  }
  std::memcpy(buffer + size, text.data(), text.size());
  size += text.size();
  return true;
}
 
inline bool Writer::AppendBufferU32ZeroPad(char* buffer, size_t capacity, size_t& size,
                                           uint32_t value, uint8_t width)
{
  char digits[UnsignedDigitCapacity<uint32_t, 10>()];
  size_t digit_count = AppendUnsigned<10>(digits, value);
  size_t zero_count = (width > digit_count) ? static_cast<size_t>(width) - digit_count : 0;
 
  for (size_t i = 0; i < zero_count; ++i)
  {
    if (!AppendBufferChar(buffer, capacity, size, '0'))
    {
      return false;
    }
  }
 
  return AppendBufferText(buffer, capacity, size, std::string_view(digits, digit_count));
}