brace 前端共享的参数分类与字段形状构造辅助函数 / Shared brace-frontend argument classification and field-shape helpers More...

Functions
template<typename Arg >
consteval ArgumentSummary	ClassifyArgument ()
	将一个 C++ 参数类型归类到 brace 前端使用的本地参数类别 / Classify one C++ argument type into the brace frontend's local category

template<typename... Args>
consteval auto	ClassifyArguments ()
	为 brace 前端归类整组 C++ 参数类型 / Classify one full C++ argument list for the brace frontend

constexpr bool	HasSignOption (const ParsedField &field)
	判断某个已解析字段是否请求了显式符号策略 / Return whether one parsed field requested an explicit sign policy

constexpr uint8_t	UnspecifiedPrecision ()
	返回“未指定精度”的本地哨兵值 / Return the local sentinel meaning "precision not specified"

constexpr uint8_t	BuildFlags (const ParsedField &parsed, bool upper_case)
	根据一个已解析 brace 字段构造共享 FormatFlag 位集合 / Build the shared `FormatFlag` bitset from one parsed brace field

constexpr FormatField	MakeField (const ParsedField &parsed, FormatType type, FormatPackKind pack, bool upper_case=false)
	根据 brace 字段属性构造一条共享 `FormatField` 记录 / Build one shared `FormatField` record from parsed brace-field properties

constexpr bool	IsDefaultOr (char presentation, char expected)
	判断展示字符是否缺省或等于目标字符 / Return whether the presentation is absent or matches the expected token

constexpr bool	IsNonDecimalPresentation (char presentation)
	判断展示字符是否选择了非十进制整数族 / Return whether the presentation selects one non-decimal integer family

constexpr char	DefaultFloatPresentation ()
	在当前功能开关下选择前端默认浮点展示字符 / Choose the frontend default float presentation under current feature gates

consteval ResolvedField	ResolveFloatField (const ParsedField &parsed, ArgumentKind kind)
	针对 float、double 或 long double 参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a float, double, or long double argument

template<typename... Args>
consteval ResolvedField	ResolveField (const ParsedField &parsed)
	先判断一个已解析 brace 字段指向哪类参数，再选择匹配的字段构造逻辑 / Check which argument family a parsed brace field points to, then choose the matching field builder

consteval ResolvedField	ResolveIntegerField (const ParsedField &parsed, bool signed_decimal, bool uses_64bit_storage)
	针对整数类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for an integer-like argument

consteval ResolvedField	ResolveBoolField (const ParsedField &parsed)
	针对 bool 参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a bool argument

consteval ResolvedField	ResolveCharacterField (const ParsedField &parsed)
	针对字符参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a character argument

consteval ResolvedField	ResolveStringField (const ParsedField &parsed)
	针对字符串类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a string-like argument

consteval ResolvedField	ResolvePointerField (const ParsedField &parsed)
	针对指针类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a pointer-like argument

Detailed Description

brace 前端共享的参数分类与字段形状构造辅助函数 / Shared brace-frontend argument classification and field-shape helpers

brace 前端里处理 bool、整数、字符、字符串与指针参数字段的辅助函数 / Brace-frontend helpers for fields that point to bool, integer, character, string, and pointer arguments

brace 前端里处理浮点参数字段的辅助函数 / Brace-frontend helpers for fields that point to float arguments

Function Documentation

◆ BuildFlags()

uint8_t ArgumentResolution::BuildFlags	(	const ParsedField &	parsed,
		bool	upper_case )

nodiscardconstexpr

根据一个已解析 brace 字段构造共享 FormatFlag 位集合 / Build the shared FormatFlag bitset from one parsed brace field

Parameters

parsed	已解析的 brace 字段 / Parsed brace field
upper_case	最终展示是否使用大写字母 / Whether the final presentation should use uppercase letters

Returns: 返回该字段对应的共享 FormatFlag 位集合 / Returns the shared FormatFlag bitset for this field

Definition at line 105 of file format_frontend_binding_base.hpp.

{
  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;
}

