Trait parity_scale_codec::Decode

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

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

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

Required methods

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

Attempt to deserialise the value from input.

Loading content...

Provided methods

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

Attempt to skip the encoded value from input.

The default implementation of this function is just calling Decode::decode. When possible, an implementation should provided a specialized implementation.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

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

Loading content...

Implementations on Foreign Types

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

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

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

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

impl Decode for NonZeroI8

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

impl Decode for NonZeroI16

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

impl Decode for NonZeroI32

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

impl Decode for NonZeroI64

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

impl Decode for NonZeroI128

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

impl Decode for NonZeroU8

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

impl Decode for NonZeroU16

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

impl Decode for NonZeroU32

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

impl Decode for NonZeroU64

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

impl Decode for NonZeroU128

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

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

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

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

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

impl<T> Decode for PhantomData<T>

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

impl Decode for String

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

impl<T: Decode> Decode for Vec<T>

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

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

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

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

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

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

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

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

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

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

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

impl Decode for ()

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

impl<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> Decode for (A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<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> Decode for (B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<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> Decode for (C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<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> Decode for (D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<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> Decode for (E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<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> Decode for (F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<G0: Decode, H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<H0: Decode, I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<I0: Decode, J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<J0: Decode, K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (J0, K0, L0, M0, N0, O0, P0, Q0, R0)

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

impl<K0: Decode, L0: Decode, M0: Decode, N0: Decode, O0: Decode, P0: Decode, Q0: Decode, R0: Decode> Decode for (K0, L0, M0, N0, O0, P0, Q0, R0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Decode for u16

const TYPE_INFO: TypeInfo

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

impl Decode for u32

const TYPE_INFO: TypeInfo

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

impl Decode for u64

const TYPE_INFO: TypeInfo

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

impl Decode for u128

const TYPE_INFO: TypeInfo

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

impl Decode for i16

const TYPE_INFO: TypeInfo

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

impl Decode for i32

const TYPE_INFO: TypeInfo

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

impl Decode for i64

const TYPE_INFO: TypeInfo

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

impl Decode for i128

const TYPE_INFO: TypeInfo

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

impl Decode for u8

const TYPE_INFO: TypeInfo

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

impl Decode for i8

const TYPE_INFO: TypeInfo

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

impl Decode for bool

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

impl Decode for Duration

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

Loading content...

Implementors

impl Decode for Compact<u8>

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

impl Decode for Compact<u16>

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

impl Decode for Compact<u32>

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

impl Decode for Compact<u64>

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

impl Decode for Compact<u128>

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

impl Decode for Compact<()>

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

impl Decode for OptionBool

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

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

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

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

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

Loading content...