Decode

Trait Decode 

Source
pub trait Decode: Sized {
    // Required method
    fn decode<I: Input>(input: &mut I) -> Result<Self, Error>;

    // Provided methods
    fn skip<I: Input>(input: &mut I) -> Result<(), Error> { ... }
    fn encoded_fixed_size() -> Option<usize> { ... }
}
Expand description

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

Required Methods§

Source

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

Provided Methods§

Source

fn skip<I: Input>(input: &mut I) -> Result<(), Error>

Attempt to skip the encoded value from input.

The default implementation of this function is just calling Decode::decode. When possible, an implementation should provided a specialized implementation.

Source

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

If it returns Some(size) then all possible values of this type have the given size (in bytes) when encoded.

NOTE: A type with a fixed encoded size may return None.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl Decode for bool

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for i8

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for i16

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for i32

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for i64

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for i128

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for u8

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for u16

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for u32

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for u64

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for u128

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for ()

Source§

impl Decode for String

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for Duration

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroI8

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroI16

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroI32

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroI64

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroI128

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroU8

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroU16

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroU32

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroU64

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl Decode for NonZeroU128

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<A0: Decode, B0: Decode, C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<B0: Decode, C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<C0: Decode, D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<D0: Decode, E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<E0: Decode, F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<F0: Decode, G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (J0, K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (K0, L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (L0, M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (M0, N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (N0, O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (O0, P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<P0: Decode, Q0: Decode, R0: Decode> Decode for (P0, Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

impl<Q0: Decode, R0: Decode> Decode for (Q0, R0)

Source§

fn decode<INPUT: Input>(input: &mut INPUT) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<T> Decode for PhantomData<T>

Source§

fn decode<I: Input>(_input: &mut I) -> Result<Self, Error>

Source§

impl<T: Decode + Ord> Decode for BinaryHeap<T>

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<T: Decode + Ord> Decode for BTreeSet<T>

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<T: Decode> Decode for LinkedList<T>

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

impl<T: Decode> Decode for VecDeque<T>

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Source§

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

Source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Implementors§