Trait Decode 

pub trait Decode: Sized {
    // Required method
    fn decode<I: Input>(value: &mut I) -> Option<Self>;
}

Trait that allows zero-copy read of value-references from slices in LE format.

Required Methods

fn decode<I: Input>(value: &mut I) -> Option<Self>

Attempt to deserialise the value from input.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl Decode for ()

fn decode<I: Input>(_: &mut I) -> Option<()>

impl Decode for [u8; 1]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 2]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 3]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 4]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 5]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 6]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 7]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 8]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 10]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 12]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 14]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 16]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 20]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 24]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 28]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 32]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 40]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 48]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 56]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 64]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 80]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 96]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 112]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for [u8; 128]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for bool

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for i8

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for i16

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for i32

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for i64

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for i128

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for isize

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for u16

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for u32

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for u64

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for u128

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl Decode for usize

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (A, B, C, D, E, F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (B, C, D, E, F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (C, D, E, F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (D, E, F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (E, F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (F, G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (G, H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<H: Decode, I: Decode, J: Decode, K: Decode> Decode for (H, I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<I: Decode, J: Decode, K: Decode> Decode for (I, J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<J: Decode, K: Decode> Decode for (J, K)

fn decode<INPUT: Input>(input: &mut INPUT) -> Option<Self>

impl<K: Decode> Decode for (K,)

fn decode<I: Input>(input: &mut I) -> Option<Self>

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

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for Option<T>

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 1]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 2]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 3]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 4]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 5]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 6]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 7]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 8]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 9]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 10]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 11]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 12]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 13]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 14]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 15]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 16]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 17]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 18]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 19]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 20]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 21]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 22]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 23]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 24]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 25]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 26]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 27]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 28]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 29]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 30]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 31]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 32]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 40]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 48]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 56]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 64]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 72]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 96]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 128]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 160]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 192]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 224]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T: Decode> Decode for [T; 256]

fn decode<I: Input>(input: &mut I) -> Option<Self>

impl<T> Decode for PhantomData<T>

fn decode<I: Input>(_input: &mut I) -> Option<Self>

Implementors

impl Decode for Compact<()>

impl Decode for Compact<u8>

impl Decode for Compact<u16>

impl Decode for Compact<u32>

impl Decode for Compact<u64>

impl Decode for Compact<u128>

impl Decode for String

Available on crate features full or std only.

impl Decode for Vec<u8>

impl<'a, T: ToOwned + ?Sized> Decode for Cow<'a, T>

where <T as ToOwned>::Owned: Decode,

Available on crate features full or std only.

impl<K: Decode + Ord, V: Decode> Decode for BTreeMap<K, V>

impl<T: Decode> Decode for Box<T>

impl<T: Decode> Decode for Vec<T>

impl<T> Decode for Compact<T>

where T: CompactAs, Compact<<T as CompactAs>::As>: Decode,