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

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

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 decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

The default implementation will just call Decode::decode.

Safety

If this function returns Ok then dst must be properly initialized.

This is enforced by requiring the implementation to return a [DecodeFinished] which can only be created by calling [DecodeFinished::assert_decoding_finished] which is unsafe.

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 provide 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§

source§

impl Decode for RuntimeString

source§

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

source§

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

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for OpaqueExtrinsic

source§

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

source§

impl Decode for AnySignature

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for TransactionValidityError

source§

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

source§

impl Decode for UintAuthorityId

source§

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

source§

impl Decode for Era

source§

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

source§

impl Decode for Time

source§

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

source§

impl Decode for TransactionSource

source§

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

source§

impl<Block> Decode for BlockId<Block>where Block: Block, <Block as Block>::Hash: Decode, <<Block as Block>::Header as Header>::Number: Decode,

source§

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

source§

impl Decode for DigestItem

source§

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

source§

impl Decode for MultiSigner

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for InvalidTransaction

source§

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

source§

impl Decode for TestSignature

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for ModuleError

source§

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

source§

impl Decode for LookupError

source§

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

source§

impl Decode for ValidTransaction

source§

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

source§

impl Decode for BadOrigin

source§

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

source§

impl Decode for UnknownTransaction

source§

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

source§

impl Decode for DispatchError

source§

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

source§

impl Decode for MultiSignature

source§

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

source§

impl Decode for TransactionalError

source§

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

source§

impl Decode for Digest

source§

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

source§

impl Decode for Justifications

source§

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

source§

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

source§

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

source§

impl Decode for TokenError

source§

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

source§

impl Decode for ModuleError

source§

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

source§

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

source§

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

§

impl Decode for NonZeroU128

§

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

§

impl Decode for i8

§

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

§

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

§

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

§

impl Decode for u128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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 Decode for f64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for NonZeroI16

§

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

§

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

§

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

§

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 NonZeroU64

§

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

§

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

§

impl Decode for NonZeroU32

§

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

§

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

§

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

§

impl Decode for bool

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for NonZeroI64

§

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

§

impl Decode for i128

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for NonZeroI8

§

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

§

impl Decode for NonZeroI128

§

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

§

impl Decode for Bytes

§

fn decode<I>(input: &mut I) -> Result<Bytes, 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 Vec<T, Global>where T: Decode,

§

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

§

impl Decode for NonZeroU16

§

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

§

impl Decode for i32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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

§

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

§

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<R0> Decode for (R0,)where R0: Decode,

§

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

§

impl Decode for i16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for NonZeroU8

§

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

§

impl Decode for i64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

impl Decode for ()

§

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

§

impl Decode for u8

§

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

§

impl Decode for String

§

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

§

impl Decode for f32

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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,

§

impl Decode for NonZeroI32

§

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

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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

§

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

§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<[T; N]> ) -> Result<DecodeFinished, Error>where I: Input,

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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,

§

impl Decode for Duration

§

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

§

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

§

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

§

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

§

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

§

impl Decode for u16

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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 Decode for u64

§

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

§

fn encoded_fixed_size() -> Option<usize>

§

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<K, V> Decode for BTreeMap<K, V, Global>where K: Decode + Ord, V: Decode,

§

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

§

impl<T> Decode for TypeParameter<T>where T: Form, <T as Form>::String: Decode, Option<<T as Form>::Type>: Decode,

§

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

§

impl<T> Decode for TypeDef<T>where T: Form, TypeDefComposite<T>: Decode, TypeDefVariant<T>: Decode, TypeDefSequence<T>: Decode, TypeDefArray<T>: Decode, TypeDefTuple<T>: Decode, TypeDefCompact<T>: Decode, TypeDefBitSequence<T>: Decode,

§

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

§

impl<T> Decode for UntrackedSymbol<T>where PhantomData<fn() -> T>: Decode,

§

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

§

