按编译格式 profile 特化的、按输出端类型区分的字节码执行器 / Per-sink bytecode executor specialized by the compiled format profile More...

#include <writer_executor.hpp>

Collaboration diagram for Writer::Executor< Sink, Profile >:

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

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	WriteUnsigned (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 InlineAlternateOctal = 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

template<typename T >
ErrorCode	WriteFloat (FormatType type, const Spec &spec, T value)
	通过共享浮点文本后端写出一个浮点语义值 / Write one float semantic value through the shared float-text backend

ErrorCode	WriteU32Dec (uint32_t value)
	单个原始 uint32_t 十进制字段的快路径。 / Fast path for one raw uint32_t 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	WriteF32FixedPrec (uint8_t precision, float value)
	单个带显式精度的定点 float 快路径。 / Fast path for one fixed float with explicit precision.

ErrorCode	WriteF64FixedPrec (uint8_t precision, double value)
	单个带显式精度的定点 double 快路径。 / Fast path for one fixed double with explicit precision.

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

template<FormatType Type, typename Float >
ErrorCode	DispatchFloatField ()
	读取一个浮点载荷并转发给选定的浮点语义写出路径 / Read one float payload and forward it to the selected float 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

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

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

template<typename T >
static char	ResolveFloatSignChar (T value, const Spec &spec)
	为一个浮点载荷确定最终可见的符号字符 / Resolve the visible sign character for one float payload

Private Attributes
Sink &	sink_

CodeReader	codes_

ArgumentReader	args_

Detailed Description

template<OutputSink Sink, FormatProfile Profile>
class Writer::Executor< Sink, Profile >

按编译格式 profile 特化的、按输出端类型区分的字节码执行器 / Per-sink bytecode executor specialized by the compiled format profile

Definition at line 7 of file writer_executor.hpp.

Constructor & Destructor Documentation

◆ Executor()

template<OutputSink Sink, FormatProfile Profile>

Writer::Executor< Sink, Profile >::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 14 of file writer_executor_opcode.hpp.

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

Member Function Documentation

◆ DispatchCharacterField()

template<OutputSink Sink, FormatProfile Profile>

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

nodiscardprivate

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

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

Definition at line 60 of file writer_executor_generic.hpp.

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

◆ DispatchFloatField()

template<OutputSink Sink, FormatProfile Profile>

template<FormatType Type, typename Float >

ErrorCode Writer::Executor< Sink, Profile >::DispatchFloatField ( )

nodiscardprivate

读取一个浮点载荷并转发给选定的浮点语义写出路径 / Read one float payload and forward it to the selected float semantic writer

Template Parameters

Type	运行期浮点语义类型 / Runtime float semantic type
Float	打包浮点存储类型 / Packed float storage type

Returns: 返回选定浮点语义路径的写出结果 / Returns the selected float-field write result

Definition at line 40 of file writer_executor_generic.hpp.

{
  return WriteFloat(Type, codes_.ReadSpec(), args_.Read<Float>());
}

◆ DispatchGenericField()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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

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 81 of file writer_executor_generic.hpp.

{
  switch (type)
  {
    case FormatType::Signed32:
      if constexpr (!Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchSignedField<int32_t>();
    case FormatType::Signed64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchSignedField<int64_t>();
    case FormatType::Unsigned32:
      if constexpr (!Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Unsigned32, uint32_t>();
    case FormatType::Unsigned64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Unsigned64, uint64_t>();
    case FormatType::Binary32:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Binary32, uint32_t>();
    case FormatType::Binary64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16 ||
                    !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Binary64, uint64_t>();
    case FormatType::Octal32:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Octal32, uint32_t>();
    case FormatType::Octal64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16 ||
                    !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::Octal64, uint64_t>();
    case FormatType::HexLower32:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::HexLower32, uint32_t>();
    case FormatType::HexLower64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16 ||
                    !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::HexLower64, uint64_t>();
    case FormatType::HexUpper32:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::HexUpper32, uint32_t>();
    case FormatType::HexUpper64:
      if constexpr (!Config::enable_integer || !Config::enable_integer_base8_16 ||
                    !Config::enable_integer_64bit)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchUnsignedField<FormatType::HexUpper64, uint64_t>();
    case FormatType::Pointer:
      if constexpr (!Config::enable_pointer)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchPointerField();
    case FormatType::Character:
      if constexpr (!Config::enable_text)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchCharacterField();
    case FormatType::String:
      if constexpr (!Config::enable_text)
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchStringField();
    case FormatType::FloatFixed:
      if constexpr (!FloatEnabled(FormatType::FloatFixed))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::FloatFixed, float>();
    case FormatType::DoubleFixed:
      if constexpr (!FloatEnabled(FormatType::DoubleFixed))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::DoubleFixed, double>();
    case FormatType::FloatScientific:
      if constexpr (!FloatEnabled(FormatType::FloatScientific))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::FloatScientific, float>();
    case FormatType::DoubleScientific:
      if constexpr (!FloatEnabled(FormatType::DoubleScientific))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::DoubleScientific, double>();
    case FormatType::FloatGeneral:
      if constexpr (!FloatEnabled(FormatType::FloatGeneral))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::FloatGeneral, float>();
    case FormatType::DoubleGeneral:
      if constexpr (!FloatEnabled(FormatType::DoubleGeneral))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::DoubleGeneral, double>();
    case FormatType::LongDoubleFixed:
      if constexpr (!FloatEnabled(FormatType::LongDoubleFixed))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::LongDoubleFixed, long double>();
    case FormatType::LongDoubleScientific:
      if constexpr (!FloatEnabled(FormatType::LongDoubleScientific))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::LongDoubleScientific, long double>();
    case FormatType::LongDoubleGeneral:
      if constexpr (!FloatEnabled(FormatType::LongDoubleGeneral))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchFloatField<FormatType::LongDoubleGeneral, long double>();
    case FormatType::TextInline:
    case FormatType::TextRef:
    case FormatType::TextSpace:
    case FormatType::End:
    default:
      return ErrorCode::STATE_ERR;
  }
}

◆ DispatchOp()

template<OutputSink Sink, FormatProfile Profile>

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

nodiscardprivate

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

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

Parameters

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

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

Parameters

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

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

Definition at line 54 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::U32) ||
                    !Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32Dec(args_.Read<uint32_t>());
    case FormatOp::U32ZeroPadWidth:
      if constexpr (!HasProfile(Profile, FormatProfile::U32) ||
                    !Config::enable_integer)
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteU32ZeroPadWidth(codes_.Read<uint8_t>(), 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::F32FixedPrec:
      if constexpr (!HasProfile(Profile, FormatProfile::F32Fixed) ||
                    !FloatEnabled(FormatType::FloatFixed))
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteF32FixedPrec(codes_.Read<uint8_t>(), args_.Read<float>());
    case FormatOp::F64FixedPrec:
      if constexpr (!HasProfile(Profile, FormatProfile::F64Fixed) ||
                    !FloatEnabled(FormatType::DoubleFixed))
      {
        return ErrorCode::STATE_ERR;
      }
      return WriteF64FixedPrec(codes_.Read<uint8_t>(), args_.Read<double>());
    case FormatOp::GenericField:
      if constexpr (!HasProfile(Profile, FormatProfile::Generic))
      {
        return ErrorCode::STATE_ERR;
      }
      return DispatchGenericField(codes_.ReadFormatType());
    case FormatOp::End:
    default:
      return ErrorCode::STATE_ERR;
  }
}

◆ DispatchPointerField()

template<OutputSink Sink, FormatProfile Profile>

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

nodiscardprivate

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

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

Definition at line 50 of file writer_executor_generic.hpp.

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

◆ DispatchSignedField()

template<OutputSink Sink, FormatProfile Profile>

template<std::signed_integral Int>

ErrorCode Writer::Executor< Sink, Profile >::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 14 of file writer_executor_generic.hpp.

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

◆ DispatchStringField()

template<OutputSink Sink, FormatProfile Profile>

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

nodiscardprivate

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

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

Definition at line 70 of file writer_executor_generic.hpp.

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

◆ DispatchUnsignedField()

template<OutputSink Sink, FormatProfile Profile>

template<FormatType Type, std::unsigned_integral UInt>

ErrorCode Writer::Executor< Sink, Profile >::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 27 of file writer_executor_generic.hpp.

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

◆ ResolveFloatSignChar()

template<OutputSink Sink, FormatProfile Profile>

template<typename T >

char Writer::Executor< Sink, Profile >::ResolveFloatSignChar	(	T	value,
		const Spec &	spec )

staticnodiscardprivate

为一个浮点载荷确定最终可见的符号字符 / Resolve the visible sign character for one float payload

Template Parameters

T	浮点类型 / Float type

Parameters

value	当前要输出的浮点值 / Float value being emitted
spec	解码后的字段规格 / Decoded field spec

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

Definition at line 42 of file writer_executor_value.hpp.

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

◆ ResolveSignChar()

template<OutputSink Sink, FormatProfile Profile>

template<std::signed_integral Int>

char Writer::Executor< Sink, Profile >::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 16 of file writer_executor_value.hpp.

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

◆ Run()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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.

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

Definition at line 29 of file writer_executor_opcode.hpp.

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

◆ WriteCharacter()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 193 of file writer_executor_value.hpp.

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

◆ WriteF32FixedPrec()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::WriteF32FixedPrec	(	uint8_t	precision,
		float	value )

nodiscardprivate

单个带显式精度的定点 float 快路径。 / Fast path for one fixed float with explicit precision.

写出一个 float32 定点精度快路径字段 / Write one float32 fixed-precision fast-path field

Parameters

precision	显式定点精度 / Explicit fixed precision
value	待写出的浮点值 / Float value to write

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

Definition at line 326 of file writer_executor_value.hpp.

{
  char sign_char = std::signbit(value) ? '-' : '\0';
  float magnitude = std::signbit(value) ? -value : value;
  if (ExceedsFixedIntegerDigits(magnitude, precision))
  {
    return ErrorCode::OUT_OF_RANGE;
  }
  char output_buffer[float_buffer_capacity];
  size_t output_size = 0;
  if (!FormatF32FixedPrecText(magnitude, precision, output_buffer, output_size))
  {
    return ErrorCode::NO_BUFF;
  }
 
  if (sign_char != '\0')
  {
    if (auto ec = WriteRaw(std::string_view(&sign_char, 1)); ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  return WriteRaw(std::string_view(output_buffer, output_size));
}

◆ WriteF64FixedPrec()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::WriteF64FixedPrec	(	uint8_t	precision,
		double	value )

nodiscardprivate

单个带显式精度的定点 double 快路径。 / Fast path for one fixed double with explicit precision.

通过通用浮点写出路径写出一个 double 定点精度字段 / Write one double fixed-precision field through the generic float writer

Parameters

precision	显式定点精度 / Explicit fixed precision
value	待写出的 double 值 / Double value to write

Returns: 返回通用浮点写出路径的结果 / Returns the generic float-writer result

Definition at line 360 of file writer_executor_value.hpp.

{
  return WriteFloat(FormatType::DoubleFixed, Spec{.precision = precision}, value);
}

◆ WriteFloat()

template<OutputSink Sink, FormatProfile Profile>

template<typename T >

ErrorCode Writer::Executor< Sink, Profile >::WriteFloat	(	FormatType	type,
		const Spec &	spec,
		T	value )

nodiscardprivate

通过共享浮点文本后端写出一个浮点语义值 / 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

Definition at line 227 of file writer_executor_value.hpp.

{
  if (!UsesFloatTextBackend(type))
  {
    return ErrorCode::ARG_ERR;
  }
 
  char sign_char = ResolveFloatSignChar(value, spec);
  T magnitude = std::signbit(value) ? -static_cast<T>(value) : static_cast<T>(value);
  uint8_t precision = spec.HasPrecision() ? spec.precision : DefaultFloatPrecision();
  if (type == FormatType::FloatFixed || type == FormatType::DoubleFixed ||
      type == FormatType::LongDoubleFixed)
  {
    if (ExceedsFixedIntegerDigits(magnitude, precision))
    {
      return ErrorCode::OUT_OF_RANGE;
    }
  }
  else if (type == FormatType::FloatGeneral || type == FormatType::DoubleGeneral ||
           type == FormatType::LongDoubleGeneral)
  {
    uint8_t significant = precision == 0 ? 1 : precision;
    int exponent = (magnitude == 0) ? 0 : NormalizeDecimal(magnitude).exponent;
    if (!(exponent < -4 || exponent >= significant))
    {
      int fractional_precision = static_cast<int>(significant) - (exponent + 1);
      if (fractional_precision < 0)
      {
        fractional_precision = 0;
      }
      if (ExceedsFixedIntegerDigits(magnitude,
                                    static_cast<uint8_t>(fractional_precision)))
      {
        return ErrorCode::OUT_OF_RANGE;
      }
    }
  }
  char output_buffer[float_buffer_capacity];
  size_t output_size = 0;
  if (!FormatFloatText(type, spec, magnitude, output_buffer, output_size))
  {
    return ErrorCode::NO_BUFF;
  }
 
  return WriteFloatField(sign_char, std::string_view(output_buffer, output_size), spec);
}

◆ WriteFloatField()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 170 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);
}

◆ WriteIntegerField()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 91 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 25 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 170 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 13 of file writer_executor_field.hpp.

{
  return sink_.Write(text);
}

◆ WriteSigned()

template<OutputSink Sink, FormatProfile Profile>

template<std::signed_integral Int>

ErrorCode Writer::Executor< Sink, Profile >::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 68 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 205 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 314 of file writer_executor_value.hpp.

{
  return WriteRaw(text);
}

◆ WriteTextField()

template<OutputSink Sink, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 51 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);
}

