按输出端共享重后端、按调用点 profile 裁剪操作码分发的字节码执行器 / Per-sink bytecode executor with shared heavy backends and per-call profile-pruned opcode dispatch More...

#include <writer_executor.hpp>

Collaboration diagram for Writer::Executor< Sink >:

[legend]

Public Member Functions
	Executor (Sink &sink, const uint8_t codes, const uint8_t args)
	将一个输出端、一份编译字节块和一份参数字节块绑定起来 / Bind one sink with one compiled byte blob and one packed argument blob

template<FormatProfile Profile>
ErrorCode	Run ()
	持续执行记录流，直到遇到 `FormatOp::End` / Run until the compiled record stream reaches `FormatOp::End`

Private Member Functions
ErrorCode	WriteRaw (std::string_view text)
	运行期执行器共享的字段写出原语，供所有操作码路径复用 / Executor-side field-writing primitives shared by all runtime opcodes

ErrorCode	WritePadding (char fill, size_t count)
	向输出端写入重复填充字符 / Write repeated fill characters into the sink

ErrorCode	WriteTextField (std::string_view text, const Spec &spec)
	按宽度与对齐策略写出一个文本字段 / Write one text field with width/alignment policy applied

ErrorCode	WriteIntegerField (char sign_char, std::string_view prefix, std::string_view digits, const Spec &spec)
	按符号、前缀、精度与填充策略写出一个整数载荷 / Write one integer payload with sign, prefix, precision, and padding policy applied

ErrorCode	WriteFloatField (char sign_char, std::string_view text, const Spec &spec)
	按符号与字段填充策略写出一个浮点文本载荷 / Write one float text payload with sign and field padding applied

template<std::signed_integral Int>
ErrorCode	WriteSigned (const Spec &spec, Int value)
	通过共享整数字段路径写出一个有符号整数值 / Write one signed integer value through the shared integer-field path

template<FormatType Type, std::unsigned_integral UInt>
ErrorCode	DispatchUnsigned (const Spec &spec, UInt value)
	通过共享整数字段路径写出一个无符号整数语义值 / Write one unsigned integer semantic value through the shared integer-field path

template<uint8_t Base, bool UpperCase = false, bool PrependOctalZero = false, std::unsigned_integral UInt>
ErrorCode	WriteUnsignedDigits (std::string_view prefix, const Spec &spec, UInt value)
	按编译期进制/大小写/八进制备用格式参数复用无符号数字载荷写出逻辑 / Reuse the unsigned-digit payload writer with compile-time radix, case, and octal-alternate parameters

ErrorCode	WritePointer (const Spec &spec, uintptr_t value)
	按规范指针字段策略写出一个指针值 / Write one pointer value using the canonical pointer field policy

ErrorCode	WriteCharacter (const Spec &spec, char ch)
	写出一个字符字段值 / Write one character field value

ErrorCode	WriteString (const Spec &spec, std::string_view text)
	写出一个字符串字段值，并在需要时应用精度截断 / Write one string field value, including precision truncation when present

ErrorCode	WriteU32Dec (uint32_t value)
	单个原始 uint32_t 十进制字段的快路径。 / Fast path for one raw uint32_t decimal field.

ErrorCode	WriteI32Dec (int32_t value)
	单个原始 int32_t 十进制字段的快路径。 / Fast path for one raw int32_t decimal field.

template<uint8_t Base, bool UpperCase = false>
ErrorCode	WriteU32Base (uint32_t value)
	单个原始 uint32_t 非十进制字段的快路径。 / Fast path for one raw uint32_t non-decimal field.

ErrorCode	WriteU32ZeroPadWidth (uint8_t width, uint32_t value)
	单个零填充 uint32_t 十进制字段的快路径。 / Fast path for one zero-padded uint32_t decimal field.

ErrorCode	WriteStringRaw (std::string_view text)
	单个原始字符串参数的快路径。 / Fast path for one raw string argument.

ErrorCode	WriteCharacterRaw (char ch)
	单个原始字符参数的快路径。 / Fast path for one raw character argument.

template<std::signed_integral Int>
ErrorCode	DispatchSignedField ()
	运行期执行器中 `GenericField` 的分发桥接函数 / `GenericField` dispatch bridges for the runtime executor

template<FormatType Type, std::unsigned_integral UInt>
ErrorCode	DispatchUnsignedField ()
	读取一个无符号载荷并转发给选定的整数语义写出路径 / Read one unsigned payload and forward it to the selected integer semantic writer

ErrorCode	DispatchPointerField ()
	读取一个指针载荷并走指针字段写出路径 / Read one pointer payload and write it through the pointer field path

ErrorCode	DispatchCharacterField ()
	读取一个字符载荷并走字符字段写出路径 / Read one character payload and write it through the character field path

ErrorCode	DispatchStringField ()
	读取一个字符串载荷并走字符串字段写出路径 / Read one string payload and write it through the string field path

