Trait frame_support::dispatch::Decode

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

    fn skip<I>(input: &mut I) -> Result<(), Error>
    where
        I: Input,
    { ... }
    fn encoded_fixed_size() -> Option<usize> { ... }
}

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

Required methods

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

Attempt to deserialise the value from input.

Provided methods

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

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.

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.

Implementations on Foreign Types

impl Decode for WasmMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmValuesSet

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValuesSet, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmFields

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmFields, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmLevel

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmLevel, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmFieldName

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmFieldName, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmEntryAttributes

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmEntryAttributes, Error> where
    __CodecInputEdqy: Input, 

impl Decode for WasmValue

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValue, Error> where
    __CodecInputEdqy: Input, 

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

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

impl Decode for i64

pub const TYPE_INFO: TypeInfo

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

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

pub fn decode<I>(input: &mut I) -> Result<BTreeMap<K, V>, 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
    G0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode, 

pub 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 Decode for u32

pub const TYPE_INFO: TypeInfo

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

impl Decode for Compact<u8>

pub fn decode<I>(input: &mut I) -> Result<Compact<u8>, 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, 

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

impl Decode for u64

pub const TYPE_INFO: TypeInfo

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

impl Decode for OptionBool

pub fn decode<I>(input: &mut I) -> Result<OptionBool, 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, 

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

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

pub fn decode<I>(input: &mut I) -> Result<BTreeSet<T>, 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
    B0: Decode,
    G0: Decode,
    A0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode, 

pub 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 RangeInclusive<T> where
    T: Decode, 

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

impl Decode for Compact<u32>

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

impl Decode for NonZeroI32

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

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

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

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

pub fn decode<I>(input: &mut I) -> Result<Compact<T>, 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, 

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

impl Decode for i8

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i8, 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, 

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

impl Decode for Compact<()>

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

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

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

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

pub fn decode<INPUT>(input: &mut INPUT) -> Result<(P0, Q0, R0), Error> where
    INPUT: 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, 

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

impl Decode for u128

pub const TYPE_INFO: TypeInfo

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

impl Decode for Duration

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

impl Decode for String

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

impl Decode for NonZeroU64

pub fn decode<I>(input: &mut I) -> Result<NonZeroU64, 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, 

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

pub 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 Decode for i32

pub const TYPE_INFO: TypeInfo

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

impl Decode for u8

pub const TYPE_INFO: TypeInfo

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

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

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

impl Decode for Compact<u128>

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

impl Decode for NonZeroI64

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

impl Decode for NonZeroU16

pub fn decode<I>(input: &mut I) -> Result<NonZeroU16, 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
    G0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode, 

pub 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 Decode for NonZeroI8

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

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

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

impl Decode for NonZeroU128

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

impl Decode for i16

pub const TYPE_INFO: TypeInfo

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

impl Decode for NonZeroI16

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

impl Decode for bool

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

impl Decode for NonZeroU8

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

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

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

impl Decode for Compact<u16>

pub fn decode<I>(input: &mut I) -> Result<Compact<u16>, 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,
    G0: Decode,
    C0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode, 

pub 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 Decode for i128

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i128, 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, 

pub 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 Compact<u64>

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

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

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

impl Decode for NonZeroI128

pub fn decode<I>(input: &mut I) -> Result<NonZeroI128, 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, 

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

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

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

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

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

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

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

impl Decode for NonZeroU32

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

impl Decode for ()

pub fn decode<I>(&mut I) -> Result<(), Error> where
    I: 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
    G0: Decode,
    D0: Decode,
    E0: Decode,
    F0: Decode,
    H0: Decode,
    I0: Decode,
    J0: Decode,
    K0: Decode,
    L0: Decode,
    M0: Decode,
    N0: Decode,
    O0: Decode,
    P0: Decode,
    Q0: Decode,
    R0: Decode, 

pub 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 Decode for u16

pub const TYPE_INFO: TypeInfo

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