impl<T> Decode for Path<T>where T: Form, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl<T> Decode for Field<T>where T: Form, Option<<T as Form>::String>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl Decode for TypeDefPrimitive

§

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

§

impl Decode for PortableRegistry

§

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

§

impl<T> Decode for TypeDefTuple<T>where T: Form, Vec<<T as Form>::Type, Global>: Decode,

§

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

§

impl<T> Decode for Type<T>where T: Form, Path<T>: Decode, Vec<TypeParameter<T>, Global>: Decode, TypeDef<T>: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl<T> Decode for TypeDefArray<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for Variant<T>where T: Form, <T as Form>::String: Decode, Vec<Field<T>, Global>: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl<T> Decode for TypeDefCompact<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for TypeDefVariant<T>where T: Form, Vec<Variant<T>, Global>: Decode,

§

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

§

impl<T> Decode for TypeDefComposite<T>where T: Form, Vec<Field<T>, Global>: Decode,

§

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

§

impl<T> Decode for TypeDefBitSequence<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for TypeDefSequence<T>where T: Form, <T as Form>::Type: Decode,

§

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

source§

impl Decode for Perquintill

source§

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

source§

impl Decode for FixedI128

source§

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

source§

impl Decode for Permill

source§

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

source§

impl Decode for Percent

source§

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

source§

impl Decode for ArithmeticError

source§

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

source§

impl Decode for PerU16

source§

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

source§

impl Decode for FixedI64

source§

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

source§

impl Decode for BigUint

source§

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

source§

impl Decode for FixedU64

source§

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

source§

impl Decode for Perbill

source§

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

source§

impl Decode for FixedU128

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl<T> Decode for Signature<T>where PhantomData<fn() -> T>: Decode,

source§

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

source§

impl Decode for VrfOutput

source§

fn decode<R>(i: &mut R) -> Result<VrfOutput, Error>where R: Input,

source§

impl Decode for VrfSignature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for LogLevel

source§

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

source§

impl Decode for KeyTypeId

source§

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

source§

impl Decode for OpaqueMetadata

source§

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

source§

impl Decode for CryptoTypeId

source§

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

source§

impl Decode for Timestamp

source§

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

source§

impl Decode for RingVrfSignature

source§

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

source§

impl Decode for VrfSignature

source§

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

source§

impl Decode for LogLevelFilter

source§

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

source§

impl Decode for OpaquePeerId

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for OpaqueMultiaddr

source§

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

source§

impl Decode for VrfProof

source§

fn decode<R>(i: &mut R) -> Result<VrfProof, Error>where R: Input,

source§

impl Decode for RingContext

source§

fn decode<R>(i: &mut R) -> Result<RingContext, Error>where R: Input,

source§

impl Decode for Signature

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for OpaqueNetworkState

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Signature

source§

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

source§

impl Decode for Duration

source§

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

source§

impl Decode for Void

source§

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

source§

impl Decode for VrfOutput

source§

fn decode<R>(i: &mut R) -> Result<VrfOutput, Error>where R: Input,

source§

impl Decode for StorageKind

source§

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

source§

impl Decode for DeriveJunction

source§

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

source§

impl<T> Decode for Public<T>where PhantomData<fn() -> T>: Decode,

source§

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

source§

impl Decode for HttpRequestStatus

source§

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

source§

impl Decode for Public

source§

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

source§

impl Decode for HttpError

source§

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

source§

impl Decode for HttpRequestId

source§

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

source§

impl Decode for AccountId32

source§

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

source§

impl Decode for ReturnValue

source§

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

source§

impl Decode for Value

source§

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

source§

impl Decode for WasmLevel

source§

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

source§

impl Decode for WasmMetadata

source§

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

source§

impl Decode for WasmValue

source§

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

source§

impl Decode for WasmFields

source§

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

source§

impl Decode for WasmEntryAttributes

source§

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

source§

impl Decode for WasmValuesSet

source§

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

source§

impl Decode for WasmFieldName

source§

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

source§

