Struct IoDecoder 

pub struct IoDecoder<R: Read> { /* private fields */ }

Available on crate feature std only.

Streaming decoder that reads directly from any Read-shaped source.

Each IoDecoder::read call may issue many small reads against the underlying source. Wrap raw sockets / files in std::io::BufReader first if read-syscall amplification is a concern.

Examples

use pack_io::{IoEncoder, IoDecoder};
use std::io::Cursor;

let mut buf: Vec<u8> = Vec::new();
{
    let mut enc = IoEncoder::new(&mut buf);
    enc.write(&42_u64).unwrap();
    enc.write(&"hi").unwrap();
}

let mut dec = IoDecoder::new(Cursor::new(buf));
let n: u64 = dec.read().unwrap();
let s: String = dec.read().unwrap();
assert_eq!((n, s.as_str()), (42, "hi"));

Implementations

impl<R: Read> IoDecoder<R>

pub fn new(reader: R) -> Self

Wrap reader with the default Config.

pub fn with_config(reader: R, config: Config) -> Result<Self>

Wrap reader with the supplied configuration.

Errors

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

pub fn reader(&self) -> &R

Borrow the underlying reader.

pub fn into_inner(self) -> R

Consume the decoder and return the underlying reader.

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

Decode the next value from the underlying reader.

Errors

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

Trait Implementations

impl<R: Debug + Read> Debug for IoDecoder<R>

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

Formats the value using the given formatter.

impl<R: Read> Decode for IoDecoder<R>

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.

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

Read a length-prefixed byte run, allocating a fresh Vec<u8>.