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 = RoundDecimal(value, precision);
  if (!std::isfinite(rounded))
  {
    // RoundDecimal returns +infinity when value * 10^precision overflows.
    // Treat this as exceeding the integer digit limit.
    return true;
  }
  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;
}