Trait frame_support::dispatch::Decode

pub trait Decode {
    fn decode<I>(value: &mut I) -> Result<Self, Error>
    where
        I: Input;
}

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

Required methods

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

Attempt to deserialise the value from input.

Loading content...

Implementations on Foreign Types

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

fn decode<I>(input: &mut I) -> Result<[T; 1024], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 112], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 8], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 93], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 99], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 76], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 92], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 199], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 124], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 206], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 243], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 220], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 13], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 38], Error> where
    I: Input, 

impl Decode for ()

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

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

fn decode<I>(input: &mut I) -> Result<[T; 3], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 244], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 162], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 218], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 185], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 142], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 209], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 2048], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 252], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 80], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 145], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 108], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 139], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 195], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 96], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 14], Error> where
    I: Input, 

impl<E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 107], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 197], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 7], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 212], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 182], Error> where
    I: Input, 

impl Decode for u16

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 204], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 34], Error> where
    I: Input, 

impl Decode for u64

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 8192], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 192], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 32768], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 235], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 143], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 113], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 175], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 47], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 117], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 16], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 44], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 241], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 98], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 29], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 255], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 2], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 23], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 154], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 10], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 188], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 226], Error> where
    I: Input, 

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(O0, P0, Q0, R0), Error> where
    INPUT: Input, 

impl<D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 190], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 103], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 66], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 172], Error> where
    I: Input, 

impl Decode for Compact<u32>

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

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

fn decode<I>(input: &mut I) -> Result<[T; 170], Error> where
    I: Input, 

impl<C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 101], Error> where
    I: Input, 

impl Decode for u128

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 75], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 196], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 43], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 12], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 128], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 180], Error> where
    I: Input, 

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

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

impl Decode for i128

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 27], Error> where
    I: Input, 

impl<B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 152], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 130], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

impl Decode for bool

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

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

fn decode<I>(input: &mut I) -> Result<[T; 24], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 512], Error> where
    I: Input, 

impl Decode for Compact<u16>

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

impl Decode for i16

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 171], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 5], Error> where
    I: Input, 

impl Decode for Compact<u8>

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

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

fn decode<I>(input: &mut I) -> Result<[T; 158], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 88], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 21], Error> where
    I: Input, 

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 52], Error> where
    I: Input, 

impl Decode for i32

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 237], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 71], Error> where
    I: Input, 

impl Decode for i8

const TYPE_INFO: TypeInfo

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

impl Decode for u32

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 176], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 229], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 63], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 135], Error> where
    I: Input, 

impl Decode for Compact<()>

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

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

fn decode<I>(input: &mut I) -> Result<[T; 53], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 131], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 256], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 126], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 33], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 51], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 155], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 213], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 174], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 216], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 159], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 79], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 133], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 6], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 72], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 40], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 123], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 127], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 65], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 129], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 191], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 18], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 179], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 224], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 77], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 245], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 148], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 81], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 157], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 58], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 91], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 102], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 37], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 228], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 207], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 246], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 240], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 4], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 39], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 89], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 194], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 144], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 121], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 147], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 221], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 161], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 183], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 15], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 184], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 49], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 69], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 32], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 249], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 9], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 119], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 205], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 16384], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 54], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 1], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 28], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 150], Error> where
    I: Input, 

impl<A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 149], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 36], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 236], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 163], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 70], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 151], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 85], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 227], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 22], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 250], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 100], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 239], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 46], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 82], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 384], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 125], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 26], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 104], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 11], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 134], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 211], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 768], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 110], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 68], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 132], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 189], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 17], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 61], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 106], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<BTreeMap<K, V>, Error> where
    I: Input, 

impl Decode for Compact<u128>

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

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

fn decode<I>(input: &mut I) -> Result<[T; 215], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 168], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 247], Error> where
    I: Input, 

impl Decode for i64

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 178], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 223], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 167], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 187], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 114], Error> where
    I: Input, 

impl Decode for u8

const TYPE_INFO: TypeInfo

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

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

