Trait diny_core::backend::FormatDeserialize[−][src]

pub trait FormatDeserialize: FormatDecode {

Show 36 associated items    type DeserializeUnit: Future<Output = Result<(), Self::Error>> + Unpin;
    type DeserializeBool: Future<Output = Result<bool, Self::Error>> + Unpin;
    type DeserializeI8: Future<Output = Result<i8, Self::Error>> + Unpin;
    type DeserializeI16: Future<Output = Result<i16, Self::Error>> + Unpin;
    type DeserializeI32: Future<Output = Result<i32, Self::Error>> + Unpin;
    type DeserializeI64: Future<Output = Result<i64, Self::Error>> + Unpin;
    type DeserializeI128: Future<Output = Result<i128, Self::Error>> + Unpin;
    type DeserializeU8: Future<Output = Result<u8, Self::Error>> + Unpin;
    type DeserializeU16: Future<Output = Result<u16, Self::Error>> + Unpin;
    type DeserializeU32: Future<Output = Result<u32, Self::Error>> + Unpin;
    type DeserializeU64: Future<Output = Result<u64, Self::Error>> + Unpin;
    type DeserializeU128: Future<Output = Result<u128, Self::Error>> + Unpin;
    type DeserializeF32: Future<Output = Result<f32, Self::Error>> + Unpin;
    type DeserializeF64: Future<Output = Result<f64, Self::Error>> + Unpin;
    type DeserializeChar: Future<Output = Result<char, Self::Error>> + Unpin;
    type DeserializeString: Future<Output = Result<String, Self::Error>> + Unpin;
    type DeserializeVariantIdx: Future<Output = Result<VariantIdx, Self::Error>> + Unpin;
    type DeserializeSequenceLen: Future<Output = Result<SequenceLen, Self::Error>> + Unpin;
    fn deserialize_unit<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeUnit
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_bool<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeBool
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_i8<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeI8
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_i16<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeI16
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_i32<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeI32
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_i64<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeI64
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_i128<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeI128
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_u8<'r, R>(&'r self, reader: &'r mut R) -> Self::DeserializeU8
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_u16<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeU16
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_u32<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeU32
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_u64<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeU64
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_u128<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeU128
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_f32<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeF32
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_f64<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeF64
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_char<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeChar
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_string<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeString
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_variant_idx<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeVariantIdx
    where
        R: AsyncBufRead + Unpin;

    fn deserialize_sequence_len<'r, R>(
        &'r self, 
        reader: &'r mut R
    ) -> Self::DeserializeSequenceLen
    where
        R: AsyncBufRead + Unpin;

}
Expand description

Define the primitive deserialization methods and the concrete futures they return.

Associated Types

This is supported on crate features std or alloc only.

Required methods

This is supported on crate features std or alloc only.

Implementors