◆ ClassifyArgument()

template<typename Arg >

ArgumentSummary ArgumentResolution::ClassifyArgument ( )

nodiscardconsteval

将一个 C++ 参数类型归类到 brace 前端使用的本地参数类别 / Classify one C++ argument type into the brace frontend's local category

Template Parameters

Arg	待归类的 C++ 参数类型 / C++ argument type to classify

Returns: 返回后续字段解析要使用的本地前端参数摘要 / Returns the local frontend summary used by later field resolution

Definition at line 15 of file format_frontend_binding_base.hpp.

{
  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{};
  }
}

◆ ClassifyArguments()

template<typename... Args>

auto ArgumentResolution::ClassifyArguments ( )

nodiscardconsteval

为 brace 前端归类整组 C++ 参数类型 / Classify one full C++ argument list for the brace frontend

Template Parameters

Args	待归类的 C++ 实参类型列表 / C++ argument types to classify

Returns: 按源参数顺序返回每个参数对应的一份 ArgumentSummary / Returns one ArgumentSummary per argument in source order

Definition at line 75 of file format_frontend_binding_base.hpp.

{
  return std::array<ArgumentSummary, sizeof...(Args)>{ClassifyArgument<Args>()...};
}

◆ DefaultFloatPresentation()

char ArgumentResolution::DefaultFloatPresentation ( )

nodiscardconstexpr

在当前功能开关下选择前端默认浮点展示字符 / Choose the frontend default float presentation under current feature gates

Returns: 返回默认浮点展示字符；若全部浮点展示都被关闭则返回 0 / Returns the default float presentation token, or zero when all float presentations are disabled

Definition at line 187 of file format_frontend_binding_base.hpp.

{
  if (Config::enable_float_general)
  {
    return 'g';
  }
  if (Config::enable_float_fixed)
  {
    return 'f';
  }
  if (Config::enable_float_scientific)
  {
    return 'e';
  }
  return 0;
}

◆ HasSignOption()

bool ArgumentResolution::HasSignOption ( const ParsedField & field )

nodiscardconstexpr

判断某个已解析字段是否请求了显式符号策略 / Return whether one parsed field requested an explicit sign policy

Parameters

field 待检查的已解析字段 / Parsed field to inspect

Returns: 若请求了 + 或空格符号策略则返回 true，否则返回 false / Returns true when + or space-sign was requested, otherwise false

Definition at line 85 of file format_frontend_binding_base.hpp.

{
  return field.force_sign || field.space_sign;
}

◆ IsDefaultOr()

bool ArgumentResolution::IsDefaultOr	(	char	presentation,
		char	expected )

nodiscardconstexpr

判断展示字符是否缺省或等于目标字符 / Return whether the presentation is absent or matches the expected token

Parameters

presentation	已解析展示字符；缺省时为 0 / Parsed presentation token, or zero when absent
expected	期望的展示字符 / Expected presentation token

Returns: 若展示字符缺省或等于 expected 则返回 true / Returns true when the presentation is absent or matches expected

Definition at line 167 of file format_frontend_binding_base.hpp.

{
  return presentation == 0 || presentation == expected;
}

◆ IsNonDecimalPresentation()

bool ArgumentResolution::IsNonDecimalPresentation ( char presentation )

nodiscardconstexpr

判断展示字符是否选择了非十进制整数族 / Return whether the presentation selects one non-decimal integer family

Parameters

presentation 已解析展示字符 / Parsed presentation token

Returns: 若选择了二进制、八进制或十六进制展示则返回 true，否则返回 false / Returns true for binary, octal, or hex presentations, otherwise false

Definition at line 177 of file format_frontend_binding_base.hpp.

{
  return presentation == 'b' || presentation == 'B' || presentation == 'o' ||
         presentation == 'x' || presentation == 'X';
}

◆ MakeField()

FormatField ArgumentResolution::MakeField	(	const ParsedField &	parsed,
		FormatType	type,
		FormatPackKind	pack,
		bool	upper_case = false )

nodiscardconstexpr

