Trait destream::de::FromStream

pub trait FromStream: Send + Sized {
#[must_use]    pub fn from_stream<'life0, 'async_trait, D: Decoder>(
        decoder: &'life0 mut D
    ) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>>
    where
        D: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
}

This trait describes a value which can be decoded from a stream.

Based on serde::de::Deserialize.

Required methods

#[must_use]pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Parse this value using the given Decoder.

Loading content...

Implementations on Foreign Types

impl FromStream for bool

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i8

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i16

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i32

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for i64

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u8

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u16

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u32

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for u64

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for f32

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for f64

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl FromStream for String

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for Option<T>

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: Send + ?Sized> FromStream for PhantomData<T>

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for BinaryHeap<T> where
    T: FromStream + Ord, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for BTreeSet<T> where
    T: FromStream + Eq + Ord, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for LinkedList<T> where
    T: FromStream, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T, S> FromStream for HashSet<T, S> where
    T: FromStream + Eq + Hash,
    S: BuildHasher + Default + Send, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for VecDeque<T> where
    T: FromStream, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T> FromStream for Vec<T> where
    T: FromStream, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 0]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, <D as Decoder>::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 1]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 2]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 3]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 4]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 5]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 6]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 7]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 8]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 9]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 10]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 11]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 12]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 13]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 14]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 15]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 16]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 17]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 18]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 19]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 20]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 21]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 22]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 23]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 24]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 25]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 26]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 27]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 28]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 29]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 30]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 31]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T: FromStream> FromStream for [T; 32]

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream> FromStream for (T0,)

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream, T1: FromStream> FromStream for (T0, T1)

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream, T1: FromStream, T2: FromStream> FromStream for (T0, T1, T2)

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<T0: FromStream, T1: FromStream, T2: FromStream, T3: FromStream> FromStream for (T0, T1, T2, T3)

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<K, V> FromStream for BTreeMap<K, V> where
    K: FromStream + Ord,
    V: FromStream, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

impl<K, V, S> FromStream for HashMap<K, V, S> where
    K: FromStream + Eq + Hash,
    V: FromStream,
    S: BuildHasher + Default + Send, 

pub fn from_stream<'life0, 'async_trait, D: Decoder>(
    decoder: &'life0 mut D
) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>> where
    D: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Loading content...

Implementors

Loading content...