impl Decode for StorageMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for RuntimeMetadataDeprecated

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

impl Decode for StorageEntryMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ModuleMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ModuleMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageEntryType

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryType, Error> where
    __CodecInputEdqy: Input, 

impl Decode for RuntimeMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ExtrinsicMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExtrinsicMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for RuntimeMetadataPrefixed

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadataPrefixed, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageHasher

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageHasher, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageEntryModifier

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryModifier, Error> where
    __CodecInputEdqy: Input, 

impl Decode for RuntimeMetadataV13

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RuntimeMetadataV13, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for OpaquePeerId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaquePeerId, Error> where
    __CodecInputEdqy: Input, 

impl Decode for LogLevelFilter

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LogLevelFilter, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Timestamp

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Timestamp, Error> where
    __CodecInputEdqy: Input, 

impl Decode for OpaqueMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMetadata, Error> where
    __CodecInputEdqy: Input, 

impl Decode for HostError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HostError, Error> where
    __CodecInputEdqy: Input, 

impl Decode for HttpError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpError, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ExternEntity

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExternEntity, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ChangesTrieConfiguration

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ChangesTrieConfiguration, Error> where
    __CodecInputEdqy: Input, 

impl Decode for AccountId32

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AccountId32, Error> where
    __CodecInputEdqy: Input, 

impl Decode for LogLevel

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LogLevel, Error> where
    __CodecInputEdqy: Input, 

impl Decode for CryptoTypeId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypeId, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageKind

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageKind, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Duration

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Duration, Error> where
    __CodecInputEdqy: Input, 

impl Decode for NeverNativeValue

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

impl Decode for OpaqueMultiaddr

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMultiaddr, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Entry

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Entry, Error> where
    __CodecInputEdqy: Input, 

impl Decode for HttpRequestStatus

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpRequestStatus, Error> where
    __CodecInputEdqy: Input, 

impl Decode for HttpRequestId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpRequestId, Error> where
    __CodecInputEdqy: Input, 

impl Decode for EnvironmentDefinition

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<EnvironmentDefinition, Error> where
    __CodecInputEdqy: Input, 

impl Decode for OpaqueNetworkState

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueNetworkState, Error> where
    __CodecInputEdqy: Input, 

impl Decode for KeyTypeId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<KeyTypeId, Error> where
    __CodecInputEdqy: Input, 

impl Decode for LocalizedSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LocalizedSignature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for DeriveJunction

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DeriveJunction, Error> where
    __CodecInputEdqy: Input, 

impl Decode for CryptoTypePublicPair

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypePublicPair, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Value

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Value, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ReturnValue

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ReturnValue, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageKey

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageKey, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageData

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageData, Error> where
    __CodecInputEdqy: Input, 

impl Decode for TrackedStorageKey

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TrackedStorageKey, Error> where
    __CodecInputEdqy: Input, 

impl Decode for U256

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

impl Decode for U512

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

impl Decode for H160

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

impl Decode for H512

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

impl Decode for H128

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

impl Decode for H256

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

impl Decode for U128

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

impl<T> Decode for Crossing<T> where
    T: Encode + Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Crossing<T>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for EcdsaVerifyError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<EcdsaVerifyError, Error> where
    __CodecInputEdqy: Input, 

impl Decode for StorageProof

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageProof, Error> where
    __CodecInputEdqy: Input, 

impl Decode for CompactProof

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CompactProof, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ArithmeticError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ArithmeticError, Error> where
    __CodecInputEdqy: Input, 

impl Decode for TestSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TestSignature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for BadOrigin

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BadOrigin, Error> where
    __CodecInputEdqy: Input, 

impl Decode for UintAuthorityId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<UintAuthorityId, Error> where
    __CodecInputEdqy: Input, 

impl Decode for OpaqueExtrinsic

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueExtrinsic, Error> where
    __CodecInputEdqy: Input, 