根据 brace 字段属性构造一条共享 FormatField 记录 / Build one shared FormatField record from parsed brace-field properties

Parameters

parsed	已解析的 brace 字段 / Parsed brace field
type	共享运行期字段类型 / Shared runtime field type
pack	运行期参数打包类型 / Runtime packed-argument kind
upper_case	最终展示是否使用大写字母 / Whether the final presentation should use uppercase letters

Returns: 返回共享编译后端要消费的 FormatField 记录 / Returns the shared FormatField record consumed by the compile-time backend

Definition at line 147 of file format_frontend_binding_base.hpp.

{
  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(),
  };
}

◆ ResolveBoolField()

ResolvedField ArgumentResolution::ResolveBoolField ( const ParsedField & parsed )

nodiscardconsteval

针对 bool 参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a bool argument

Parameters

parsed 已解析的 brace 字段 / Parsed brace field

Returns: 返回解析后的共享字段；不匹配时返回首个类型错误 / Returns the resolved shared field, or the first type-mismatch error

Definition at line 127 of file format_frontend_binding_integer.hpp.

{
  if (parsed.presentation == 0)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  return ResolveIntegerField(parsed, false, false);
}

◆ ResolveCharacterField()

ResolvedField ArgumentResolution::ResolveCharacterField ( const ParsedField & parsed )

nodiscardconsteval

针对字符参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a character argument

Parameters

parsed 已解析的 brace 字段 / Parsed brace field

Returns: 返回解析后的共享字段；不匹配时返回首个类型错误 / Returns the resolved shared field, or the first type-mismatch error

Definition at line 141 of file format_frontend_binding_integer.hpp.

{
  if (parsed.presentation != 0 && parsed.presentation != 'c')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad || parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_text)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  ParsedField adjusted = parsed;
  if (adjusted.align == Align::None)
  {
    adjusted.align = Align::Left;
  }
 
  return ResolvedField{
      .field = MakeField(adjusted, FormatType::Character, FormatPackKind::Character)};
}

◆ ResolveField()

template<typename... Args>

ResolvedField ArgumentResolution::ResolveField ( const ParsedField & parsed )

nodiscardconsteval

先判断一个已解析 brace 字段指向哪类参数，再选择匹配的字段构造逻辑 / Check which argument family a parsed brace field points to, then choose the matching field builder

Template Parameters

Args	已绑定的 C++ 实参类型列表 / Bound C++ argument types

Parameters

parsed 已解析的 brace 字段 / Parsed brace field

Returns: 返回解析后的共享字段；缺参或类型不支持时返回首个错误 / Returns the resolved shared field, or the first missing-argument or unsupported-type error

Definition at line 103 of file format_frontend_binding_float.hpp.

{
  constexpr auto argument_summaries = ClassifyArguments<Args...>();
  if (parsed.arg_index >= argument_summaries.size())
  {
    return ResolvedField{.error = Error::MissingArgument};
  }
 
  auto argument = argument_summaries[parsed.arg_index];
  switch (argument.kind)
  {
    case ArgumentKind::Bool:
      return ResolveBoolField(parsed);
    case ArgumentKind::Character:
      return ResolveCharacterField(parsed);
    case ArgumentKind::Signed:
      return ResolveIntegerField(parsed, true, argument.uses_64bit_storage);
    case ArgumentKind::Unsigned:
      return ResolveIntegerField(parsed, false, argument.uses_64bit_storage);
    case ArgumentKind::String:
      return ResolveStringField(parsed);
    case ArgumentKind::Pointer:
      return ResolvePointerField(parsed);
    case ArgumentKind::Float32:
    case ArgumentKind::Float64:
    case ArgumentKind::LongDouble:
      return ResolveFloatField(parsed, argument.kind);
    case ArgumentKind::Unsupported:
    default:
      return ResolvedField{.error = Error::UnsupportedArgumentType};
  }
}

◆ ResolveFloatField()

ResolvedField ArgumentResolution::ResolveFloatField	(	const ParsedField &	parsed,
		ArgumentKind	kind )

