Trait tetsy_codec::Decode

pub trait Decode: Sized {
    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.

Loading content...

Implementations on Foreign Types

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>

impl Decode for ()

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

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 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 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 i8

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

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>

Loading content...

Implementors

impl Decode for String

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

impl Decode for Vec<u8>

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

impl Decode for Compact<u8>

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

impl Decode for Compact<u16>

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

impl Decode for Compact<u32>

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

impl Decode for Compact<u64>

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

impl Decode for Compact<u128>

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

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

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

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

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

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

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

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

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

Loading content...