fn decode<I>(input: &mut I) -> Result<[T; 31], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 84], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 90], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 203], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 177], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 140], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 242], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 253], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 137], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 111], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 164], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 193], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 231], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 55], Error> where
    I: Input, 

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 57], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 238], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 202], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 109], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 45], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 19], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 146], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 116], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 141], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 136], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 120], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 48], Error> where
    I: Input, 

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

fn decode<INPUT>(input: &mut INPUT) -> Result<(P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 234], Error> where
    I: Input, 

impl Decode for Compact<u64>

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

impl Decode for Duration

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

impl<F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0> Decode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0) where
    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, 

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 186], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 222], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 214], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 97], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 165], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 74], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 20], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 233], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 83], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 86], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 41], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 50], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 248], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 59], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 62], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 67], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 87], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 95], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 138], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 208], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 181], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 73], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 225], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 56], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 173], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 25], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 219], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 251], Error> where
    I: Input, 

impl Decode for OptionBool

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

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

fn decode<I>(input: &mut I) -> Result<[T; 254], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 60], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 115], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 64], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 118], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 30], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 232], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 156], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 210], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 153], Error> where
    I: Input, 

impl Decode for String

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

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

fn decode<I>(input: &mut I) -> Result<[T; 160], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 78], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 94], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<Cow<'a, T>, Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 122], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 42], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 4096], Error> where
    I: Input, 

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

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

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

fn decode<I>(input: &mut I) -> Result<[T; 201], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 198], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 200], Error> where
    I: Input, 

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

fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(K0, L0, M0, N0, O0, P0, Q0, R0), Error> where
    INPUT: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 169], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 230], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 166], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 217], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 105], Error> where
    I: Input, 

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

fn decode<I>(input: &mut I) -> Result<[T; 35], Error> where
    I: Input, 

impl Decode for NeverNativeValue

fn decode<I>(&mut I) -> Result<NeverNativeValue, Error> where
    I: Input, 

impl Decode for Public

fn decode<DecIn>(input: &mut DecIn) -> Result<Public, Error> where
    DecIn: Input, 

impl Decode for Public

fn decode<DecIn>(input: &mut DecIn) -> Result<Public, Error> where
    DecIn: Input, 

impl Decode for EnvironmentDefinition

fn decode<DecIn>(input: &mut DecIn) -> Result<EnvironmentDefinition, Error> where
    DecIn: Input, 

impl Decode for HttpRequestId

fn decode<DecIn>(input: &mut DecIn) -> Result<HttpRequestId, Error> where
    DecIn: Input, 

impl Decode for Signature

fn decode<DecIn>(input: &mut DecIn) -> Result<Signature, Error> where
    DecIn: Input, 

impl Decode for OpaqueNetworkState

fn decode<DecIn>(input: &mut DecIn) -> Result<OpaqueNetworkState, Error> where
    DecIn: Input, 

impl Decode for OpaqueMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<OpaqueMetadata, Error> where
    DecIn: Input, 

impl Decode for ChangesTrieConfiguration

fn decode<DecIn>(input: &mut DecIn) -> Result<ChangesTrieConfiguration, Error> where
    DecIn: Input, 

impl Decode for HostError

fn decode<DecIn>(input: &mut DecIn) -> Result<HostError, Error> where
    DecIn: Input, 

impl Decode for StorageKind

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageKind, Error> where
    DecIn: Input, 

impl Decode for DeriveJunction

fn decode<DecIn>(input: &mut DecIn) -> Result<DeriveJunction, Error> where
    DecIn: Input, 

impl Decode for OpaquePeerId

fn decode<DecIn>(input: &mut DecIn) -> Result<OpaquePeerId, Error> where
    DecIn: Input, 

impl Decode for AccountId32

fn decode<DecIn>(input: &mut DecIn) -> Result<AccountId32, Error> where
    DecIn: Input, 

impl Decode for LogLevel

fn decode<DecIn>(input: &mut DecIn) -> Result<LogLevel, Error> where
    DecIn: Input, 

impl Decode for Signature

