Trait diny::AsyncSerialize

pub trait AsyncSerialize: Encodable {
    type Future: Future + Unpin;
    fn serialize<F, W>(
        &'w self, 
        format: &'w F, 
        writer: &'w mut W
    ) -> Self::Future
    where
        F: FormatSerialize,
        W: AsyncWrite + Unpin;
}

Serialize a data structure asynchronously.

Associated Types

type Future: Future + Unpin

The concrete future returned by the serialize method.

Required methods

fn serialize<F, W>(&'w self, format: &'w F, writer: &'w mut W) -> Self::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

Attempt to serialize the type asynchronously for the indicated format via the provided asynchronous writer.

Implementations on Foreign Types

impl AsyncSerialize for [u8]

type Future = <F as FormatSerialize>::SerializeByteSlice

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <[u8] as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for ()

type Future = <F as FormatSerialize>::SerializeUnit

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <() as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for i16

type Future = <F as FormatSerialize>::SerializeI16

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <i16 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for Box<T, Global> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, Box<T, Global>, <Box<T, Global> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Box<T, Global> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for u32

type Future = <F as FormatSerialize>::SerializeU32

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <u32 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T> AsyncSerialize for BTreeSet<T> where
    T: Encodable + Ord, 

type Future = SerializeAll<'w, F, W, BTreeSet<T>, <BTreeSet<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <BTreeSet<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

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

type Future = SerializeAll<'w, F, W, BTreeMap<K, V>, <BTreeMap<K, V> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <BTreeMap<K, V> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for String

type Future = <F as FormatSerialize>::SerializeString

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <String as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for f32

type Future = <F as FormatSerialize>::SerializeF32

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <f32 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for u16

type Future = <F as FormatSerialize>::SerializeU16

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <u16 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T> AsyncSerialize for Vec<T, Global> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, Vec<T, Global>, <Vec<T, Global> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Vec<T, Global> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for i32

type Future = <F as FormatSerialize>::SerializeI32

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <i32 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

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

type Future = SerializeAll<'w, F, W, Option<T>, <Option<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Option<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for Cell<T> where
    T: Encodable + Copy, 

type Future = SerializeAll<'w, F, W, Cell<T>, <Cell<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Cell<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for i128

type Future = <F as FormatSerialize>::SerializeI128

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <i128 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for bool

type Future = <F as FormatSerialize>::SerializeBool

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <bool as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for i64

type Future = <F as FormatSerialize>::SerializeI64

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <i64 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for i8

type Future = <F as FormatSerialize>::SerializeI8

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <i8 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

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

type Future = SerializeAll<'w, F, W, [T; L], <[T; L] as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <[T; L] as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for u8

type Future = <F as FormatSerialize>::SerializeU8

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <u8 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for PhantomData<T> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, PhantomData<T>, <PhantomData<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <PhantomData<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for Arc<T> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, Arc<T>, <Arc<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Arc<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T> AsyncSerialize for LinkedList<T> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, LinkedList<T>, <LinkedList<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <LinkedList<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

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

type Future = SerializeAll<'w, F, W, Result<O, E>, <Result<O, E> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Result<O, E> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for Rc<T> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, Rc<T>, <Rc<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <Rc<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for char

type Future = <F as FormatSerialize>::SerializeChar

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <char as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for u64

type Future = <F as FormatSerialize>::SerializeU64

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <u64 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for u128

type Future = <F as FormatSerialize>::SerializeU128

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <u128 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<'t, T> AsyncSerialize for RefCell<T> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, RefCell<T>, <RefCell<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <RefCell<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for f64

type Future = <F as FormatSerialize>::SerializeF64

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <f64 as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T> AsyncSerialize for BinaryHeap<T> where
    T: Encodable + Ord, 

type Future = SerializeAll<'w, F, W, BinaryHeap<T>, <BinaryHeap<T> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <BinaryHeap<T> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

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

type Future = SerializeAll<'w, F, W, HashMap<K, V, S>, <HashMap<K, V, S> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <HashMap<K, V, S> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T> AsyncSerialize for VecDeque<T, Global> where
    T: Encodable, 

type Future = SerializeAll<'w, F, W, VecDeque<T, Global>, <VecDeque<T, Global> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <VecDeque<T, Global> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl AsyncSerialize for str

type Future = <F as FormatSerialize>::SerializeStr

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <str as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

impl<T, S> AsyncSerialize for HashSet<T, S> where
    T: Encodable + Eq + Hash,
    S: BuildHasher + Default, 

type Future = SerializeAll<'w, F, W, HashSet<T, S>, <HashSet<T, S> as Encodable>::Encoder>

pub fn serialize<F, W>(
    &'w self,
    format: &'w F,
    writer: &'w mut W
) -> <HashSet<T, S> as AsyncSerialize>::Future where
    F: FormatSerialize,
    W: AsyncWrite + Unpin, 

Implementors

impl AsyncSerialize for SequenceLen

type Future = <F as FormatSerialize>::SerializeSequenceLen

impl AsyncSerialize for VariantIdx

type Future = <F as FormatSerialize>::SerializeVariantIdx