nodiscardconsteval

针对 float、double 或 long double 参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a float, double, or long double argument

Parameters

parsed	已解析的 brace 字段 / Parsed brace field
kind	当前字段选中的前端参数类别 / Frontend-side argument family selected for this field

Returns: 返回解析后的共享字段；精度或类型不匹配时返回首个错误 / Returns the resolved shared field, or the first precision or type mismatch error

Definition at line 15 of file format_frontend_binding_float.hpp.

{
  if (parsed.has_precision && parsed.precision > Config::max_float_precision)
  {
    return ResolvedField{.error = Error::FloatPrecisionLimitExceeded};
  }
 
  char presentation =
      parsed.presentation == 0 ? DefaultFloatPresentation() : parsed.presentation;
  if (presentation == 0)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  bool upper_case =
      presentation == 'F' || presentation == 'E' || presentation == 'G';
 
  FormatType type = FormatType::End;
  FormatPackKind pack = FormatPackKind::F32;
 
  auto pick_type = [&](FormatType f32_type, FormatType f64_type,
                       FormatType ld_type) consteval -> bool {
    switch (kind)
    {
      case ArgumentKind::Float32:
        type = f32_type;
        pack = FormatPackKind::F32;
        return true;
      case ArgumentKind::Float64:
        type = Config::enable_float_double ? f64_type : f32_type;
        pack = Config::enable_float_double ? FormatPackKind::F64 : FormatPackKind::F32;
        return true;
      case ArgumentKind::LongDouble:
        if (!Config::enable_float_long_double)
        {
          return false;
        }
        type = ld_type;
        pack = FormatPackKind::LongDouble;
        return true;
      default:
        return false;
    }
  };
 
  switch (presentation)
  {
    case 'f':
    case 'F':
      if (!Config::enable_float_fixed ||
          !pick_type(FormatType::FloatFixed, FormatType::DoubleFixed,
                     FormatType::LongDoubleFixed))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    case 'e':
    case 'E':
      if (!Config::enable_float_scientific ||
          !pick_type(FormatType::FloatScientific, FormatType::DoubleScientific,
                     FormatType::LongDoubleScientific))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    case 'g':
    case 'G':
      if (!Config::enable_float_general ||
          !pick_type(FormatType::FloatGeneral, FormatType::DoubleGeneral,
                     FormatType::LongDoubleGeneral))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    default:
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  return ResolvedField{.field = MakeField(parsed, type, pack, upper_case)};
}

◆ ResolveIntegerField()

ResolvedField ArgumentResolution::ResolveIntegerField	(	const ParsedField &	parsed,
		bool	signed_decimal,
		bool	uses_64bit_storage )

nodiscardconsteval

针对整数类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for an integer-like argument

Parameters

parsed	已解析的 brace 字段 / Parsed brace field
signed_decimal	选中的参数是否按有符号十进制族处理 / Whether the selected argument should be treated as a signed decimal family
uses_64bit_storage	选中的参数是否需要 64 位打包存储 / Whether the selected argument requires 64-bit packed storage

Returns: 返回解析后的共享字段；不匹配时返回首个类型错误 / Returns the resolved shared field, or the first type-mismatch error

Definition at line 16 of file format_frontend_binding_integer.hpp.

{
  if (!Config::enable_integer)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (uses_64bit_storage && !Config::enable_integer_64bit)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  if (parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  if (parsed.presentation == 'c')
  {
    if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad)
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
    return ResolvedField{.field = MakeField(parsed, FormatType::Character,
                                            FormatPackKind::Character)};
  }
 
  if (IsDefaultOr(parsed.presentation, 'd'))
  {
    if (parsed.alternate)
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
    if (!signed_decimal && HasSignOption(parsed))
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
 
    if (signed_decimal)
    {
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::Signed64
                                                 : FormatType::Signed32,
                              uses_64bit_storage ? FormatPackKind::I64
                                                 : FormatPackKind::I32)};
    }
 
    return ResolvedField{.field = MakeField(
                            parsed,
                            uses_64bit_storage ? FormatType::Unsigned64
                                               : FormatType::Unsigned32,
                            uses_64bit_storage ? FormatPackKind::U64
                                               : FormatPackKind::U32)};
  }
 
  if (!Config::enable_integer_base8_16 || HasSignOption(parsed))
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  switch (parsed.presentation)
  {
    case 'b':
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::Binary64
                                                 : FormatType::Binary32,
                              uses_64bit_storage ? FormatPackKind::U64
                                                 : FormatPackKind::U32)};
    case 'B':
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::Binary64
                                                 : FormatType::Binary32,
                              uses_64bit_storage ? FormatPackKind::U64
                                                 : FormatPackKind::U32,
                              true)};
    case 'o':
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::Octal64
                                                 : FormatType::Octal32,
                              uses_64bit_storage ? FormatPackKind::U64
                                                 : FormatPackKind::U32)};
    case 'x':
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::HexLower64
                                                 : FormatType::HexLower32,
                              uses_64bit_storage ? FormatPackKind::U64
                                                 : FormatPackKind::U32)};
    case 'X':
      return ResolvedField{.field = MakeField(
                              parsed,
                              uses_64bit_storage ? FormatType::HexUpper64
                                                 : FormatType::HexUpper32,
                              uses_64bit_storage ? FormatPackKind::U64
                                                 : FormatPackKind::U32,
                              true)};
    default:
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
}

