Trait Decode 

pub trait Decode: Sized {
    type Error: Error;

    // Required method
    fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>;
}

A trait for decoding types from Essential Words in a manner compatible with Pint’s ABI.

Required Associated Types

type Error: Error

Any error that might occur during decoding.

Required Methods

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

Decode an instance of Self from words read from the given reader.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Decode for bool

type Error = BoolError

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode> Decode for (A, B)

type Error = PairError<<A as Decode>::Error, <B as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode> Decode for (A, B, C)

type Error = PairError<<A as Decode>::Error, <(B, C) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode> Decode for (A, B, C, D)

type Error = PairError<<A as Decode>::Error, <(B, C, D) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode> Decode for (A, B, C, D, E)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode> Decode for (A, B, C, D, E, F)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode> Decode for (A, B, C, D, E, F, G)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode> Decode for (A, B, C, D, E, F, G, H)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G, H) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode> Decode for (A, B, C, D, E, F, G, H, I)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G, H, I) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode> Decode for (A, B, C, D, E, F, G, H, I, J)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G, H, I, J) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode> Decode for (A, B, C, D, E, F, G, H, I, J, K)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G, H, I, J, K) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<A: Decode, B: Decode, C: Decode, D: Decode, E: Decode, F: Decode, G: Decode, H: Decode, I: Decode, J: Decode, K: Decode, L: Decode> Decode for (A, B, C, D, E, F, G, H, I, J, K, L)

type Error = PairError<<A as Decode>::Error, <(B, C, D, E, F, G, H, I, J, K, L) as Decode>::Error>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

impl<T> Decode for Option<T>

where T: Decode,

type Error = PairError<<T as Decode>::Error, SizedError>

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

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

where T: Decode,

type Error = <T as Decode>::Error

fn decode<R: Read>(r: &mut R) -> Result<Self, Self::Error>

Implementors

impl Decode for Word

type Error = SizedError