Trait wrpc_transport::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

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<R, T: ?Sized> Deferred<Incoming<R>> for CoreVecDecoder<ResourceBorrowDecoder<T>>

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

impl<R, T: ?Sized> Deferred<Incoming<R>> for CoreVecDecoder<ResourceOwnDecoder<T>>

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

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

where R: Index<R> + Send + Sync + 'static, V0: Decode<R>,

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

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

where R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>,

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

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

where R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>,

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

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

where R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>,

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

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

where R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>, V11: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>, V11: Decode<R>, V12: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>, V11: Decode<R>, V12: Decode<R>, V13: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>, V11: Decode<R>, V12: Decode<R>, V13: Decode<R>, V14: Decode<R>,

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

impl<R, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> Deferred<Incoming<R>> 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 R: Index<R> + Send + Sync + 'static, V0: Decode<R>, V1: Decode<R>, V2: Decode<R>, V3: Decode<R>, V4: Decode<R>, V5: Decode<R>, V6: Decode<R>, V7: Decode<R>, V8: Decode<R>, V9: Decode<R>, V10: Decode<R>, V11: Decode<R>, V12: Decode<R>, V13: Decode<R>, V14: Decode<R>, V15: Decode<R>,

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

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 Utf8Codec

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

impl<T> Deferred<T> for BoolCodec

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 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 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<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<Utf8Codec>

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<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<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<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<UnitCodec>

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, 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<W, C0> Deferred<W> for TupleEncoder<(C0,)>

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

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

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

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

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

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

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3> Deferred<W> for TupleEncoder<(C0, C1, C2, C3)>

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3, C4> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4)>

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3, C4, C5> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5)>

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3, C4, C5, C6> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6)>

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3, C4, C5, C6, C7> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7)>

where W: Index<W> + Send + Sync + 'static, 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, C0, C1, C2, C3, C4, C5, C6, C7, C8> Deferred<W> for TupleEncoder<(C0, C1, C2, C3, C4, C5, C6, C7, C8)>

where W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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, 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 W: Index<W> + Send + Sync + 'static, 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>>

Implementors

impl<R> Deferred<Incoming<R>> for StreamDecoderBytes<R>

impl<R> Deferred<Incoming<R>> for StreamDecoderRead<R>

impl<R, T: ?Sized> Deferred<Incoming<R>> for ResourceBorrowDecoder<T>

impl<R, T: ?Sized> Deferred<Incoming<R>> for ResourceOwnDecoder<T>

impl<T> Deferred<T> for ListDecoderU8

impl<T> Deferred<T> for ResourceEncoder

impl<T> Deferred<T> for UnitCodec

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

impl<T, R> Deferred<Incoming<R>> for FutureDecoder<T, R>

where T: Decode<R>,

impl<T, R> Deferred<Incoming<R>> for ListDecoder<T, R>

where T: Decoder, R: Index<R> + Send + Sync + 'static,

impl<T, R> Deferred<Incoming<R>> for StreamDecoder<T, R>

where T: Decode<R>,

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>

impl<W> Deferred<W> for StreamEncoderRead<W>