◆ ResolvePointerField()

ResolvedField ArgumentResolution::ResolvePointerField ( const ParsedField & parsed )

nodiscardconsteval

针对指针类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a pointer-like argument

Parameters

parsed 已解析的 brace 字段 / Parsed brace field

Returns: 返回解析后的共享字段；不匹配时返回首个类型错误 / Returns the resolved shared field, or the first type-mismatch error

Definition at line 201 of file format_frontend_binding_integer.hpp.

{
  if (parsed.presentation != 0 && parsed.presentation != 'p')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad || parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_pointer)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  return ResolvedField{
      .field = MakeField(parsed, FormatType::Pointer, FormatPackKind::Pointer)};
}

◆ ResolveStringField()

ResolvedField ArgumentResolution::ResolveStringField ( const ParsedField & parsed )

nodiscardconsteval

针对字符串类参数解析一个已解析的 brace 字段 / Resolve one parsed brace field for a string-like argument

Parameters

parsed 已解析的 brace 字段 / Parsed brace field

Returns: 返回解析后的共享字段；不匹配时返回首个类型错误 / Returns the resolved shared field, or the first type-mismatch error

Definition at line 171 of file format_frontend_binding_integer.hpp.

{
  if (parsed.presentation != 0 && parsed.presentation != 's')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_text)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  ParsedField adjusted = parsed;
  if (adjusted.align == Align::None)
  {
    adjusted.align = Align::Left;
  }
 
  return ResolvedField{
      .field = MakeField(adjusted, FormatType::String, FormatPackKind::StringView)};
}

◆ UnspecifiedPrecision()

uint8_t ArgumentResolution::UnspecifiedPrecision ( )

nodiscardconstexpr

返回“未指定精度”的本地哨兵值 / Return the local sentinel meaning "precision not specified"

Returns: 返回 brace 前端内部使用的精度哨兵值 / Returns the precision sentinel byte used inside the brace frontend

Definition at line 94 of file format_frontend_binding_base.hpp.

{
  return std::numeric_limits<uint8_t>::max();
}

Functions

Detailed Description

Function Documentation

◆ BuildFlags()

◆ ClassifyArgument()

◆ ClassifyArguments()

◆ DefaultFloatPresentation()

◆ HasSignOption()

◆ IsDefaultOr()

◆ IsNonDecimalPresentation()

◆ MakeField()

◆ ResolveBoolField()

◆ ResolveCharacterField()

◆ ResolveField()

◆ ResolveFloatField()

◆ ResolveIntegerField()

◆ ResolvePointerField()

◆ ResolveStringField()

◆ UnspecifiedPrecision()