Trait Deferred 

pub trait Deferred<T> {
    // Required method
    fn take_deferred(&mut self) -> Option<DeferredFn<T>>;
}

Handles async processing state for codecs

Required Methods

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

Takes a deferred async processing operation, if any

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<O, E, W> Deferred<W> for ResultDecoder<O, E>

where O: Deferred<W> + Default, E: Deferred<W> + Default,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<O, E, W> Deferred<W> for ResultEncoder<O, E>

where O: Deferred<W>, E: Deferred<W>,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<T, W> Deferred<W> for OptionDecoder<T>

where T: Deferred<W> + Default,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<T, W> Deferred<W> for OptionEncoder<T>

where T: Deferred<W>,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<T: ?Sized> Deferred<BufferedIncoming> for CoreVecDecoder<ResourceBorrowDecoder<T>>

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<T: ?Sized> Deferred<BufferedIncoming> for CoreVecDecoder<ResourceOwnDecoder<T>>

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<T> Deferred<T> for BoolCodec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreNameDecoder

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreNameEncoder

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<BoolCodec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<CanonicalNanF32Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<CanonicalNanF64Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<CoreNameDecoder>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<CoreVecDecoderBytes>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<F32Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<F64Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderI8>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderI16>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderI32>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderI64>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderI128>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderU8>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderU16>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderU32>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderU64>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Leb128DecoderU128>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<S8Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<S16Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<S32Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<S64Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<U8Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<U16Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<U32Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<U64Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<UnitCodec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoder<Utf8Codec>

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecDecoderBytes

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for CoreVecEncoderBytes

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for F32Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for F64Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderI8

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderI16

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderI32

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderI64

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderI128

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderU8

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderU16

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderU32

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderU64

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128DecoderU128

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Leb128Encoder

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for PrimValEncoder

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for S8Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for S16Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for S32Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for S64Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for U8Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for U16Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for U32Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for U64Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<T> Deferred<T> for Utf8Codec

fn take_deferred(&mut self) -> Option<DeferredFn<T>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder, V11::Decoder, V12::Decoder, V13::Decoder, V14::Decoder, V15::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>, Option<V11>, Option<V12>, Option<V13>, Option<V14>, Option<V15>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode, V11: Decode, V12: Decode, V13: Decode, V14: Decode, V15: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder, V11::Decoder, V12::Decoder, V13::Decoder, V14::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>, Option<V11>, Option<V12>, Option<V13>, Option<V14>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode, V11: Decode, V12: Decode, V13: Decode, V14: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder, V11::Decoder, V12::Decoder, V13::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>, Option<V11>, Option<V12>, Option<V13>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode, V11: Decode, V12: Decode, V13: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder, V11::Decoder, V12::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>, Option<V11>, Option<V12>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode, V11: Decode, V12: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder, V11::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>, Option<V11>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode, V11: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder, V10::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>, Option<V10>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode, V10: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8, V9> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder, V9::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>, Option<V9>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode, V9: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7, V8> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder, V8::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>, Option<V8>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode, V8: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6, V7> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder, V7::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>, Option<V7>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode, V7: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5, V6> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder, V6::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>, Option<V6>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode, V6: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4, V5> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder, V5::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>, Option<V5>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode, V5: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3, V4> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder, V4::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>, Option<V4>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode, V4: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2, V3> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder, V3::Decoder), (Option<V0>, Option<V1>, Option<V2>, Option<V3>)>

where V0: Decode, V1: Decode, V2: Decode, V3: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1, V2> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder, V2::Decoder), (Option<V0>, Option<V1>, Option<V2>)>

where V0: Decode, V1: Decode, V2: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0, V1> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder, V1::Decoder), (Option<V0>, Option<V1>)>

where V0: Decode, V1: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<V0> Deferred<BufferedIncoming> for TupleDecoder<(V0::Decoder,), (Option<V0>,)>

where V0: Decode,

fn take_deferred(&mut self) -> Option<DeferredFn<BufferedIncoming>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static, C11: Deferred<W> + Default + 'static, C12: Deferred<W> + Default + 'static, C13: Deferred<W> + Default + 'static, C14: Deferred<W> + Default + 'static, C15: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static, C11: Deferred<W> + Default + 'static, C12: Deferred<W> + Default + 'static, C13: Deferred<W> + Default + 'static, C14: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static, C11: Deferred<W> + Default + 'static, C12: Deferred<W> + Default + 'static, C13: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static, C11: Deferred<W> + Default + 'static, C12: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static, C11: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static, C10: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static, C9: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7, C8> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static, C8: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6, C7> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static, C7: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5, C6> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static, C6: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4, C5> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static, C5: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3, C4> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static, C4: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2, C3> Deferred<W> for TupleEncoder<(C0, C1, C2, C3)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static, C3: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1, C2> Deferred<W> for TupleEncoder<(C0, C1, C2)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static, C2: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0, C1> Deferred<W> for TupleEncoder<(C0, C1)>

where C0: Deferred<W> + Default + 'static, C1: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

impl<W: Sink, C0> Deferred<W> for TupleEncoder<(C0,)>

where C0: Deferred<W> + Default + 'static,

fn take_deferred(&mut self) -> Option<DeferredFn<W>>

Implementors

impl Deferred<BufferedIncoming> for StreamDecoderBytes

impl Deferred<BufferedIncoming> for StreamDecoderRead

impl<T, C> Deferred<T> for SyncCodec<C>

impl<T: ?Sized> Deferred<BufferedIncoming> for ResourceBorrowDecoder<T>

impl<T: ?Sized> Deferred<BufferedIncoming> for ResourceOwnDecoder<T>

impl<T> Deferred<BufferedIncoming> for FutureDecoder<T>

where T: Decode,

impl<T> Deferred<BufferedIncoming> for ListDecoder<T>

where T: Decoder,

impl<T> Deferred<BufferedIncoming> for StreamDecoder<T>

where T: Decode,

impl<T> Deferred<T> for CanonicalNanF32Codec

impl<T> Deferred<T> for CanonicalNanF64Codec

impl<T> Deferred<T> for ListDecoderU8

impl<T> Deferred<T> for ResourceEncoder

impl<T> Deferred<T> for UnitCodec

impl<W, const MAX_READY: usize> Deferred<W> for StreamEncoderRead<W, MAX_READY>

impl<W> Deferred<W> for FutureEncoder<W>

impl<W> Deferred<W> for ListEncoder<W>

impl<W> Deferred<W> for StreamEncoder<W>

impl<W> Deferred<W> for StreamEncoderBytes<W>