Trait Deserialize 

pub trait Deserialize: Sized {
    // Required method
    fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>;

    // Provided method
    fn deserialize_many<D: Decode + ?Sized>(
        decoder: &mut D,
        count: usize,
    ) -> Result<Vec<Self>> { ... }
}

Types that know how to read themselves from any Decode source.

The contract is: deserialize consumes exactly the bytes that a corresponding Serialize would have produced for the returned value, no more and no fewer. On any malformed input it MUST return an error and MUST NOT panic, allocate unboundedly, or read past the decoder’s underlying source.

Round-trip invariant: decode::<T>(&encode(&v)?)? == v for every v: T.

Examples

use pack_io::{Decode, Decoder, Deserialize, Result, encode};

struct Point { x: i32, y: i32 }

impl Deserialize for Point {
    fn deserialize<D: Decode + ?Sized>(dec: &mut D) -> Result<Self> {
        Ok(Point {
            x: i32::deserialize(dec)?,
            y: i32::deserialize(dec)?,
        })
    }
}

let bytes = encode(&Point { x: 3, y: -7 }).unwrap();
let mut dec = Decoder::new(&bytes);
let back = Point::deserialize(&mut dec).unwrap();
assert_eq!((back.x, back.y), (3, -7));

Required Methods

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

Read a value of Self from the decoder, advancing its cursor.

Errors

Any crate::SerialError the underlying byte reads surface (truncated input, invalid length prefix, hostile varint, …).

Provided Methods

fn deserialize_many<D: Decode + ?Sized>( decoder: &mut D, count: usize, ) -> Result<Vec<Self>>

Read count consecutive Self values into a freshly-allocated Vec.

The default implementation calls Deserialize::deserialize in a loop. Types whose batch read can be done in a single bulk operation — most importantly u8, which compiles down to a single Read::read_exact instead of N individual byte reads — override this for the memcpy-class fast path.

This method is the seam that makes Vec<u8> decode at memcpy speed without forcing unsafe or specialisation onto the public trait surface. The Vec<T>::deserialize impl calls T::deserialize_many(decoder, len) rather than looping inline.

Implementations MUST cap any internal pre-allocation to bound memory use against hostile length prefixes — the count argument has already been validated against crate::Config::max_alloc by the caller, but defensive implementations should still avoid preallocating the full count for collections whose per-element overhead is large.

Errors

Propagates any error returned by the per-element / bulk read.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Deserialize for ()

fn deserialize<D: Decode + ?Sized>(_decoder: &mut D) -> Result<Self>

impl Deserialize for String

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for bool

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for f32

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for f64

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for i8

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for i16

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for i32

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for i64

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for i128

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for isize

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for u8

fn deserialize_many<D: Decode + ?Sized>( decoder: &mut D, count: usize, ) -> Result<Vec<u8>>

Single bulk read — bypasses the per-element loop the default impl would emit. For an in-memory crate::Decoder this is a bounds check plus a memcpy; for crate::IoDecoder it is one Read::read_exact. Either way it replaces N per-byte reads with one buffer fill.

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for u16

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for u32

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for u64

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for u128

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl Deserialize for usize

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<K, V, S> Deserialize for HashMap<K, V, S>

where K: Deserialize + Hash + Eq, V: Deserialize, S: BuildHasher + Default,

Available on crate feature std only.

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<K, V> Deserialize for BTreeMap<K, V>

where K: Deserialize + Ord, V: Deserialize,

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize, T7: Deserialize, T8: Deserialize, T9: Deserialize, T10: Deserialize, T11: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize, T7: Deserialize, T8: Deserialize, T9: Deserialize, T10: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize, T7: Deserialize, T8: Deserialize, T9: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize, T7: Deserialize, T8: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize, T7: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6, T7)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize, T6: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5, T6)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize, T5: Deserialize> Deserialize for (T0, T1, T2, T3, T4, T5)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize, T4: Deserialize> Deserialize for (T0, T1, T2, T3, T4)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize, T3: Deserialize> Deserialize for (T0, T1, T2, T3)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize> Deserialize for (T0, T1, T2)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize, T1: Deserialize> Deserialize for (T0, T1)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T0: Deserialize> Deserialize for (T0,)

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T, S> Deserialize for HashSet<T, S>

where T: Deserialize + Hash + Eq, S: BuildHasher + Default,

Available on crate feature std only.

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T: Deserialize, E: Deserialize> Deserialize for Result<T, E>

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T: Deserialize, const N: usize> Deserialize for [T; N]

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T: Deserialize> Deserialize for Option<T>

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T: Deserialize> Deserialize for Vec<T>

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

impl<T> Deserialize for BTreeSet<T>

where T: Deserialize + Ord,

fn deserialize<D: Decode + ?Sized>(decoder: &mut D) -> Result<Self>

Implementors