fn decode<DecIn>(input: &mut DecIn) -> Result<Signature, Error> where
    DecIn: Input, 

impl Decode for CryptoTypeId

fn decode<DecIn>(input: &mut DecIn) -> Result<CryptoTypeId, Error> where
    DecIn: Input, 

impl Decode for HttpError

fn decode<DecIn>(input: &mut DecIn) -> Result<HttpError, Error> where
    DecIn: Input, 

impl Decode for Timestamp

fn decode<DecIn>(input: &mut DecIn) -> Result<Timestamp, Error> where
    DecIn: Input, 

impl Decode for HttpRequestStatus

fn decode<DecIn>(input: &mut DecIn) -> Result<HttpRequestStatus, Error> where
    DecIn: Input, 

impl Decode for ExternEntity

fn decode<DecIn>(input: &mut DecIn) -> Result<ExternEntity, Error> where
    DecIn: Input, 

impl Decode for CryptoTypePublicPair

fn decode<DecIn>(input: &mut DecIn) -> Result<CryptoTypePublicPair, Error> where
    DecIn: Input, 

impl Decode for LocalizedSignature

fn decode<DecIn>(input: &mut DecIn) -> Result<LocalizedSignature, Error> where
    DecIn: Input, 

impl Decode for Public

fn decode<DecIn>(input: &mut DecIn) -> Result<Public, Error> where
    DecIn: Input, 

impl Decode for Entry

fn decode<DecIn>(input: &mut DecIn) -> Result<Entry, Error> where
    DecIn: Input, 

impl Decode for Duration

fn decode<DecIn>(input: &mut DecIn) -> Result<Duration, Error> where
    DecIn: Input, 

impl Decode for Signature

fn decode<DecIn>(input: &mut DecIn) -> Result<Signature, Error> where
    DecIn: Input, 

impl Decode for OpaqueMultiaddr

fn decode<DecIn>(input: &mut DecIn) -> Result<OpaqueMultiaddr, Error> where
    DecIn: Input, 

impl Decode for KeyTypeId

fn decode<DecIn>(input: &mut DecIn) -> Result<KeyTypeId, Error> where
    DecIn: Input, 

impl Decode for ReturnValue

fn decode<DecIn>(input: &mut DecIn) -> Result<ReturnValue, Error> where
    DecIn: Input, 

impl Decode for Value

fn decode<DecIn>(input: &mut DecIn) -> Result<Value, Error> where
    DecIn: Input, 

impl Decode for H256

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

impl Decode for U256

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

impl Decode for H512

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

impl Decode for U128

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

impl Decode for H160

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

impl Decode for U512

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

impl Decode for StorageProof

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageProof, Error> where
    DecIn: Input, 

impl Decode for EcdsaVerifyError

fn decode<DecIn>(input: &mut DecIn) -> Result<EcdsaVerifyError, Error> where
    DecIn: Input, 

impl Decode for RuntimeMetadataDeprecated

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

impl Decode for RuntimeMetadataV11

fn decode<DecIn>(input: &mut DecIn) -> Result<RuntimeMetadataV11, Error> where
    DecIn: Input, 

impl Decode for OpaqueExtrinsic

fn decode<DecIn>(input: &mut DecIn) -> Result<OpaqueExtrinsic, Error> where
    DecIn: Input, 

impl Decode for UnknownTransaction

fn decode<DecIn>(input: &mut DecIn) -> Result<UnknownTransaction, Error> where
    DecIn: Input, 

impl<Hash> Decode for Digest<Hash> where
    Hash: Encode + Decode,
    Vec<DigestItem<Hash>>: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<Digest<Hash>, Error> where
    DecIn: Input, 

impl<Block> Decode for SignedBlock<Block> where
    Block: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<SignedBlock<Block>, Error> where
    DecIn: Input, 

impl Decode for Era

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

impl Decode for ModuleId

fn decode<DecIn>(input: &mut DecIn) -> Result<ModuleId, Error> where
    DecIn: Input, 

impl Decode for RuntimeString

fn decode<I>(value: &mut I) -> Result<RuntimeString, Error> where
    I: Input, 

