Struct Encoder 

pub struct Encoder { /* private fields */ }

A bounded, state-machine driven encoder.

The Encoder maintains a stack of open scopes to enforce structural strictness and automatically back-patch length headers.

Structural Invariants

All write methods validate the operation against the current Scope. Returns an Error if the write violates the following rules:

1. Map Scopes: Only Tag::Variant items may be written.
2. ADT Scopes (Option, Result, Variant): Exactly one item must be written. Attempts to write >1 item or close the scope with 0 items will fail.
3. Root Scope: The encoder must end in the Root scope to finalize bytes.

Implementations

impl Encoder

pub fn new() -> Self

Creates a new encoder with default capacity.

pub fn into_bytes(self) -> Result<Vec<u8>>

Consumes the encoder and returns the final byte vector.

Errors

Returns Error::ScopeStillOpen if the stack depth > 1.

pub fn as_bytes(&self) -> Result<&[u8]>

Returns a view of the current buffer.

Errors

Returns Error::ScopeStillOpen if the stack depth > 1.

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

Encodes a boolean value.

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

Encodes an unsigned 8-bit integer.

pub fn s8(&mut self, v: i8) -> Result<()>

Encodes a signed 8-bit integer.

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

Encodes an unsigned 16-bit integer (LE).

pub fn s16(&mut self, v: i16) -> Result<()>

Encodes a signed 16-bit integer (LE).

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

Encodes an unsigned 32-bit integer (LE).

pub fn s32(&mut self, v: i32) -> Result<()>

Encodes a signed 32-bit integer (LE).

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

Encodes an unsigned 64-bit integer (LE).

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

Encodes a signed 64-bit integer (LE).

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

Encodes a 32-bit float (LE).

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

Encodes a 64-bit float (LE).

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

Encodes a char as u32 (LE).

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

Encodes Unit ().

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

Encodes Option::None.

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

Encodes a UTF-8 string blob.

pub fn bytes(&mut self, v: &[u8]) -> Result<()>

Encodes a raw byte blob.

pub fn append_raw(&mut self, v: &[u8]) -> Result<()>

Appends pre-encoded neopack bytes directly to the buffer.

This is used to inject already-encoded data (like a pre-encoded list of values) into the stream without re-encoding. The caller must ensure the bytes are valid neopack-encoded data.

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

Begins a List container.

Invariants

• Must be closed via list_end().
• Allows any number of items.

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

Ends a List container.

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

Begins a Map container.

Invariants

• Must be closed via map_end().
• Strict: Only variant_begin() (Key/Value pair) is allowed as a direct child.

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

Ends a Map container.

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

Begins an Option::Some container.

Invariants

• Must be closed via option_some_end().
• Strict: Requires exactly one item to be written.

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

Ends an Option::Some container.

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

Begins a Result::Ok container.

Invariants

• Must be closed via result_ok_end().
• Strict: Requires exactly one item to be written.

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

Ends a Result::Ok container.

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

Begins a Result::Err container.

Invariants

• Must be closed via result_err_end().
• Strict: Requires exactly one item to be written.

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

Ends a Result::Err container.

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

Begins a Variant (Named Payload).

Encodes the name string immediately.

Invariants

• Must be closed via variant_end().
• Strict: Requires exactly one item (the payload) to be written after this call.

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

Ends a Variant.