template<FormatProfile Profile>
ErrorCode	DispatchGenericField (FormatType type)
	将一个 `GenericField` 载荷分发到对应的宽回退路径 / Dispatch one `GenericField` payload to the corresponding wide fallback

template<FormatProfile Profile>
ErrorCode	DispatchOp (FormatOp op)
	将一个运行期操作码分发到选中的特化路径 / Dispatch one runtime opcode to the selected specialized path

Static Private Member Functions
template<std::signed_integral Int>
static char	ResolveSignChar (Int value, const Spec &spec)
	执行器的具体运行期数值写出函数 / Concrete runtime value writers for the executor

Private Attributes
Sink &	sink_

CodeReader	codes_

ArgumentReader	args_

Detailed Description

template<OutputSink Sink>
class Writer::Executor< Sink >

按输出端共享重后端、按调用点 profile 裁剪操作码分发的字节码执行器 / Per-sink bytecode executor with shared heavy backends and per-call profile-pruned opcode dispatch

Template Parameters

Sink	输出端类型，需满足 `OutputSink` / Sink type satisfying `OutputSink`

Definition at line 10 of file writer_executor.hpp.

Constructor & Destructor Documentation

◆ Executor()

template<OutputSink Sink>

Writer::Executor< Sink >::Executor	(	Sink &	sink,
		const uint8_t *	codes,
		const uint8_t *	args )

将一个输出端、一份编译字节块和一份参数字节块绑定起来 / Bind one sink with one compiled byte blob and one packed argument blob

writer 执行器的顶层运行期操作码循环。 / Top-level runtime opcode loop for the writer executor.

Parameters

sink	输出端 / Destination sink
codes	指向编译字节块的指针 / Pointer to the compiled byte blob
args	指向运行期参数打包字节块的指针；无参数时可为空 / Pointer to the packed runtime argument blob, or null when no arguments exist

将一个输出端、码流和参数字节块绑定到当前执行器 / Bind one sink, code stream, and packed-argument blob to this executor

Parameters

sink	输出端 / Destination sink
codes	指向编译字节流的指针 / Pointer to the compiled byte stream
args	指向已打包参数字节块的指针；无参数时可为空 / Pointer to the packed argument blob, or null when no arguments exist

Definition at line 17 of file writer_executor_opcode.hpp.

    : sink_(sink), codes_(codes), args_(args)
{
}

Member Function Documentation

◆ DispatchCharacterField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::DispatchCharacterField ( )

nodiscardprivate

读取一个字符载荷并走字符字段写出路径 / Read one character payload and write it through the character field path

Returns: 返回字符字段写出结果 / Returns the character-field write result

Definition at line 69 of file writer_executor_generic.hpp.

{
  return WriteCharacter(codes_.ReadSpec(), args_.Read<char>());
}

◆ DispatchGenericField()

template<OutputSink Sink>

template<FormatProfile Profile>

ErrorCode Writer::Executor< Sink >::DispatchGenericField ( FormatType type )

nodiscardprivate

将一个 GenericField 载荷分发到对应的宽回退路径 / Dispatch one GenericField payload to the corresponding wide fallback

将一个 GenericField 语义类型分发到具体宽回退写出路径 / Dispatch one GenericField semantic type to the concrete wide fallback writer

Template Parameters

Profile 当前编译格式使用的精确通用字段类型集合 / Exact generic-field type set used by the current compiled format

Parameters

type	`GenericField` 记录携带的语义字段类型 / Semantic field type carried by the `GenericField` record

Returns: 返回该字段的具体写出结果 / Returns the concrete writer result for that field

Parameters

type	当前 `GenericField` 携带的运行期语义类型 / Runtime semantic type carried by this `GenericField`

Returns: 返回具体宽回退路径的写出结果 / Returns the concrete wide-path write result

Definition at line 94 of file writer_executor_generic.hpp.