impl Decode for AnySignature

fn decode<DecIn>(input: &mut DecIn) -> Result<AnySignature, Error> where
    DecIn: Input, 

impl<Call, Extra> Decode for TestXt<Call, Extra> where
    Call: Decode,
    Option<(u64, Extra)>: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<TestXt<Call, Extra>, Error> where
    DecIn: Input, 

impl<Info> Decode for DispatchErrorWithPostInfo<Info> where
    Info: Eq + PartialEq<Info> + Clone + Copy + Encode + Decode + Printable, 

fn decode<DecIn>(
    input: &mut DecIn
) -> Result<DispatchErrorWithPostInfo<Info>, Error> where
    DecIn: Input, 

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic> where
    Extrinsic: MaybeSerialize,
    Header: Decode,
    Vec<Extrinsic>: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<Block<Header, Extrinsic>, Error> where
    DecIn: Input, 

impl<Hash> Decode for DigestItem<Hash> where
    Hash: Decode, 

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

impl<Number, Hash> Decode for Header<Number, Hash> where
    Hash: Hash,
    Number: HasCompact + Copy + Into<U256> + TryFrom<U256>,
    <Hash as Hash>::Output: Decode, 

fn decode<I>(input: &mut I) -> Result<Header<Number, Hash>, Error> where
    I: Input, 

impl Decode for MultiSigner

fn decode<DecIn>(input: &mut DecIn) -> Result<MultiSigner, Error> where
    DecIn: Input, 

impl Decode for ChangesTrieSignal

fn decode<DecIn>(input: &mut DecIn) -> Result<ChangesTrieSignal, Error> where
    DecIn: Input, 

impl Decode for LookupError

fn decode<DecIn>(input: &mut DecIn) -> Result<LookupError, Error> where
    DecIn: Input, 

impl<Hashing> Decode for RandomNumberGenerator<Hashing> where
    Hashing: Hash,
    <Hashing as Hash>::Output: Decode, 

fn decode<DecIn>(
    input: &mut DecIn
) -> Result<RandomNumberGenerator<Hashing>, Error> where
    DecIn: Input, 

impl<Xt> Decode for ExtrinsicWrapper<Xt> where
    Xt: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<ExtrinsicWrapper<Xt>, Error> where
    DecIn: Input, 

impl Decode for TransactionSource

fn decode<DecIn>(input: &mut DecIn) -> Result<TransactionSource, Error> where
    DecIn: Input, 

impl Decode for UintAuthorityId

fn decode<DecIn>(input: &mut DecIn) -> Result<UintAuthorityId, Error> where
    DecIn: Input, 

impl<Xt> Decode for Block<Xt> where
    Vec<Xt>: Decode, 

fn decode<DecIn>(input: &mut DecIn) -> Result<Block<Xt>, Error> where
    DecIn: Input, 

impl Decode for MultiSignature

fn decode<DecIn>(input: &mut DecIn) -> Result<MultiSignature, Error> where
    DecIn: Input, 

impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Address: Decode,
    Call: Decode,
    Extra: SignedExtension,
    Signature: Decode, 

fn decode<I>(
    input: &mut I
) -> Result<UncheckedExtrinsic<Address, Call, Signature, Extra>, Error> where
    I: Input, 

impl Decode for Header

fn decode<DecIn>(input: &mut DecIn) -> Result<Header, Error> where
    DecIn: Input, 

impl Decode for InvalidTransaction

fn decode<DecIn>(input: &mut DecIn) -> Result<InvalidTransaction, Error> where
    DecIn: Input, 

impl Decode for TransactionValidityError

fn decode<DecIn>(input: &mut DecIn) -> Result<TransactionValidityError, Error> where
    DecIn: Input, 

impl Decode for ValidTransaction

fn decode<DecIn>(input: &mut DecIn) -> Result<ValidTransaction, Error> where
    DecIn: Input, 

impl Decode for BadOrigin

fn decode<DecIn>(input: &mut DecIn) -> Result<BadOrigin, Error> where
    DecIn: Input, 