◆ WriteU32Dec()

template<OutputSink Sink, FormatProfile Profile>

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

nodiscardprivate

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

写出一个原始 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 281 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, FormatProfile Profile>

ErrorCode Writer::Executor< Sink, Profile >::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 295 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));
}

◆ WriteUnsigned()

template<OutputSink Sink, FormatProfile Profile>

template<FormatType Type, std::unsigned_integral UInt>

ErrorCode Writer::Executor< Sink, Profile >::WriteUnsigned	(	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 135 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;
}

◆ WriteUnsignedDigits()

template<OutputSink Sink, FormatProfile Profile>

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

ErrorCode Writer::Executor< Sink, Profile >::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
InlineAlternateOctal	是否把 `%#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
InlineAlternateOctal	是否把 `%#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 99 of file writer_executor_value.hpp.

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

ArgumentReader Writer::Executor< Sink, Profile >::args_

private

Definition at line 131 of file writer_executor.hpp.

◆ codes_

template<OutputSink Sink, FormatProfile Profile>

CodeReader Writer::Executor< Sink, Profile >::codes_

private

Definition at line 130 of file writer_executor.hpp.

◆ sink_

template<OutputSink Sink, FormatProfile Profile>

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

private

Definition at line 129 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()

◆ DispatchFloatField()

◆ DispatchGenericField()

◆ DispatchOp()

◆ DispatchPointerField()

◆ DispatchSignedField()

◆ DispatchStringField()

◆ DispatchUnsignedField()

◆ ResolveFloatSignChar()

◆ ResolveSignChar()

◆ Run()

◆ WriteCharacter()

◆ WriteF32FixedPrec()

◆ WriteF64FixedPrec()

◆ WriteFloat()

◆ WriteFloatField()

◆ WriteIntegerField()

◆ WritePadding()

◆ WritePointer()

◆ WriteRaw()

◆ WriteSigned()

◆ WriteString()

◆ WriteStringRaw()

◆ WriteTextField()

◆ WriteU32Dec()

◆ WriteU32ZeroPadWidth()

◆ WriteUnsigned()

◆ WriteUnsignedDigits()

Field Documentation

◆ args_

◆ codes_

◆ sink_