Struct IoEncoder 

pub struct IoEncoder<W: Write> { /* private fields */ }

Available on crate feature std only.

Streaming encoder that writes directly into any Write-shaped sink.

Each IoEncoder::write call calls into the underlying writer for the bytes the type produces. The encoder does not buffer; if you wrap a raw socket / file, wrap it in a std::io::BufWriter first.

Examples

use pack_io::IoEncoder;

let mut sink: Vec<u8> = Vec::new();
let mut enc = IoEncoder::new(&mut sink);
enc.write(&42_u64).unwrap();
enc.write(&"hello").unwrap();
assert!(!sink.is_empty());

Implementations

impl<W: Write> IoEncoder<W>

pub fn new(writer: W) -> Self

Wrap writer in an encoder.

The encoder does not buffer; wrap raw sockets / files in a std::io::BufWriter first if syscall amplification is a concern.

Examples

use pack_io::IoEncoder;

let mut sink: Vec<u8> = Vec::new();
let _enc = IoEncoder::new(&mut sink);

pub fn writer(&self) -> &W

Borrow the underlying writer.

Examples

use pack_io::IoEncoder;

let mut sink: Vec<u8> = Vec::new();
let enc = IoEncoder::new(&mut sink);
let _: &&mut Vec<u8> = &enc.writer();

pub fn writer_mut(&mut self) -> &mut W

Borrow the underlying writer mutably.

Useful when downstream code needs &mut W to call writer-specific methods (e.g. flush) without consuming the encoder.

Examples

use std::io::{BufWriter, Write};
use pack_io::IoEncoder;

let mut sink: Vec<u8> = Vec::new();
let buffered = BufWriter::new(&mut sink);
let mut enc = IoEncoder::new(buffered);
enc.write(&7_u64).unwrap();
enc.writer_mut().flush().unwrap();

pub fn into_inner(self) -> W

Consume the encoder and return the underlying writer.

Examples

use pack_io::IoEncoder;

let sink: Vec<u8> = Vec::new();
let mut enc = IoEncoder::new(sink);
enc.write(&42_u64).unwrap();
let written: Vec<u8> = enc.into_inner();
assert_eq!(written, &[0x2a]);

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

Encode value straight into the underlying writer.

Errors

• Propagates any crate::SerialError from the type’s Serialize.
• Maps any std::io::Error from the writer into SerialError::Io.

Trait Implementations

impl<W: Debug + Write> Debug for IoEncoder<W>

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

Formats the value using the given formatter.

impl<W: Write> Encode for IoEncoder<W>

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