Trait diny::AsyncDeserialize

pub trait AsyncDeserialize: Decodable {
    type Future: Future + Unpin;
    fn deserialize<F, R>(format: &'r F, reader: &'r mut R) -> Self::Future
    where
        F: FormatDeserialize,
        R: AsyncBufRead + Unpin;
}

Deserialize a data structure asynchronously.

Associated Types

type Future: Future + Unpin

The concrete future returned by the deserialize method.

Required methods

fn deserialize<F, R>(format: &'r F, reader: &'r mut R) -> Self::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

Attempt to deserialize the type asynchronously for the indicated format via the provided asynchronous reader.

Implementations on Foreign Types

impl<T> AsyncDeserialize for RefCell<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, RefCell<T>, <RefCell<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <RefCell<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Cell<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Cell<T>, <Cell<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Cell<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Vec<T, Global> where
    T: Decodable, 

type Future = DeserializeExact<'r, F, R, Vec<T, Global>, <Vec<T, Global> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Vec<T, Global> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for i16

type Future = <F as FormatDeserialize>::DeserializeI16

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <i16 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for u128

type Future = <F as FormatDeserialize>::DeserializeU128

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <u128 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for i128

type Future = <F as FormatDeserialize>::DeserializeI128

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <i128 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T, const L: usize> AsyncDeserialize for [T; L] where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, [T; L], <[T; L] as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <[T; L] as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Box<T, Global> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Box<T, Global>, <Box<T, Global> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Box<T, Global> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for String

type Future = <F as FormatDeserialize>::DeserializeString

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <String as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for i64

type Future = <F as FormatDeserialize>::DeserializeI64

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <i64 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<O, E> AsyncDeserialize for Result<O, E> where
    O: AsyncDeserialize,
    E: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Result<O, E>, <Result<O, E> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Result<O, E> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for u16

type Future = <F as FormatDeserialize>::DeserializeU16

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <u16 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for i8

type Future = <F as FormatDeserialize>::DeserializeI8

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <i8 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Option<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Option<T>, <Option<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Option<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for i32

type Future = <F as FormatDeserialize>::DeserializeI32

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <i32 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for f32

type Future = <F as FormatDeserialize>::DeserializeF32

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <f32 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for bool

type Future = <F as FormatDeserialize>::DeserializeBool

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <bool as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for u64

type Future = <F as FormatDeserialize>::DeserializeU64

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <u64 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for PhantomData<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, PhantomData<T>, <PhantomData<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <PhantomData<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for VecDeque<T, Global> where
    T: Decodable, 

type Future = DeserializeExact<'r, F, R, VecDeque<T, Global>, <VecDeque<T, Global> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <VecDeque<T, Global> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for u32

type Future = <F as FormatDeserialize>::DeserializeU32

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <u32 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for BTreeSet<T> where
    T: Decodable + Ord, 

type Future = DeserializeExact<'r, F, R, BTreeSet<T>, <BTreeSet<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <BTreeSet<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Rc<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Rc<T>, <Rc<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Rc<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T, S> AsyncDeserialize for HashSet<T, S> where
    T: Decodable + Eq + Hash,
    S: BuildHasher + Default, 

type Future = DeserializeExact<'r, F, R, HashSet<T, S>, <HashSet<T, S> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <HashSet<T, S> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for Arc<T> where
    T: AsyncDeserialize, 

type Future = DeserializeExact<'r, F, R, Arc<T>, <Arc<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <Arc<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for LinkedList<T> where
    T: Decodable, 

type Future = DeserializeExact<'r, F, R, LinkedList<T>, <LinkedList<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <LinkedList<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for char

type Future = <F as FormatDeserialize>::DeserializeChar

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <char as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for f64

type Future = <F as FormatDeserialize>::DeserializeF64

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <f64 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for ()

type Future = <F as FormatDeserialize>::DeserializeUnit

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <() as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl<T> AsyncDeserialize for BinaryHeap<T> where
    T: Decodable + Ord, 

type Future = DeserializeExact<'r, F, R, BinaryHeap<T>, <BinaryHeap<T> as Decodable>::Decoder>

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <BinaryHeap<T> as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

impl AsyncDeserialize for u8

type Future = <F as FormatDeserialize>::DeserializeU8

pub fn deserialize<F, R>(
    format: &'r F,
    reader: &'r mut R
) -> <u8 as AsyncDeserialize>::Future where
    F: FormatDeserialize,
    R: AsyncBufRead + Unpin, 

Implementors

impl AsyncDeserialize for SequenceLen

type Future = <F as FormatDeserialize>::DeserializeSequenceLen

impl AsyncDeserialize for VariantIdx

type Future = <F as FormatDeserialize>::DeserializeVariantIdx