impl Decode for MultiRemovalResults

source§

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

source§

impl Decode for StorageData

source§

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

source§

impl Decode for StateVersion

source§

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

source§

impl Decode for StorageKey

source§

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

source§

impl Decode for ChildTrieParentKeyId

source§

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

source§

impl Decode for TrackedStorageKey

source§

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

source§

impl Decode for ChildInfo

source§

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

§

impl Decode for U512

§

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

§

impl Decode for H256

§

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

§

impl Decode for H384

§

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

§

impl Decode for H512

§

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

§

impl Decode for H128

§

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

§

impl Decode for U256

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

§

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

source§

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

source§

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

source§

impl Decode for EcdsaVerifyError

source§

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

source§

impl Decode for KillStorageResult

source§

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

source§

impl Decode for StorageProof

source§

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

source§

impl Decode for CompactProof

source§

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

source§

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

source§

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

source§

impl Decode for OldWeight

source§

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

source§

impl Decode for RuntimeDbWeight

source§

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

source§

impl Decode for DispatchClass

source§

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

source§

impl<AccountId> Decode for RawOrigin<AccountId>where AccountId: Decode,

source§

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

source§

impl Decode for StorageVersion

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for DispatchInfo

source§

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

source§

impl<T, Hash> Decode for MaybeHashed<T, Hash>where T: Decode, Hash: Decode,

source§

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

source§

impl Decode for Never

source§

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

source§

impl Decode for ProcessMessageError

source§

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

source§

impl Decode for Select

source§

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

source§

impl Decode for LookupError

source§

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

source§

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

source§

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

source§

impl Decode for PostDispatchInfo

source§

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

source§

impl Decode for UpgradeCheckSelect

source§

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

source§

impl Decode for PaymentStatus

source§

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

source§

impl Decode for WithdrawReasons

source§

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

source§

impl Decode for StorageInfo

source§

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

source§

impl Decode for PalletId

source§

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

source§

impl Decode for Pays

source§

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

source§

impl Decode for VersionedPostUpgradeData

source§

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

source§

impl Decode for BalanceStatus

source§

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

source§

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

source§

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

source§

impl<T> Decode for Bounded<T>where PhantomData<T>: Decode,

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for CrateVersion

source§

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

§

impl<T> Decode for PalletCallMetadata<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for ExtrinsicMetadata<T>where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>, Global>: Decode,

§

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

§

impl<T> Decode for PalletMetadata<T>where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>, Global>: Decode, Option<PalletErrorMetadata<T>>: Decode,

§

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

§

impl<T> Decode for StorageEntryMetadata<T>where T: Form, <T as Form>::String: Decode, StorageEntryType<T>: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl Decode for RuntimeMetadataV14

§

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

§

impl<T> Decode for OuterEnums<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for PalletEventMetadata<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for RuntimeApiMethodMetadata<T>where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodParamMetadata<T>, Global>: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl Decode for OpaqueMetadata

§

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

§

impl<T> Decode for StorageEntryType<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for SignedExtensionMetadata<T>where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

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

§

impl Decode for RuntimeMetadataPrefixed

§

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

§

impl Decode for StorageEntryModifier

§

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

§

impl<T> Decode for PalletStorageMetadata<T>where T: Form, <T as Form>::String: Decode, Vec<StorageEntryMetadata<T>, Global>: Decode,

§

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

§

impl Decode for RuntimeMetadataDeprecated

§

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

§

impl<T> Decode for RuntimeApiMethodParamMetadata<T>where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

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

§

impl Decode for RuntimeMetadataV15

§

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

§

impl<T> Decode for ExtrinsicMetadata<T>where T: Form, <T as Form>::Type: Decode, Vec<SignedExtensionMetadata<T>, Global>: Decode,

§

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

§

impl Decode for StorageHasher

§

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

§

impl<T> Decode for PalletErrorMetadata<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for CustomMetadata<T>where T: Form, BTreeMap<<T as Form>::String, CustomValueMetadata<T>, Global>: Decode,

