Trait frame_support::dispatch::Decode

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

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

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

Required methods

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

Attempt to deserialise the value from input.

Loading content...

Provided methods

pub 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.

pub 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.

Loading content...

Implementations on Foreign Types

impl Decode for WasmFields

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmFields, 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 WasmMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmMetadata, 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 WasmFieldName

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

impl Decode for WasmValue

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<WasmValue, 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 i64

pub const TYPE_INFO: TypeInfo

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

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

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

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

pub fn decode<INPUT>(
    input: &mut INPUT
) -> Result<(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 Decode for Compact<u16>

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

pub fn decode<I>(_input: &mut I) -> Result<Compact<()>, 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<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 Decode for Compact<u128>

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

impl Decode for i128

pub const TYPE_INFO: TypeInfo

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

impl Decode for NonZeroU64

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

impl Decode for NonZeroU32

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

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

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

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<i8, Error> where
    I: 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<T> Decode for VecDeque<T> where
    T: Decode, 

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

impl Decode for NonZeroU128

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

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

pub const TYPE_INFO: TypeInfo

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

pub const TYPE_INFO: TypeInfo

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

impl Decode for NonZeroI32

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

impl Decode for u32

pub const TYPE_INFO: TypeInfo

pub fn decode<I>(input: &mut I) -> Result<u32, 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<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
    G0: Decode,
    B0: 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 Option<T> where
    T: Decode, 

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

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

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

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

pub const TYPE_INFO: TypeInfo

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

impl Decode for NonZeroU16

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

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueNetworkState, 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 ExternEntity

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ExternEntity, 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 EnvironmentDefinition

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<EnvironmentDefinition, 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 DeriveJunction

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<DeriveJunction, 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 Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, 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 Public

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Public, 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 KeyTypeId

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<KeyTypeId, 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 Timestamp

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

impl Decode for NeverNativeValue

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

impl Decode for AccountId32

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AccountId32, 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 Signature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Signature, 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 CryptoTypePublicPair

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CryptoTypePublicPair, 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 OpaqueMultiaddr

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OpaqueMultiaddr, 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 HttpError

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<HttpError, 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 ReturnValue

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ReturnValue, 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 TrackedStorageKey

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<TrackedStorageKey, Error> where
    __CodecInputEdqy: 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 U128

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

impl Decode for H512

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

impl Decode for H256

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

impl Decode for H128

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

impl Decode for U256

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

impl Decode for StorageProof

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageProof, Error> where
    __CodecInputEdqy: 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 RuntimeMetadataDeprecated

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

impl Decode for RuntimeMetadataV12

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

impl Decode for ModuleId

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

impl Decode for Era

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

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

impl Decode for UintAuthorityId

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

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

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

impl Decode for TestSignature

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

impl Decode for StoredMapError

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

impl Decode for OpaqueExtrinsic

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

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

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<RandomNumberGenerator<Hashing>, 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 Decode for ChangesTrieSignal

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ChangesTrieSignal, 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<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 Decode for BadOrigin

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<BadOrigin, 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<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<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<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 AnySignature

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<AnySignature, 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<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<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 Decode for Time

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

impl Decode for RuntimeString

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

impl Decode for MultiSigner

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

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

pub fn decode<I>(input: &mut I) -> Result<Header<Number, Hash>, Error> where
    I: 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 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 FixedI64

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

impl Decode for PerU16

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

impl Decode for FixedI128

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

impl Decode for Perquintill

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

impl Decode for FixedU128

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedU128, Error> where
    __CodecInputEdqy: 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 Error

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

impl Decode for CheckInherentsResult

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<CheckInherentsResult, 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, 

Loading content...

Implementors

impl Decode for Void

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Void, 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 StorageEntryModifier

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<StorageEntryModifier, 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 StorageHasher

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

impl Decode for DispatchError

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

impl Decode for InvalidTransaction

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

impl Decode for TransactionSource

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

impl Decode for TransactionValidityError

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

impl Decode for UnknownTransaction

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

impl Decode for BalanceStatus

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

impl Decode for DispatchClass

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

impl Decode for Pays

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

impl Decode for ErrorMetadata

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

impl Decode for FunctionArgumentMetadata

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

impl Decode for FunctionMetadata

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

impl Decode for ModuleConstantMetadata

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

impl Decode for EventMetadata

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

impl Decode for OuterEventMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<OuterEventMetadata, 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 ModuleMetadata

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<ModuleMetadata, 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 StorageEntryMetadata

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

impl Decode for StorageMetadata

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

impl Decode for InherentData

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

impl Decode for ValidTransaction

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

impl Decode for PalletVersion

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

impl Decode for WithdrawReasons

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

impl Decode for DispatchInfo

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

impl Decode for PostDispatchInfo

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

impl Decode for RuntimeDbWeight

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

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

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

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

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

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

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

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

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

impl<T> Decode for PhantomData<T>

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

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

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

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

pub 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>, 

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

Loading content...