Struct IoWriteSink 

pub struct IoWriteSink<'a, W: ?Sized> { /* private fields */ }

JsonWrite sink that forwards to any std::io::Write implementor.

The natural target for serializing JSON to a file, socket, or other byte stream. Errors propagate through the sink’s Self::Error, which is std::io::Error.

Implementations

impl<'a, W: Write + ?Sized> IoWriteSink<'a, W>

pub const fn new(out: &'a mut W) -> Self

Trait Implementations

impl<'a, W: Debug + ?Sized> Debug for IoWriteSink<'a, W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W: Write + ?Sized> JsonWrite for IoWriteSink<'_, W>

Available on crate feature std only.

type Error = Error

Sink-specific error type. StringSink uses core::convert::Infallible for the byte/string writes; the typed-level to_string entry point widens to crate::Error so non-finite floats can surface.

fn write_byte(&mut self, b: u8) -> Result<(), Self::Error>

Append a single ASCII byte. Used for structural punctuation ({, }, [, ], ,, :, ").

fn write_str_raw(&mut self, s: &str) -> Result<(), Self::Error>

Append a &str verbatim. Caller is responsible for any escaping — this is the structural / pre-escaped path. For user string payloads, call Self::write_escaped_str instead.

fn write_float_f64(&mut self, f: f64) -> Result<(), Self::Error>

Write a finite f64 as a JSON number. Non-finite inputs (inf, -inf, NaN) have no JSON representation; sinks reject them via their Self::Error type.

fn reserve_hint(&mut self, _additional: usize)

Hint that at least additional more bytes will be written. Sinks backed by a growable buffer (like ByteSink) can amortize capacity growth across a known-size sequence; sinks without a reservation concept treat this as a no-op.

unsafe fn write_byte_unchecked(&mut self, b: u8) -> Result<(), Self::Error>

Append a single ASCII byte WITHOUT a per-write capacity check.

fn write_escaped_str(&mut self, s: &str) -> Result<(), Self::Error>

Append a JSON-quoted, escaped string (including the surrounding " characters). The default impl escapes one byte at a time through write_byte; sinks with bulk-write capability (like StringSink) override with a literal-run fast path.

fn write_raw_bytes(&mut self, b: &[u8]) -> Result<(), Self::Error>

Append a byte slice whose contents are known-valid UTF-8.

fn write_int_i64(&mut self, n: i64) -> Result<(), Self::Error>

Write a signed 64-bit integer as a JSON number.

fn write_int_u64(&mut self, n: u64) -> Result<(), Self::Error>

Write an unsigned 64-bit integer as a JSON number.

fn write_int_i128(&mut self, n: i128) -> Result<(), Self::Error>

Write a signed 128-bit integer as a JSON number.

fn write_int_u128(&mut self, n: u128) -> Result<(), Self::Error>

Write an unsigned 128-bit integer as a JSON number.

unsafe fn write_float_f64_unchecked( &mut self, f: f64, ) -> Result<(), Self::Error>

Write a finite f64 ASSUMING the caller has reserved at least f64::MAX_SERIALIZED_LEN (32) bytes of sink capacity. Skips the per-call cap check in Vec::extend_from_slice — the second-largest mispredict source after the comma Vec::push.

unsafe fn write_float_f64_unchecked_finite( &mut self, f: f64, ) -> Result<(), Self::Error>

Like write_float_f64_unchecked, but additionally requires the caller to have validated that f is finite. The per-element finiteness branch in the bench’s hot loop was the dominant remaining mispredict source after the cap-check elimination; hoisting validation to a one-shot pre-scan over the whole slice removes that branch from the inner loop entirely.

unsafe fn write_float_f64_taint(&mut self, f: f64) -> Result<(), Self::Error>

Per-element float write that branchlessly tolerates non-finite input. Tainted bytes (junk ASCII for non-finite values) land in the sink; the caller is expected to query the sink’s take_nonfinite_taint() once at the end of the slice and turn a non-zero result into a typed error.

fn take_nonfinite_taint(&mut self) -> u64

Read and clear the accumulated non-finite taint from the sink. Returns 0 for sinks without taint tracking. The array writer queries this once after a batch of write_float_f64_taint calls; a non-zero result means at least one input was inf/NaN and the call must return Err(NonFiniteFloat).