§

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

§

impl<T> Decode for RuntimeApiMetadata<T>where T: Form, <T as Form>::String: Decode, Vec<RuntimeApiMethodMetadata<T>, Global>: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl<T> Decode for PalletConstantMetadata<T>where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl<T> Decode for CustomValueMetadata<T>where T: Form, <T as Form>::Type: Decode,

§

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

§

impl<T> Decode for PalletMetadata<T>where T: Form, <T as Form>::String: Decode, Option<PalletStorageMetadata<T>>: Decode, Option<PalletCallMetadata<T>>: Decode, Option<PalletEventMetadata<T>>: Decode, Vec<PalletConstantMetadata<T>, Global>: Decode, Option<PalletErrorMetadata<T>>: Decode, Vec<<T as Form>::String, Global>: Decode,

§

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

§

impl Decode for RuntimeMetadata

§

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

§

impl<T> Decode for SignedExtensionMetadata<T>where T: Form, <T as Form>::String: Decode, <T as Form>::Type: Decode,

§

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

source§

impl Decode for InherentData

source§

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

source§

impl Decode for CheckInherentsResult

source§

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

source§

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

source§

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

source§

impl Decode for DisableStrategy

source§

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

source§

impl Decode for RuntimeVersion

source§

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

source§

impl Decode for ElectionScore

source§

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

source§

impl<AccountId> Decode for StakedAssignment<AccountId>where AccountId: Decode, Vec<(AccountId, u128), Global>: Decode,

source§

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

source§

impl<T> Decode for CheckWeight<T>where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

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

source§

impl Decode for BlockLength

source§

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

source§

impl<E, T> Decode for EventRecord<E, T>where E: Parameter + Member + Decode, Vec<T, Global>: Decode,

source§

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

source§

impl<T> Decode for CheckNonce<T>where T: Config, <T as Config>::Nonce: HasCompact,

source§

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

source§

impl<T> Decode for CheckMortality<T>where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

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

source§

impl<T> Decode for Call<T>where T: Config,

source§

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

source§

impl Decode for LastRuntimeUpgradeInfo

source§

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

source§

impl<T> Decode for CheckTxVersion<T>where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

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

source§

impl<T> Decode for CheckSpecVersion<T>where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

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

source§

impl<T> Decode for CheckGenesis<T>where T: Config + Send + Sync, PhantomData<T>: Decode,

source§

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

source§

impl<T> Decode for Error<T>

source§

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

source§

impl Decode for BlockWeights

source§

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

source§

impl Decode for Phase

source§

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

source§

impl<T> Decode for CheckNonZeroSender<T>where PhantomData<T>: Decode,

source§

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

source§

impl Decode for WeightsPerClass

source§

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

source§

impl<Nonce, AccountData> Decode for AccountInfo<Nonce, AccountData>where Nonce: Decode, AccountData: Decode,

source§

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

source§

impl<T> Decode for Event<T>where T: Config, <T as Config>::AccountId: Decode, <T as Config>::Hash: Decode,

source§

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

Implementors§

source§

impl Decode for Weight

§

impl Decode for Compact<u8>

§

impl Decode for Compact<u16>

§

impl Decode for Compact<u32>

§

impl Decode for Compact<u64>

§

impl Decode for Compact<u128>

§

impl Decode for Compact<()>

§

impl Decode for OptionBool

source§

impl<AccountId> Decode for Support<AccountId>where Vec<(AccountId, u128), Global>: Decode,

source§

impl<AccountId, P> Decode for Assignment<AccountId, P>where P: PerThing, AccountId: Decode, Vec<(AccountId, P), Global>: Decode,

§

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

§

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

§

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

source§

impl<VoterIndex, TargetIndex, P: PerThing> Decode for IndexAssignment<VoterIndex, TargetIndex, P>where VoterIndex: Decode, Vec<(TargetIndex, P)>: Decode,