impl Decode for LookupError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<LookupError, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExtrinsicWrapper<Xt>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Time

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Time, Error> where
    __CodecInputEdqy: Input, 

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

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

impl Decode for MultiSignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSignature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Justifications

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Justifications, Error> where
    __CodecInputEdqy: Input, 

impl<B> Decode for BlockAndTimeDeadline<B> where
    B: BlockNumberProvider,
    <B as BlockNumberProvider>::BlockNumber: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BlockAndTimeDeadline<B>, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DispatchErrorWithPostInfo<Info>, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Digest<Hash>, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Block<Xt>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for RuntimeString

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

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

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

impl Decode for MultiSigner

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiSigner, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<SignedBlock<Block>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for TokenError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TokenError, Error> where
    __CodecInputEdqy: Input, 

impl Decode for ChangesTrieSignal

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ChangesTrieSignal, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Header<Number, Hash>, Error> where
    __CodecInputEdqy: Input, 

impl<AccountId, AccountIndex> Decode for MultiAddress<AccountId, AccountIndex> where
    AccountId: Decode,
    AccountIndex: HasCompact, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<MultiAddress<AccountId, AccountIndex>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Era

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

impl Decode for AnySignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AnySignature, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TestXt<Call, Extra>, Error> where
    __CodecInputEdqy: Input, 

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Block<Header, Extrinsic>, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, Error> where
    __CodecInputEdqy: Input, 

impl Decode for FixedI64

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedI64, Error> where
    __CodecInputEdqy: Input, 

impl Decode for FixedU128

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedU128, Error> where
    __CodecInputEdqy: Input, 

impl Decode for BigUint

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BigUint, Error> where
    __CodecInputEdqy: Input, 

impl Decode for PerU16

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

impl Decode for Perquintill

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

impl Decode for Permill

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

impl Decode for Perbill

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

impl Decode for Percent

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

impl Decode for FixedI128

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedI128, Error> where
    __CodecInputEdqy: Input, 

impl<Reporter, Offender> Decode for OffenceDetails<Reporter, Offender> where
    Offender: Decode,
    Vec<Reporter, Global>: Decode, 

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OffenceDetails<Reporter, Offender>, Error> where
    __CodecInputEdqy: Input, 

Implementors

impl Decode for Void

impl Decode for DispatchError

impl Decode for InvalidTransaction

impl Decode for TransactionSource

impl Decode for TransactionValidityError

impl Decode for UnknownTransaction

impl Decode for KillStorageResult

impl Decode for BalanceStatus

impl Decode for DispatchClass

impl Decode for Pays

impl Decode for EventMetadata

impl Decode for OuterEventMetadata

impl Decode for CheckInherentsResult

impl Decode for InherentData

impl Decode for ValidTransaction

impl Decode for PalletId

impl Decode for StorageInfo

impl Decode for StorageVersion

impl Decode for WithdrawReasons

impl Decode for DispatchInfo

impl Decode for PostDispatchInfo

impl Decode for RuntimeDbWeight

impl Decode for ErrorMetadata

impl Decode for FunctionArgumentMetadata

impl Decode for FunctionMetadata

impl Decode for ModuleConstantMetadata

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

impl<Balance> Decode for WeightToFeeCoefficient<Balance> where
    Balance: Decode,
    Balance: Decode, 

impl<BlockNumber> Decode for DispatchTime<BlockNumber> where
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode,
    BlockNumber: Decode, 

impl<K, V, S> Decode for BoundedBTreeMap<K, V, S> where
    K: Decode + Ord,
    V: Decode,
    S: Get<u32>, 

impl<T> Decode for PhantomData<T>

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

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

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

impl<T, S> Decode for BoundedBTreeSet<T, S> where
    T: Decode + Ord,
    S: Get<u32>, 

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

impl<T: Decode, S: Get<u32>> Decode for BoundedVec<T, S>

impl<T: Decode, S: Get<u32>> Decode for WeakBoundedVec<T, S>