{
  switch (type)
  {
    case FormatType::Signed32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericSigned32) &&
                    Config::enable_integer)
      {
        return DispatchSignedField<int32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Signed64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericSigned64) &&
                    Config::enable_integer && Config::enable_integer_64bit)
      {
        return DispatchSignedField<int64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Unsigned32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericUnsigned32) &&
                    Config::enable_integer)
      {
        return DispatchUnsignedField<FormatType::Unsigned32, uint32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Unsigned64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericUnsigned64) &&
                    Config::enable_integer && Config::enable_integer_64bit)
      {
        return DispatchUnsignedField<FormatType::Unsigned64, uint64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Binary32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericBinary32) &&
                    Config::enable_integer && Config::enable_integer_base8_16)
      {
        return DispatchUnsignedField<FormatType::Binary32, uint32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Binary64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericBinary64) &&
                    Config::enable_integer && Config::enable_integer_base8_16 &&
                    Config::enable_integer_64bit)
      {
        return DispatchUnsignedField<FormatType::Binary64, uint64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Octal32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericOctal32) &&
                    Config::enable_integer && Config::enable_integer_base8_16)
      {
        return DispatchUnsignedField<FormatType::Octal32, uint32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Octal64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericOctal64) &&
                    Config::enable_integer && Config::enable_integer_base8_16 &&
                    Config::enable_integer_64bit)
      {
        return DispatchUnsignedField<FormatType::Octal64, uint64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::HexLower32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericHexLower32) &&
                    Config::enable_integer && Config::enable_integer_base8_16)
      {
        return DispatchUnsignedField<FormatType::HexLower32, uint32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::HexLower64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericHexLower64) &&
                    Config::enable_integer && Config::enable_integer_base8_16 &&
                    Config::enable_integer_64bit)
      {
        return DispatchUnsignedField<FormatType::HexLower64, uint64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::HexUpper32:
      if constexpr (HasProfile(Profile, FormatProfile::GenericHexUpper32) &&
                    Config::enable_integer && Config::enable_integer_base8_16)
      {
        return DispatchUnsignedField<FormatType::HexUpper32, uint32_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::HexUpper64:
      if constexpr (HasProfile(Profile, FormatProfile::GenericHexUpper64) &&
                    Config::enable_integer && Config::enable_integer_base8_16 &&
                    Config::enable_integer_64bit)
      {
        return DispatchUnsignedField<FormatType::HexUpper64, uint64_t>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Pointer:
      if constexpr (HasProfile(Profile, FormatProfile::GenericPointer) &&
                    Config::enable_pointer)
      {
        return DispatchPointerField();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::Character:
      if constexpr (HasProfile(Profile, FormatProfile::GenericCharacter) &&
                    Config::enable_text)
      {
        return DispatchCharacterField();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::String:
      if constexpr (HasProfile(Profile, FormatProfile::GenericString) &&
                    Config::enable_text)
      {
        return DispatchStringField();
      }
      return ErrorCode::STATE_ERR;
#if LIBXR_PRINT_ENABLE_FLOAT
    case FormatType::FloatFixed:
      if constexpr (HasProfile(Profile, FormatProfile::GenericFloatFixed) &&
                    FloatEnabled(FormatType::FloatFixed))
      {
        return DispatchFloatField<FormatType::FloatFixed, float>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::DoubleFixed:
      if constexpr (HasProfile(Profile, FormatProfile::GenericDoubleFixed) &&
                    FloatEnabled(FormatType::DoubleFixed))
      {
        return DispatchFloatField<FormatType::DoubleFixed, double>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::FloatScientific:
      if constexpr (HasProfile(Profile, FormatProfile::GenericFloatScientific) &&
                    FloatEnabled(FormatType::FloatScientific))
      {
        return DispatchFloatField<FormatType::FloatScientific, float>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::DoubleScientific:
      if constexpr (HasProfile(Profile, FormatProfile::GenericDoubleScientific) &&
                    FloatEnabled(FormatType::DoubleScientific))
      {
        return DispatchFloatField<FormatType::DoubleScientific, double>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::FloatGeneral:
      if constexpr (HasProfile(Profile, FormatProfile::GenericFloatGeneral) &&
                    FloatEnabled(FormatType::FloatGeneral))
      {
        return DispatchFloatField<FormatType::FloatGeneral, float>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::DoubleGeneral:
      if constexpr (HasProfile(Profile, FormatProfile::GenericDoubleGeneral) &&
                    FloatEnabled(FormatType::DoubleGeneral))
      {
        return DispatchFloatField<FormatType::DoubleGeneral, double>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::LongDoubleFixed:
      if constexpr (HasProfile(Profile, FormatProfile::GenericLongDoubleFixed) &&
                    FloatEnabled(FormatType::LongDoubleFixed))
      {
        return DispatchFloatField<FormatType::LongDoubleFixed, long double>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::LongDoubleScientific:
      if constexpr (HasProfile(Profile, FormatProfile::GenericLongDoubleScientific) &&
                    FloatEnabled(FormatType::LongDoubleScientific))
      {
        return DispatchFloatField<FormatType::LongDoubleScientific, long double>();
      }
      return ErrorCode::STATE_ERR;
    case FormatType::LongDoubleGeneral:
      if constexpr (HasProfile(Profile, FormatProfile::GenericLongDoubleGeneral) &&
                    FloatEnabled(FormatType::LongDoubleGeneral))
      {
        return DispatchFloatField<FormatType::LongDoubleGeneral, long double>();
      }
      return ErrorCode::STATE_ERR;
#endif
    case FormatType::TextInline:
    case FormatType::TextRef:
    case FormatType::TextSpace:
    case FormatType::End:
    default:
      return ErrorCode::STATE_ERR;
  }
}

◆ DispatchOp()

template<OutputSink Sink>

template<FormatProfile Profile>

ErrorCode Writer::Executor< Sink >::DispatchOp ( FormatOp op )

nodiscardprivate

将一个运行期操作码分发到选中的特化路径 / Dispatch one runtime opcode to the selected specialized path

将一个顶层操作码分发到其特化运行期路径 / Dispatches one top-level opcode to its specialized runtime path.

Template Parameters

Profile 当前编译格式需要的操作码配置 / Opcode profile required by the current compiled format

Parameters

op	解码后的运行期操作码 / Decoded runtime opcode

Returns: 返回该操作码对应特化路径的运行结果 / Returns the specialized runtime result for that opcode

Template Parameters

Profile 当前编译格式需要的操作码配置 / Opcode profile required by the current compiled format

Parameters

op	Decoded runtime opcode. / 解码后的运行期操作码。

Returns: Returns the specialized runtime result for that opcode. / 返回该操作码对应特化路径的运行结果。

Definition at line 62 of file writer_executor_opcode.hpp.

{
  switch (op)
  {
    case FormatOp::TextInline:
      return WriteRaw(codes_.ReadInlineText());
    case FormatOp::TextRef:
      return WriteRaw(codes_.ReadTextRef());
    case FormatOp::TextSpace:
      return WriteRaw(" ");
    case FormatOp::U32Dec:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Dec(args_.Read<uint32_t>());
    case FormatOp::I32Dec:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteI32Dec(args_.Read<int32_t>());
    case FormatOp::U32ZeroPadWidth:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32ZeroPadWidth(codes_.Read<uint8_t>(), args_.Read<uint32_t>());
    case FormatOp::U32Binary:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Base<2>(args_.Read<uint32_t>());
    case FormatOp::U32Octal:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Base<8>(args_.Read<uint32_t>());
    case FormatOp::U32HexLower:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Base<16>(args_.Read<uint32_t>());
    case FormatOp::U32HexUpper:
      if constexpr (!HasProfile(Profile, FormatProfile::NarrowInt) ||
                    !Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Base<16, true>(args_.Read<uint32_t>());
    case FormatOp::StringRaw:
      if constexpr (!HasProfile(Profile, FormatProfile::TextArg) || !Config::enable_text)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteStringRaw(args_.Read<std::string_view>());
    case FormatOp::CharacterRaw:
      if constexpr (!HasProfile(Profile, FormatProfile::TextArg) || !Config::enable_text)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteCharacterRaw(args_.Read<char>());
    case FormatOp::GenericField:
      if constexpr (!HasProfile(Profile, FormatProfile::Generic))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchGenericField<Profile>(codes_.ReadFormatType());
    case FormatOp::End:
    default:
      return ErrorCode::STATE_ERR;
  }
}

◆ DispatchPointerField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::DispatchPointerField ( )

nodiscardprivate

读取一个指针载荷并走指针字段写出路径 / Read one pointer payload and write it through the pointer field path

Returns: 返回指针字段写出结果 / Returns the pointer-field write result

Definition at line 58 of file writer_executor_generic.hpp.

{
  return WritePointer(codes_.ReadSpec(), args_.Read<uintptr_t>());
}

◆ DispatchSignedField()

template<OutputSink Sink>

template<std::signed_integral Int>

ErrorCode Writer::Executor< Sink >::DispatchSignedField ( )

nodiscardprivate

运行期执行器中 GenericField 的分发桥接函数 / GenericField dispatch bridges for the runtime executor

读取一个有符号载荷并转发给具体有符号写出路径 / Read one signed payload and forward it to the concrete signed writer

Template Parameters

Int	有符号打包存储类型 / Signed packed-storage type

Returns: 返回具体有符号字段写出结果 / Returns the concrete signed-field write result

Definition at line 16 of file writer_executor_generic.hpp.

{
  return WriteSigned(codes_.ReadSpec(), args_.Read<Int>());
}

◆ DispatchStringField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::DispatchStringField ( )

nodiscardprivate

读取一个字符串载荷并走字符串字段写出路径 / Read one string payload and write it through the string field path

Returns: 返回字符串字段写出结果 / Returns the string-field write result

Definition at line 80 of file writer_executor_generic.hpp.

{
  return WriteString(codes_.ReadSpec(), args_.Read<std::string_view>());
}

◆ DispatchUnsigned()

template<OutputSink Sink>

template<FormatType Type, std::unsigned_integral UInt>

ErrorCode Writer::Executor< Sink >::DispatchUnsigned	(	const Spec &	spec,
		UInt	value )

nodiscardprivate

通过共享整数字段路径写出一个无符号整数语义值 / Write one unsigned integer semantic value through the shared integer-field path

Template Parameters

Type	运行期整数语义类型 / Runtime integer semantic type
UInt	无符号整数类型 / Unsigned integer type

Parameters

spec	解码后的字段规格 / Decoded field spec
value	待写出的整数值 / Integer value to write

Returns: 返回共享整数字段路径的写出结果 / Returns the shared integer-field write result

This bridge does not format digits itself; it only maps one runtime integer semantic type onto the shared compile-time radix/case helper above. 这个桥接函数本身不直接格式化数字；它只负责把运行期整数语义类型映射到上面的编译期进制/大小写共享辅助路径。

Definition at line 150 of file writer_executor_value.hpp.

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

◆ DispatchUnsignedField()

template<OutputSink Sink>

template<FormatType Type, std::unsigned_integral UInt>

ErrorCode Writer::Executor< Sink >::DispatchUnsignedField ( )

nodiscardprivate

读取一个无符号载荷并转发给选定的整数语义写出路径 / Read one unsigned payload and forward it to the selected integer semantic writer

Template Parameters

Type	运行期整数语义类型 / Runtime integer semantic type
UInt	无符号打包存储类型 / Unsigned packed-storage type

Returns: 返回选定整数语义路径的写出结果 / Returns the selected integer-field write result

Definition at line 31 of file writer_executor_generic.hpp.

{
  return DispatchUnsigned<Type>(codes_.ReadSpec(), args_.Read<UInt>());
}

◆ ResolveSignChar()

template<OutputSink Sink>

template<std::signed_integral Int>

char Writer::Executor< Sink >::ResolveSignChar	(	Int	value,
		const Spec &	spec )

staticnodiscardprivate

执行器的具体运行期数值写出函数 / Concrete runtime value writers for the executor

为一个有符号整数载荷确定最终可见的符号字符 / Resolve the visible sign character for one signed integer payload

Template Parameters

Int	有符号整数类型 / Signed integer type

Parameters

value	当前要输出的整数值 / Integer value being emitted
spec	解码后的字段规格 / Decoded field spec

Returns: 返回 ‘’-'、'+'、' '或'\0'/ Returns'-','+',' ', or'\0'`

Definition at line 17 of file writer_executor_value.hpp.

{
  if (value < 0)
  {
    return '-';
  }
  if (spec.ForceSign())
  {
    return '+';
  }
  if (spec.SpaceSign())
  {
    return ' ';
  }
  return '\0';
}

◆ Run()

template<OutputSink Sink>

template<FormatProfile Profile>

ErrorCode Writer::Executor< Sink >::Run ( )

nodiscard

持续执行记录流，直到遇到 FormatOp::End / Run until the compiled record stream reaches FormatOp::End

运行操作码循环，直到遇到 End 或首个 sink/运行期错误 / Runs the opcode loop until End or the first sink/runtime error.

Template Parameters

Profile 当前编译格式需要的操作码配置 / Opcode profile required by the current compiled format

Returns: 返回首个 sink 或运行期错误；正常执行到记录流结束时返回 ErrorCode::OK / Returns the first sink or runtime error, or ErrorCode::OK when the record stream finishes normally

Template Parameters

Profile 当前编译格式需要的操作码配置 / Opcode profile required by the current compiled format

Returns: Returns ErrorCode::OK on normal completion, or the first sink / runtime error. / 正常结束返回 ErrorCode::OK；否则返回首个 sink/运行期错误。

Definition at line 33 of file writer_executor_opcode.hpp.

{
  while (true)
  {
    auto op = codes_.ReadOp();
    if (op == FormatOp::End)
    {
      return ErrorCode::OK;
    }
 
    auto ec = DispatchOp<Profile>(op);
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
  }
}

◆ WriteCharacter()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteCharacter	(	const Spec &	spec,
		char	ch )

nodiscardprivate

写出一个字符字段值 / Write one character field value

Parameters

spec	解码后的字段规格 / Decoded field spec
ch	待写出的字符值 / Character value to write

Returns: 返回字符字段写出结果 / Returns the character-field write result

Definition at line 208 of file writer_executor_value.hpp.

{
  return WriteTextField(std::string_view(&ch, 1), spec);
}

◆ WriteCharacterRaw()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteCharacterRaw ( char ch )

nodiscardprivate

单个原始字符参数的快路径。 / Fast path for one raw character argument.

写出一个原始字符快路径字段 / Writes one raw character fast-path field.

Parameters

ch	Character payload to write. / 待写出的字符载荷。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 393 of file writer_executor_value.hpp.

{
  return WriteRaw(std::string_view(&ch, 1));
}

◆ WriteFloatField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteFloatField	(	char	sign_char,
		std::string_view	text,
		const Spec &	spec )

nodiscardprivate

按符号与字段填充策略写出一个浮点文本载荷 / Write one float text payload with sign and field padding applied

Parameters

sign_char 最终可见的符号字符；无符号时为 ‘’\0'/ Visible sign character, or '\0'when absent @param text 已完成格式化的浮点文本载荷 / Already formatted float text payload @param spec 解码后的字段规格 / Decoded field spec @return 返回首个 sink 错误；成功时返回ErrorCode::OK/ Returns the first sink error, orErrorCode::OK` on success

Definition at line 184 of file writer_executor_field.hpp.

{
  auto write_char = [this](char ch) -> ErrorCode
  {
    if (ch == '\0')
    {
      return ErrorCode::OK;
    }
    return WriteRaw(std::string_view(&ch, 1));
  };
 
  size_t total = text.size() + static_cast<size_t>(sign_char != '\0');
  size_t pad = FieldPadding(spec.width, total);
  bool zero_fill = spec.ZeroPad() && !spec.LeftAlign() && !spec.CenterAlign();
  size_t left_pad = 0;
  size_t middle_zeros = zero_fill ? pad : 0;
  size_t right_pad = 0;
  if (!zero_fill)
  {
    if (spec.LeftAlign())
    {
      right_pad = pad;
    }
    else if (spec.CenterAlign())
    {
      left_pad = pad / 2;
      right_pad = pad - left_pad;
    }
    else
    {
      left_pad = pad;
    }
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_char(sign_char); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', middle_zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WriteRaw(text); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}

◆ WriteI32Dec()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteI32Dec ( int32_t value )

nodiscardprivate

单个原始 int32_t 十进制字段的快路径。 / Fast path for one raw int32_t decimal field.

写出一个原始 int32 十进制快路径字段 / Writes one raw int32 decimal fast-path field.

Parameters

value Signed value to write. / 待写出的有符号值。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 320 of file writer_executor_value.hpp.

{
  using UInt = std::make_unsigned_t<int32_t>;
  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);
 
  if (value < 0)
  {
    if (auto ec = WriteRaw("-"); ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}

◆ WriteIntegerField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteIntegerField	(	char	sign_char,
		std::string_view	prefix,
		std::string_view	digits,
		const Spec &	spec )

nodiscardprivate

按符号、前缀、精度与填充策略写出一个整数载荷 / Write one integer payload with sign, prefix, precision, and padding policy applied

Parameters

sign_char 最终可见的符号字符；无符号时为 ‘’\0'/ Visible sign character, or '\0'when absent @param prefix 输出在数字前面的前缀 / Prefix emitted ahead of the digits @param digits 十进制、二进制、八进制或十六进制数字载荷 / Decimal, binary, octal, or hex digit payload @param spec 解码后的字段规格 / Decoded field spec @return 返回首个 sink 错误；成功时返回ErrorCode::OK/ Returns the first sink error, orErrorCode::OK` on success

Definition at line 98 of file writer_executor_field.hpp.

{
  auto write_char = [this](char ch) -> ErrorCode
  {
    if (ch == '\0')
    {
      return ErrorCode::OK;
    }
    return WriteRaw(std::string_view(&ch, 1));
  };
  auto write_text = [this](std::string_view text) -> ErrorCode
  {
    if (text.empty())
    {
      return ErrorCode::OK;
    }
    return WriteRaw(text);
  };
 
  size_t zeros = IntegerPrecisionZeros(spec, digits.size());
  size_t total =
      digits.size() + zeros + prefix.size() + static_cast<size_t>(sign_char != '\0');
  size_t pad = FieldPadding(spec.width, total);
  bool zero_fill =
      spec.ZeroPad() && !spec.LeftAlign() && !spec.CenterAlign() && !spec.HasPrecision();
  size_t left_pad = 0;
  size_t middle_zeros = zero_fill ? pad : 0;
  size_t right_pad = 0;
  if (!zero_fill)
  {
    if (spec.LeftAlign())
    {
      right_pad = pad;
    }
    else if (spec.CenterAlign())
    {
      left_pad = pad / 2;
      right_pad = pad - left_pad;
    }
    else
    {
      left_pad = pad;
    }
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_char(sign_char); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_text(prefix); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', middle_zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_text(digits); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}

◆ WritePadding()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WritePadding	(	char	fill,
		size_t	count )

nodiscardprivate

向输出端写入重复填充字符 / Write repeated fill characters into the sink

Parameters

fill	填充字符 / Fill character
count	重复次数 / Repeat count

Returns: 返回首个 sink 错误；全部填充字节写出后返回 ErrorCode::OK / Returns the first sink error, or ErrorCode::OK when all fill bytes are written

Definition at line 27 of file writer_executor_field.hpp.

{
  char chunk[16];
  std::memset(chunk, fill, sizeof(chunk));
 
  while (count != 0)
  {
    size_t step = (count < sizeof(chunk)) ? count : sizeof(chunk);
    auto ec = WriteRaw(std::string_view(chunk, step));
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
    count -= step;
  }
 
  return ErrorCode::OK;
}

◆ WritePointer()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WritePointer	(	const Spec &	spec,
		uintptr_t	value )

nodiscardprivate

按规范指针字段策略写出一个指针值 / Write one pointer value using the canonical pointer field policy

Parameters

spec	解码后的字段规格 / Decoded field spec
value	以 `uintptr_t` 编码的指针值 / Pointer value encoded as `uintptr_t`

Returns: 返回指针字段写出结果 / Returns the pointer-field write result

Definition at line 186 of file writer_executor_value.hpp.

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

◆ WriteRaw()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteRaw ( std::string_view text )

nodiscardprivate

运行期执行器共享的字段写出原语，供所有操作码路径复用 / Executor-side field-writing primitives shared by all runtime opcodes

将一段原始文本直接写入输出端 / Write one raw text chunk directly into the sink

Parameters

text	Text chunk to write. / 待写出的文本片段。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 14 of file writer_executor_field.hpp.

{
  return sink_.Write(text);
}

◆ WriteSigned()

template<OutputSink Sink>

template<std::signed_integral Int>

ErrorCode Writer::Executor< Sink >::WriteSigned	(	const Spec &	spec,
		Int	value )

nodiscardprivate

通过共享整数字段路径写出一个有符号整数值 / Write one signed integer value through the shared integer-field path

Template Parameters

Int	有符号整数类型 / Signed integer type

Parameters

spec	解码后的字段规格 / Decoded field spec
value	待写出的整数值 / Integer value to write

Returns: 返回共享整数字段路径的写出结果 / Returns the shared integer-field write result

Definition at line 81 of file writer_executor_value.hpp.

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

◆ WriteString()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteString	(	const Spec &	spec,
		std::string_view	text )

nodiscardprivate

写出一个字符串字段值，并在需要时应用精度截断 / Write one string field value, including precision truncation when present

Parameters

spec	解码后的字段规格 / Decoded field spec
text	待写出的字符串载荷 / String payload to write

Returns: 返回字符串字段写出结果 / Returns the string-field write result

Definition at line 221 of file writer_executor_value.hpp.

{
  auto view = text;
  if (spec.HasPrecision() && spec.precision < view.size())
  {
    view = view.substr(0, spec.precision);
  }
 
  return WriteTextField(view, spec);
}

◆ WriteStringRaw()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteStringRaw ( std::string_view text )

nodiscardprivate

单个原始字符串参数的快路径。 / Fast path for one raw string argument.

写出一个原始字符串快路径字段 / Writes one raw string fast-path field.

Parameters

text	String payload to write. / 待写出的字符串载荷。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 382 of file writer_executor_value.hpp.

{
  return WriteRaw(text);
}

◆ WriteTextField()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteTextField	(	std::string_view	text,
		const Spec &	spec )

nodiscardprivate

按宽度与对齐策略写出一个文本字段 / Write one text field with width/alignment policy applied

Parameters

text	上层归一化后的文本载荷 / Text payload after higher-level normalization
spec	解码后的字段规格 / Decoded field spec

Returns: 返回首个 sink 错误；成功时返回 ErrorCode::OK / Returns the first sink error, or ErrorCode::OK on success

Definition at line 55 of file writer_executor_field.hpp.

{
  size_t pad = FieldPadding(spec.width, text.size());
  size_t left_pad = 0;
  size_t right_pad = 0;
  if (spec.LeftAlign())
  {
    right_pad = pad;
  }
  else if (spec.CenterAlign())
  {
    left_pad = pad / 2;
    right_pad = pad - left_pad;
  }
  else
  {
    left_pad = pad;
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WriteRaw(text); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}

◆ WriteU32Base()

template<OutputSink Sink>

template<uint8_t Base, bool UpperCase>

ErrorCode Writer::Executor< Sink >::WriteU32Base ( uint32_t value )

nodiscardprivate

单个原始 uint32_t 非十进制字段的快路径。 / Fast path for one raw uint32_t non-decimal field.

写出一个原始 uint32 多进制快路径字段 / Writes one raw uint32 base-specific fast-path field.

Template Parameters

Base	Integer radix. / 整数进制。
UpperCase	Whether hexadecimal digits are uppercase. / 十六进制数字是否大写。

Parameters

value Unsigned value to write. / 待写出的无符号值。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 349 of file writer_executor_value.hpp.

{
  char digit_buffer[UnsignedDigitCapacity<uint32_t, Base>()];
  size_t digit_count = AppendUnsigned<Base, UpperCase>(digit_buffer, value);
  return WriteRaw(std::string_view(digit_buffer, digit_count));
}

◆ WriteU32Dec()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteU32Dec ( uint32_t value )

nodiscardprivate

单个原始 uint32_t 十进制字段的快路径。 / Fast path for one raw uint32_t decimal field.

通过共享浮点文本后端写出一个浮点语义值 / Write one float semantic value through the shared float-text backend

Template Parameters

T	浮点类型 / Float type

Parameters

type	运行期浮点语义类型 / Runtime float semantic type
spec	解码后的字段规格 / Decoded field spec
value	待写出的浮点值 / Float value to write

Returns: 返回浮点字段写出结果 / Returns the float-field write result

写出一个原始 uint32 十进制快路径字段 / Writes one raw uint32 decimal fast-path field.

Parameters

value Unsigned value to write. / 待写出的无符号值。

Returns: Returns the sink write result. / 返回 sink 写出结果。

Definition at line 306 of file writer_executor_value.hpp.

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

◆ WriteU32ZeroPadWidth()

template<OutputSink Sink>

ErrorCode Writer::Executor< Sink >::WriteU32ZeroPadWidth	(	uint8_t	width,
		uint32_t	value )

nodiscardprivate

单个零填充 uint32_t 十进制字段的快路径。 / Fast path for one zero-padded uint32_t decimal field.

写出一个带零填充宽度的 uint32_t 十进制快路径字段 / Write one zero-padded uint32_t decimal fast-path field

Parameters

width	目标零填充宽度 / Target zero-padded width
value	待写出的无符号值 / Unsigned value to write

Returns: 返回该快路径的写出结果 / Returns the fast-path write result

Definition at line 364 of file writer_executor_value.hpp.

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

◆ WriteUnsignedDigits()

template<OutputSink Sink>

template<uint8_t Base, bool UpperCase, bool PrependOctalZero, std::unsigned_integral UInt>

ErrorCode Writer::Executor< Sink >::WriteUnsignedDigits	(	std::string_view	prefix,
		const Spec &	spec,
		UInt	value )

nodiscardprivate

按编译期进制/大小写/八进制备用格式参数复用无符号数字载荷写出逻辑 / Reuse the unsigned-digit payload writer with compile-time radix, case, and octal-alternate parameters

通过共享整数字段路径写出一个无符号整数语义值 / Write one unsigned integer semantic value through the shared integer-field path

Template Parameters

Base	整数进制 / Integer radix
UpperCase	十六进制数字是否使用大写字符 / Whether hexadecimal digits should use uppercase characters
PrependOctalZero	是否把 `%#o` 的前导 `0` 直接并入数字载荷 / Whether `%#o` should inline its leading `0` into the digit payload
UInt	无符号整数类型 / Unsigned integer type

Parameters

prefix	脱离数字载荷输出的前缀 / Prefix emitted outside the digit payload
spec	解码后的字段规格 / Decoded field spec
value	待写出的整数值 / Integer value to write

Returns: 返回共享无符号数字写出路径的结果 / Returns the shared unsigned-digit write result

Template Parameters

Base	整数进制 / Integer radix
UpperCase	十六进制数字是否使用大写字符 / Whether hexadecimal digits should use uppercase characters
PrependOctalZero	是否把 `%#o` 的前导 `0` 直接并入数字载荷 / Whether `%#o` should inline its leading `0` into the digit payload
UInt	无符号整数类型 / Unsigned integer type

Parameters

prefix	脱离数字载荷输出的前缀 / Prefix emitted outside the digit payload
spec	解码后的字段规格 / Decoded field spec
value	待写出的整数值 / Integer value to write

Returns: 返回共享整数字段路径的写出结果 / Returns the shared integer-field write result

Definition at line 115 of file writer_executor_value.hpp.

{
  char digit_buffer[UnsignedDigitCapacity<UInt, Base>() + (PrependOctalZero ? 1U : 0U)];
  size_t digit_count = AppendUnsigned<Base, UpperCase>(digit_buffer, value);
 
  if constexpr (PrependOctalZero)
  {
    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);
}

Field Documentation

◆ args_

template<OutputSink Sink>

ArgumentReader Writer::Executor< Sink >::args_

private

Definition at line 172 of file writer_executor.hpp.

◆ codes_

template<OutputSink Sink>

CodeReader Writer::Executor< Sink >::codes_

private

Definition at line 171 of file writer_executor.hpp.

◆ sink_

template<OutputSink Sink>

Sink& Writer::Executor< Sink >::sink_

private

Definition at line 170 of file writer_executor.hpp.

The documentation for this class was generated from the following files:

src/core/print/writer/writer_executor.hpp
src/core/print/writer/writer_executor_field.hpp
src/core/print/writer/writer_executor_generic.hpp
src/core/print/writer/writer_executor_opcode.hpp
src/core/print/writer/writer_executor_value.hpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Executor()

Member Function Documentation

◆ DispatchCharacterField()

◆ DispatchGenericField()

◆ DispatchOp()

◆ DispatchPointerField()

◆ DispatchSignedField()

◆ DispatchStringField()

◆ DispatchUnsigned()

◆ DispatchUnsignedField()

◆ ResolveSignChar()

◆ Run()

◆ WriteCharacter()

◆ WriteCharacterRaw()

◆ WriteFloatField()

◆ WriteI32Dec()

◆ WriteIntegerField()

◆ WritePadding()

◆ WritePointer()

◆ WriteRaw()

◆ WriteSigned()

◆ WriteString()

◆ WriteStringRaw()

◆ WriteTextField()

◆ WriteU32Base()

◆ WriteU32Dec()

◆ WriteU32ZeroPadWidth()

◆ WriteUnsignedDigits()

Field Documentation

◆ args_

◆ codes_

◆ sink_