Trait Decode

pub trait Decode: Sized {
    type Error: From<Error> + Error + Send + Sync + 'static;

    // Required method
    fn decode<R>(
        reader: &mut R,
    ) -> impl Future<Output = Result<Self, Self::Error>> + MaybeSend
       where R: SeqRead;
}

Required Associated Types

type Error: From<Error> + Error + Send + Sync + 'static

Required Methods

fn decode<R>( reader: &mut R, ) -> impl Future<Output = Result<Self, Self::Error>> + MaybeSend

where R: SeqRead,

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 = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for i8

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for i16

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for i32

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for i64

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for u8

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for u16

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for u32

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for u64

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for String

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl Decode for Bytes

type Error = Error

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

impl<T> Decode for Arc<T>

where T: Decode,

type Error = <T as Decode>::Error

async fn decode<R>(reader: &mut R) -> Result<Self, Self::Error>

where R: SeqRead,

impl<T> Decode for Vec<T>

where T: Decode + Send + Sync, Error: From<<T as Decode>::Error>,

type Error = Error

async fn decode<R>(reader: &mut R) -> Result<Self, Self::Error>

where R: SeqRead,

impl<V> Decode for Option<V>

where V: Decode,

type Error = DecodeError<<V as Decode>::Error>

async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error>

Implementors