Struct Encoder 

pub struct Encoder { /* private fields */ }

In-memory encoder. Writes into an owned Vec<u8>; the buffer can be reused across encodes by calling Encoder::take to swap it out.

Implements Encode, so Serialize impls written generically over E: Encode work directly through it.

Examples

use pack_io::Encoder;

let mut enc = Encoder::new();
enc.write(&7_u64).unwrap();
enc.write(&"hello").unwrap();
let bytes = enc.into_inner();
assert!(bytes.len() > 0);

Implementations

impl Encoder

pub fn new() -> Self

Construct an encoder with an empty output buffer.

Examples

let enc = pack_io::Encoder::new();
assert!(enc.as_bytes().is_empty());

pub fn into_buffer(buffer: Vec<u8>) -> Self

Construct an encoder backed by buffer. The encoder appends to the buffer rather than allocating its own — callers that re-use a single Vec<u8> across many encodes avoid the per-call allocation.

Examples

use pack_io::Encoder;

let buf = Vec::with_capacity(64);
let mut enc = Encoder::into_buffer(buf);
enc.write(&42_u64).unwrap();
let buf = enc.into_inner();
assert!(!buf.is_empty());

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

Borrow the encoded bytes accumulated so far.

pub fn into_inner(self) -> Vec<u8>

Consume the encoder and return its underlying buffer.

pub fn take(&mut self) -> Vec<u8>

Swap the encoder’s buffer with a fresh empty one, returning the bytes written so far. Useful for “encode then send” loops that want to re-use the encoder.

pub fn write<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()>

Encode value, appending its bytes to the internal buffer.

Errors

Propagates any error returned by the type’s Serialize implementation. Primitive impls in this crate never error on an in-memory encoder.

Trait Implementations

impl Debug for Encoder

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

Formats the value using the given formatter.

impl Default for Encoder

fn default() -> Encoder

Returns the “default value” for a type.

impl Encode for Encoder

fn write_byte(&mut self, byte: u8) -> Result<()>

Append a single byte.

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

Append a slice of bytes.

fn reserve(&mut self, additional: usize)

Hint that the caller is about to write additional more bytes.

fn write_varint_u64(&mut self, value: u64) -> Result<()>

Append a u64 as an unsigned LEB128 varint (1–10 bytes).

fn write_varint_u128(&mut self, value: u128) -> Result<()>

Append a u128 as an unsigned LEB128 varint (1–19 bytes).