Struct ByteSink 

pub struct ByteSink<'a> { /* private fields */ }

JsonWrite sink that appends to a Vec<u8>.

Bypasses String’s UTF-8 invariant maintenance — every byte written is known-valid by construction, so the caller can convert to String via from_utf8_unchecked after serialization completes.

Implementations

impl<'a> ByteSink<'a>

pub const fn new(out: &'a mut Vec<u8>) -> Self

Trait Implementations

impl<'a> Debug for ByteSink<'a>

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

Formats the value using the given formatter.

impl JsonWrite for ByteSink<'_>

Available on crate feature alloc only.

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

Branchless byte append. Skips Vec::push’s capacity check; relies on the caller having reserved enough via reserve_hint.

Safety

self.out.len() < self.out.capacity() must hold. The caller’s reserve_hint is what makes this safe in write_array for primitive slices.

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

SAFETY-relying override: caller must have reserved ≥ 32 bytes via reserve_hint. Skips Vec::extend_from_slice’s per-call cap check that the per-element float loop otherwise pays.

The non-finite arm is outlined via #[cold] so the branch predictor gets a strong static hint that the error path is rare. On perf record -e branch-misses the inlined Err::new(...) path inflated the finiteness jg’s mispredict rate; outlining it pushed the cold-arm PCs out of the hot loop’s history.

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

Finite-known override: skip both the cap check AND the finiteness check. The slice writer guarantees both preconditions via a one-shot pre-scan + reserve_hint. This removes the last data-dependent branch from the bench’s per-element loop.

Safety

cap - len ≥ 32 AND f.is_finite().

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

Taint-tracking float write: accumulates non-finite-ness into the sink’s nonfinite_taint field for end-of-slice query. No per-element branch on finiteness.

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 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.

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_raw_bytes(&mut self, b: &[u8]) -> Result<(), Self::Error>

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

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_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.

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 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).