Trait Decode 

pub trait Decode: Sized {
    // Required method
    fn decode_from<'life0, 'async_trait, R>(
        config: &'life0 Config,
        reader: R,
    ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>
       where R: Read + Unpin + Send + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait;
}

Trait for decoding values

Required Methods

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Decodes values from reader

Equivalent to:

async fn decode_from<R>(reader: R) -> Result<Self>
where
    R: Read + Unpin + Send

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

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for char

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for f32

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for f64

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for i8

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for i16

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for i32

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for i64

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for i128

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for isize

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for u8

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for u16

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for u32

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for u64

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for u128

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for ()

fn decode_from<'life0, 'async_trait, R>( _config: &'life0 Config, _reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for usize

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for CString

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for String

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroI8

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroI16

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroI32

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroI64

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroI128

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroIsize

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroU8

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroU16

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroU32

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroU64

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroU128

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl Decode for NonZeroUsize

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<'a, T> Decode for Cow<'a, T>

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

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<K, V> Decode for BTreeMap<K, V>

where K: Decode + Send + Ord, V: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<K, V, S> Decode for HashMap<K, V, S>

where K: Decode + Send + Eq + Hash, V: Decode + Send, S: BuildHasher + Default + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0> Decode for (T0,)

where T0: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1> Decode for (T0, T1)

where T0: Decode + Send, T1: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2> Decode for (T0, T1, T2)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3> Decode for (T0, T1, T2, T3)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4> Decode for (T0, T1, T2, T3, T4)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5> Decode for (T0, T1, T2, T3, T4, T5)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6> Decode for (T0, T1, T2, T3, T4, T5, T6)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7> Decode for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send, T11: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send, T11: Decode + Send, T12: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send, T11: Decode + Send, T12: Decode + Send, T13: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send, T11: Decode + Send, T12: Decode + Send, T13: Decode + Send, T14: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Decode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: Decode + Send, T1: Decode + Send, T2: Decode + Send, T3: Decode + Send, T4: Decode + Send, T5: Decode + Send, T6: Decode + Send, T7: Decode + Send, T8: Decode + Send, T9: Decode + Send, T10: Decode + Send, T11: Decode + Send, T12: Decode + Send, T13: Decode + Send, T14: Decode + Send, T15: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for Option<T>

where T: Decode,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 1]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 2]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 3]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 4]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 5]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 6]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 7]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 8]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 9]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 10]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 11]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 12]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 13]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 14]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 15]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 16]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 17]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 18]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 19]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 20]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 21]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 22]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 23]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 24]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 25]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 26]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 27]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 28]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 29]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 30]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 31]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 32]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 33]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 34]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 35]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 36]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 37]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 38]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 39]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 40]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 41]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 42]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 43]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 44]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 45]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 46]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 47]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 48]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 49]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 50]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 51]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 52]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 53]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 54]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 55]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 56]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 57]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 58]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 59]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 60]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 61]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 62]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 63]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 64]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 128]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 256]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 512]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for [T; 1024]

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for Box<T>

where T: Decode,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for BinaryHeap<T>

where T: Decode + Send + Ord,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for BTreeSet<T>

where T: Decode + Send + Ord,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for LinkedList<T>

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for VecDeque<T>

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for Rc<T>

where T: Decode,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for Arc<T>

where T: Decode,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for Vec<T>

where T: Decode + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T> Decode for PhantomData<T>

where T: ?Sized,

fn decode_from<'life0, 'async_trait, R>( _config: &'life0 Config, _reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

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

where T: Decode, E: Decode,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<T, S> Decode for HashSet<T, S>

where T: Decode + Send + Eq + Hash, S: BuildHasher + Default + Send,

fn decode_from<'life0, 'async_trait, R>( config: &'life0 Config, reader: R, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where R: Read + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Implementors