Trait Decode

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.

Dyn Compatibility§

This trait is not dyn compatible.

impl Decode for RuntimeMetadataDeprecated

Available on crate feature decode only.

Available on crate feature std only.

§

Source §

Trait Decode Copy item path

Required Methods§

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,

§Safety

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

fn encoded_fixed_size() -> Option<usize>

Dyn Compatibility§

Implementations on Foreign Types§

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 f32

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

fn encoded_fixed_size() -> Option<usize>

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 i8

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

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

fn encoded_fixed_size() -> Option<usize>

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 i128

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

fn encoded_fixed_size() -> Option<usize>

impl Decode for u8

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

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

fn encoded_fixed_size() -> Option<usize>

impl Decode for u64

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

fn encoded_fixed_size() -> Option<usize>

impl Decode for u128

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

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

impl Decode for NonZero<i8>

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

impl Decode for NonZero<i16>

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

impl Decode for NonZero<i32>

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

impl Decode for NonZero<i64>

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

impl Decode for NonZero<i128>

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

impl Decode for NonZero<u8>

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

impl Decode for NonZero<u16>

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

impl Decode for NonZero<u32>

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

impl Decode for NonZero<u64>

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

impl Decode for NonZero<u128>

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

impl Decode for Duration

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

impl Decode for AccountId32

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

impl Decode for AnySignature

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

impl Decode for ArithmeticError

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

impl Decode for BadOrigin

Trait Decode

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn decode<CodecInputEdqy>( codec_input_edqy: &mut CodecInputEdqy, ) -> Result<ExtrinsicInclusionMode, Error>
where CodecInputEdqy: Input,

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

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

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

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