Struct Encoder 

pub struct Encoder<W: Write, const VALIDATE: bool = true> { /* private fields */ }

JSON encoder with internal buffering and indentation state.

All bytes are buffered in an internal Vec<u8> and flushed to W once a threshold is crossed, keeping memory bounded.

The VALIDATE const parameter selects the event-protocol policy:

• Encoder<W> (the default, VALIDATE = true) checks every call against the serialization event protocol and reports misuse as an error. This is the safe surface for hand-written NsonSerialize implementations.
• Encoder<W, false> trusts the caller to follow the protocol (the repository-owned derive macros are verified to do so) and skips every per-value check. The top-level nextencode / to_vec / to_string entry points use this fast path.

Both emit byte-identical output for protocol-conforming callers; the fast path trades misuse diagnostics for ~2x encoding throughput.

Implementations

impl<W: Write, const VALIDATE: bool> Encoder<W, VALIDATE>

pub fn new(writer: W) -> Self

Create an encoder with the default (compact) config.

pub fn with_config(writer: W, config: EncodeConfig) -> Self

Create an encoder with the given config.

pub fn finish(self) -> Result<W>

Flush the internal buffer and return the underlying writer.

pub fn flush(&mut self) -> Result<()>

Flush the internal buffer without consuming self.

pub fn begin_object(&mut self) -> Result<()>

Open an object: write {.

pub fn end_object(&mut self) -> Result<()>

Close an object: write }.

pub fn begin_array(&mut self) -> Result<()>

Open an array: write [.

pub fn end_array(&mut self) -> Result<()>

Close an array: write ].

pub fn key(&mut self, key: &str) -> Result<()>

Write an object key: separator + "key":.

pub fn separator(&mut self) -> Result<()>

Write an element / key separator.

The first entry of a container produces nothing; subsequent entries produce , (plus newline and indent in pretty mode).

pub fn write_null(&mut self) -> Result<()>

Write null.

pub fn write_bool(&mut self, v: bool) -> Result<()>

Write a boolean.

pub fn write_str(&mut self, s: &str) -> Result<()>

Write a string (auto-escaped).

pub fn write_char(&mut self, c: char) -> Result<()>

Write a character (a one-scalar string) on the hot path.

Implemented directly instead of routing through Encoder::write_str so a single character skips the full-string raw-copy scan.

pub fn write_number(&mut self, n: &Number) -> Result<()>

Write a number.

pub fn write_i64(&mut self, v: i64) -> Result<()>

Write an i64.

pub fn write_u64(&mut self, v: u64) -> Result<()>

Write a u64.

pub fn write_i128(&mut self, v: i128) -> Result<()>

Write an i128.

pub fn write_u128(&mut self, v: u128) -> Result<()>

Write a u128.

pub fn write_f64(&mut self, v: f64) -> Result<()>

Write an f64 (shortest round-trip; non-finite values error).

Integral floats are written as 1.0 rather than 1 so float-ness survives round-trips.

pub fn write_f32(&mut self, v: f32) -> Result<()>

Write an f32 using its shortest round-trip representation.

Trait Implementations

impl<W: Write, const VALIDATE: bool> FormatEncoder for Encoder<W, VALIDATE>

type Error = Error

The error type produced by this format’s methods.

fn begin_array(&mut self) -> Result<(), Self::Error>

Begin an array container.

fn separator(&mut self) -> Result<(), Self::Error>

Emit the separator preceding a subsequent array element.

fn end_array(&mut self) -> Result<(), Self::Error>

End the current array container.

fn begin_object(&mut self) -> Result<(), Self::Error>

Begin an object container.

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

Emit an object key.

fn end_object(&mut self) -> Result<(), Self::Error>

End the current object container.

fn write_null(&mut self) -> Result<(), Self::Error>

Emit null.

fn write_bool(&mut self, value: bool) -> Result<(), Self::Error>

Emit a boolean.

fn write_str(&mut self, value: &str) -> Result<(), Self::Error>

Emit a UTF-8 string.

fn write_char(&mut self, value: char) -> Result<(), Self::Error>

Emit a single character (a one-scalar string).

fn write_number(&mut self, value: &Number) -> Result<(), Self::Error>

Emit a number preserving its exact internal kind.

fn write_i64(&mut self, value: i64) -> Result<(), Self::Error>

Emit an i64.

fn write_u64(&mut self, value: u64) -> Result<(), Self::Error>

Emit a u64.

fn write_i128(&mut self, value: i128) -> Result<(), Self::Error>

Emit an i128.

fn write_u128(&mut self, value: u128) -> Result<(), Self::Error>

Emit a u128.

fn write_f64(&mut self, value: f64) -> Result<(), Self::Error>

Emit an f64 (shortest round-trip).

fn write_f32(&mut self, value: f32) -> Result<(), Self::Error>

Emit an f32 (shortest round-trip).

fn write_i8(&mut self, value: i8) -> Result<(), Self::Error>

Emit an i8 (default: widen to write_i64).

fn write_i16(&mut self, value: i16) -> Result<(), Self::Error>

Emit an i16 (default: widen to write_i64).

fn write_i32(&mut self, value: i32) -> Result<(), Self::Error>

Emit an i32 (default: widen to write_i64).

fn write_u8(&mut self, value: u8) -> Result<(), Self::Error>

Emit a u8 (default: widen to write_u64).

fn write_u16(&mut self, value: u16) -> Result<(), Self::Error>

Emit a u16 (default: widen to write_u64).

fn write_u32(&mut self, value: u32) -> Result<(), Self::Error>

Emit a u32 (default: widen to write_u64).

fn write_none(&mut self) -> Result<(), Self::Error>

Emit Option::None.

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

Emit a byte sequence.

fn write_some(&mut self) -> Result<(), Self::Error>

Emit the marker that the following value is Option::Some.

fn map_key<K: NsonSerialize>(&mut self, key: &K) -> Result<(), Self::Error>

Emit a map key.

fn is_human_readable(&self) -> bool

Whether this format produces human-readable output.