format_frontend_binding_base.hpp

#pragma once
 
namespace ArgumentResolution
{
 
template <typename Arg>
[[nodiscard]] consteval ArgumentSummary ClassifyArgument()
{
  using Traits = FormatArgument::TypeTraits<Arg>;
  using Decayed = typename Traits::Decayed;
  using Normalized = typename Traits::Normalized;
 
  if constexpr (std::is_same_v<Decayed, bool>)
  {
    return ArgumentSummary{.kind = ArgumentKind::Bool};
  }
  else if constexpr (std::is_same_v<Decayed, char>)
  {
    return ArgumentSummary{.kind = ArgumentKind::Character};
  }
  else if constexpr (Traits::is_string_like)
  {
    return ArgumentSummary{.kind = ArgumentKind::String};
  }
  else if constexpr (Traits::is_pointer_like)
  {
    return ArgumentSummary{.kind = ArgumentKind::Pointer};
  }
  else if constexpr (Traits::is_signed_integer)
  {
    return ArgumentSummary{
        .kind = ArgumentKind::Signed,
        .uses_64bit_storage = sizeof(Normalized) > sizeof(int32_t),
    };
  }
  else if constexpr (Traits::is_unsigned_integer)
  {
    return ArgumentSummary{
        .kind = ArgumentKind::Unsigned,
        .uses_64bit_storage = sizeof(Normalized) > sizeof(uint32_t),
    };
  }
  else if constexpr (std::is_same_v<Decayed, float>)
  {
    return ArgumentSummary{.kind = ArgumentKind::Float32};
  }
  else if constexpr (std::is_same_v<Decayed, double>)
  {
    return ArgumentSummary{.kind = ArgumentKind::Float64};
  }
  else if constexpr (std::is_same_v<Decayed, long double>)
  {
    return ArgumentSummary{.kind = ArgumentKind::LongDouble};
  }
  else
  {
    return ArgumentSummary{};
  }
}
 
template <typename... Args>
[[nodiscard]] consteval auto ClassifyArguments()
{
  return std::array<ArgumentSummary, sizeof...(Args)>{ClassifyArgument<Args>()...};
}
 
[[nodiscard]] constexpr bool HasSignOption(const ParsedField& field)
{
  return field.force_sign || field.space_sign;
}
 
[[nodiscard]] constexpr uint8_t UnspecifiedPrecision()
{
  return std::numeric_limits<uint8_t>::max();
}
 
[[nodiscard]] constexpr uint8_t BuildFlags(const ParsedField& parsed, bool upper_case)
{
  uint8_t flags = 0;
  if (parsed.align == Align::Left)
  {
    flags |= static_cast<uint8_t>(FormatFlag::LeftAlign);
  }
  if (parsed.align == Align::Center)
  {
    flags |= static_cast<uint8_t>(FormatFlag::CenterAlign);
  }
  if (parsed.force_sign)
  {
    flags |= static_cast<uint8_t>(FormatFlag::ForceSign);
  }
  if (parsed.space_sign)
  {
    flags |= static_cast<uint8_t>(FormatFlag::SpaceSign);
  }
  if (parsed.alternate)
  {
    flags |= static_cast<uint8_t>(FormatFlag::Alternate);
  }
  if (parsed.zero_pad && parsed.align == Align::None)
  {
    flags |= static_cast<uint8_t>(FormatFlag::ZeroPad);
  }
  if (upper_case)
  {
    flags |= static_cast<uint8_t>(FormatFlag::UpperCase);
  }
  return flags;
}
 
[[nodiscard]] constexpr FormatField MakeField(const ParsedField& parsed, FormatType type,
                                              FormatPackKind pack,
                                              bool upper_case = false)
{
  return FormatField{
      .type = type,
      .pack = pack,
      .rule = FormatArgumentRule::None,
      .flags = BuildFlags(parsed, upper_case),
      .fill = parsed.fill,
      .width = parsed.width,
      .precision = parsed.has_precision ? parsed.precision : UnspecifiedPrecision(),
  };
}
 
[[nodiscard]] constexpr bool IsDefaultOr(char presentation, char expected)
{
  return presentation == 0 || presentation == expected;
}
 
[[nodiscard]] constexpr bool IsNonDecimalPresentation(char presentation)
{
  return presentation == 'b' || presentation == 'B' || presentation == 'o' ||
         presentation == 'x' || presentation == 'X';
}
 
[[nodiscard]] constexpr char DefaultFloatPresentation()
{
  if (Config::enable_float_general)
  {
    return 'g';
  }
  if (Config::enable_float_fixed)
  {
    return 'f';
  }
  if (Config::enable_float_scientific)
  {
    return 'e';
  }
  return 0;
}
}  // namespace ArgumentResolution