impl Decode for Signature

fn decode<DecIn>(input: &mut DecIn) -> Result<Signature, Error> where
    DecIn: Input, 

impl Decode for Public

fn decode<DecIn>(input: &mut DecIn) -> Result<Public, Error> where
    DecIn: Input, 

impl Decode for Signature

fn decode<DecIn>(input: &mut DecIn) -> Result<Signature, Error> where
    DecIn: Input, 

impl Decode for Public

fn decode<DecIn>(input: &mut DecIn) -> Result<Public, Error> where
    DecIn: Input, 

impl Decode for Perquintill

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

impl Decode for PerU16

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

impl Decode for Fixed64

fn decode<DecIn>(input: &mut DecIn) -> Result<Fixed64, Error> where
    DecIn: Input, 

impl Decode for Permill

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

impl Decode for Percent

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

impl Decode for Fixed128

fn decode<DecIn>(input: &mut DecIn) -> Result<Fixed128, Error> where
    DecIn: Input, 

impl Decode for Perbill

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

impl Decode for InherentData

fn decode<DecIn>(input: &mut DecIn) -> Result<InherentData, Error> where
    DecIn: Input, 

impl Decode for CheckInherentsResult

fn decode<DecIn>(input: &mut DecIn) -> Result<CheckInherentsResult, Error> where
    DecIn: Input, 

impl Decode for Error

fn decode<DecIn>(input: &mut DecIn) -> Result<Error, Error> where
    DecIn: Input, 

Loading content...

Implementors

impl Decode for DispatchError

fn decode<DecIn>(input: &mut DecIn) -> Result<DispatchError, Error> where
    DecIn: Input, 

impl Decode for RuntimeMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<RuntimeMetadata, Error> where
    DecIn: Input, 

impl Decode for StorageEntryModifier

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageEntryModifier, Error> where
    DecIn: Input, 

impl Decode for StorageEntryType

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageEntryType, Error> where
    DecIn: Input, 

impl Decode for StorageHasher

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageHasher, Error> where
    DecIn: Input, 

impl Decode for WithdrawReason

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

impl Decode for DispatchClass

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

impl Decode for ErrorMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<ErrorMetadata, Error> where
    DecIn: Input, 

impl Decode for FunctionArgumentMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<FunctionArgumentMetadata, Error> where
    DecIn: Input, 

impl Decode for FunctionMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<FunctionMetadata, Error> where
    DecIn: Input, 

impl Decode for ModuleConstantMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<ModuleConstantMetadata, Error> where
    DecIn: Input, 

impl Decode for EventMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<EventMetadata, Error> where
    DecIn: Input, 

impl Decode for OuterEventMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<OuterEventMetadata, Error> where
    DecIn: Input, 

impl Decode for ExtrinsicMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<ExtrinsicMetadata, Error> where
    DecIn: Input, 

impl Decode for ModuleMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<ModuleMetadata, Error> where
    DecIn: Input, 

impl Decode for RuntimeMetadataPrefixed

fn decode<DecIn>(input: &mut DecIn) -> Result<RuntimeMetadataPrefixed, Error> where
    DecIn: Input, 

impl Decode for StorageEntryMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageEntryMetadata, Error> where
    DecIn: Input, 

impl Decode for StorageMetadata

fn decode<DecIn>(input: &mut DecIn) -> Result<StorageMetadata, Error> where
    DecIn: Input, 

impl Decode for WithdrawReasons

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

impl Decode for DispatchInfo

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

impl Decode for PostDispatchInfo

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

impl<B, O> Decode for DecodeDifferent<B, O> where
    B: 'static,
    O: Decode + 'static, 

fn decode<I>(input: &mut I) -> Result<DecodeDifferent<B, O>, Error> where
    I: Input, 

impl<T> Decode for PhantomData<T>

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

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

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

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

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

impl<T, X> Decode for X where
    T: Decode + Into<X>,
    X: WrapperTypeDecode<Wrapped = T>, 

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

Loading content...