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

    // Provided methods
    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§

source

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

Attempt to deserialise the value from input.

Provided Methods§

source

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.

source

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Implementations on Foreign Types§

source§

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,

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroI32

source§

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

source§

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

source§

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

source§

impl<O, T> Decode for BitBox<T, O>where O: BitOrder, T: BitStore + Decode,

source§

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

source§

impl Decode for i8

source§

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

source§

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,

source§

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,

source§

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

source§

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

source§

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,

source§

impl Decode for NonZeroU128

source§

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

source§

impl<T> Decode for PhantomData<T>

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU16

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU32

source§

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

source§

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,

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

impl Decode for Bytes

source§

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

source§

impl Decode for NonZeroI128

source§

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

source§

impl Decode for String

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for ()

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for NonZeroU64

source§

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

source§

impl Decode for i32

source§

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

source§

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,

source§

impl Decode for u128

source§

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

source§

impl Decode for u64

source§

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

source§

impl Decode for u8

source§

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

source§

impl Decode for i64

source§

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

source§

impl Decode for NonZeroI8

source§

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

source§

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,

source§

impl Decode for i128

source§

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

source§

impl<O, T> Decode for BitVec<T, O>where O: BitOrder, T: BitStore + Decode,

source§

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

source§

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,

source§

impl Decode for u16

source§

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

source§

impl Decode for f64

source§

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

source§

impl Decode for bool

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Duration

source§

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

source§

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,

source§

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,

source§

impl Decode for NonZeroI16

source§

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

source§

impl Decode for f32

source§

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

source§

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,

source§

impl Decode for u32

source§

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

source§

impl Decode for NonZeroI64

source§

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

source§

impl Decode for NonZeroU8

source§

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

source§

impl Decode for i16

source§

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

source§

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

source§

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

source§

impl<Header, Extrinsic> Decode for Block<Header, Extrinsic>where Extrinsic: MaybeSerialize, 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 Decode for Time

source§

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

source§

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

source§

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

source§

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

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Digest, 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<Xt> Decode for ExtrinsicWrapper<Xt>where Xt: Decode,

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<ExtrinsicWrapper<Xt>, 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 Decode for ModuleError

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for RuntimeString

source§

fn decode<I>(value: &mut I) -> Result<RuntimeString, Error>where I: 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<T> Decode for TypeDefVariant<T>where T: Form, Vec<Variant<T>, Global>: Decode,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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

source§

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

source§

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

source§

impl Decode for TypeDefPrimitive

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for PortableRegistry

source§

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

source§

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

source§

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<TypeDefArray<T>, 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 PerU16

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for Timestamp

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for LocalizedSignature

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl Decode for H384

source§

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

source§

impl Decode for U512

source§

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

source§

impl Decode for H128

source§

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

source§

impl Decode for U256

source§

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

source§

impl Decode for H256

source§

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

source§

impl Decode for H512

source§

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

source§

impl Decode for H160

source§

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

source§

impl Decode for H768

source§

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

source§

impl Decode for U128

source§

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

source§

impl Decode for KillStorageResult

source§

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

source§

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

source§

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

Implementors§

source§

impl Decode for OptionBool

source§

impl Decode for Compact<u8>

source§

impl Decode for Compact<u16>

source§

impl Decode for Compact<u32>

source§

impl Decode for Compact<u64>

source§

impl Decode for Compact<u128>

source§

impl Decode for Compact<()>

source§

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

source§

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

source§

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