Struct Decoder 

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

In-memory decoder. Borrows from an input slice and advances a position pointer as values are read. Bounds-checked on every operation.

Implements Decode, so Deserialize impls written generically over D: Decode work directly through it.

Examples

use pack_io::{Encoder, Decoder};

let mut enc = Encoder::new();
enc.write(&7_u64).unwrap();
enc.write(&true).unwrap();
let bytes = enc.into_inner();

let mut dec = Decoder::new(&bytes);
let n: u64 = dec.read().unwrap();
let b: bool = dec.read().unwrap();
assert_eq!(n, 7);
assert!(b);
assert!(dec.is_empty());

Implementations

impl<'a> Decoder<'a>

pub fn new(bytes: &'a [u8]) -> Self

Construct a decoder over bytes.

pub fn with_config(bytes: &'a [u8], config: Config) -> Result<Self>

Construct a decoder with the supplied configuration.

Errors

Returns SerialError::InvalidLength if config.max_alloc == 0.

pub fn position(&self) -> usize

Bytes consumed so far from the start of the input.

pub fn remaining(&self) -> usize

Number of bytes remaining in the input.

pub fn is_empty(&self) -> bool

True when there are no more bytes to read.

pub fn read<T: Deserialize>(&mut self) -> Result<T>

Decode a value of type T from the current position.

Errors

Returns any SerialError surfaced by T::deserialize.

pub fn read_length_prefixed_borrowed(&mut self) -> Result<&'a [u8]>

Read a length-prefixed byte run as a borrowed slice of the underlying input — no allocation, no copy.

The borrowed slice has the same lifetime 'a as the decoder’s input buffer, which lets caller-side &'a str / &'a [u8] decode paths return a borrow directly into that buffer. This is the seam the zero-copy crate::DeserializeView surface plugs into for &'a str and &'a [u8].

Errors

• SerialError::InvalidLength if the prefix exceeds the configured max_alloc, OR exceeds the remaining input.
• SerialError::UnexpectedEof is folded into InvalidLength for this method, since the buffer length is known up front and a declared length running off the end is logically a length-prefix error, not a streaming EOF.

Trait Implementations

impl<'a> Debug for Decoder<'a>

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

Formats the value using the given formatter.

impl Decode for Decoder<'_>

fn read_length_prefixed(&mut self) -> Result<Vec<u8>>

In-memory specialisation: validates length against the actual buffer length too, not just max_alloc. Catches truncated inputs without allocating.

fn read_byte(&mut self) -> Result<u8>

Read the next byte, advancing the cursor.

fn read_into(&mut self, out: &mut [u8]) -> Result<()>

Fill out with exactly out.len() bytes, advancing the cursor.

fn max_alloc(&self) -> usize

Maximum number of bytes the decoder will allocate for a single length-prefixed value. Mirrors Config::max_alloc.

fn read_varint_u64(&mut self) -> Result<u64>

Read a LEB128 varint as a u64.

fn read_varint_u128(&mut self) -> Result<u128>

Read a LEB128 varint as a u128.