Trait Encode 

pub trait Encode<W: Sink = Outgoing>: Sized {
    type Encoder: Encoder<Self> + Deferred<W> + Default + Send;

    // Provided methods
    fn encode(
        self,
        enc: &mut Self::Encoder,
        dst: &mut BytesMut,
    ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error> { ... }
    fn encode_iter_own<I>(
        items: I,
        enc: &mut Self::Encoder,
        dst: &mut BytesMut,
    ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>
       where I: IntoIterator<Item = Self>,
             I::IntoIter: ExactSizeIterator { ... }
    fn encode_iter_ref<'a, I>(
        items: I,
        enc: &mut Self::Encoder,
        dst: &mut BytesMut,
    ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>
       where I: IntoIterator<Item = &'a Self>,
             I::IntoIter: ExactSizeIterator,
             Self::Encoder: Encoder<&'a Self> { ... }
    fn encode_list_own(
        items: Vec<Self>,
        enc: &mut Self::Encoder,
        dst: &mut BytesMut,
    ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error> { ... }
    fn encode_list_ref<'a>(
        items: &'a [Self],
        enc: &mut Self::Encoder,
        dst: &mut BytesMut,
    ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>
       where Self::Encoder: Encoder<&'a Self> { ... }
}

Defines value encoding

Required Associated Types

type Encoder: Encoder<Self> + Deferred<W> + Default + Send

Encoder used to encode the value

Provided Methods

fn encode( self, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

Convenience function for encoding a value

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

Encode an iterator of owned values

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, Self::Encoder: Encoder<&'a Self>,

Encode an iterator of value references

fn encode_list_own( items: Vec<Self>, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

Encode a list of owned values

fn encode_list_ref<'a>( items: &'a [Self], enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where Self::Encoder: Encoder<&'a Self>,

Encode a list of value references

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<&'a V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<&'a V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<&'a V13, Error = E> + 'static, V14: Encode<W>, V14::Encoder: Encoder<&'a V14, Error = E> + 'static, V15: Encode<W>, V15::Encoder: Encoder<&'a V15, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder, <V14 as Encode<W>>::Encoder, <V15 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<&'a V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<&'a V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<&'a V13, Error = E> + 'static, V14: Encode<W>, V14::Encoder: Encoder<&'a V14, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder, <V14 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<&'a V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<&'a V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<&'a V13, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<&'a V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<&'a V12, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<&'a V11, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<&'a V10, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<&'a V9, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<&'a V8, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<&'a V7, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5, V6> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<&'a V6, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4, V5> Encode<W> for &'a (V0, V1, V2, V3, V4, V5)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<&'a V5, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3, V4> Encode<W> for &'a (V0, V1, V2, V3, V4)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<&'a V4, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2, V3> Encode<W> for &'a (V0, V1, V2, V3)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<&'a V3, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1, V2> Encode<W> for &'a (V0, V1, V2)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<&'a V2, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0, V1> Encode<W> for &'a (V0, V1)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<&'a V1, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder)>

impl<'a, E, W: Sink, V0> Encode<W> for &'a (V0,)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<&'a V0, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder,)>

impl<'a, O, E, W: Sink> Encode<W> for &'a Result<O, E>

where O: Encode<W>, O::Encoder: Encoder<&'a O>, E: Encode<W>, E::Encoder: Encoder<&'a E>, Error: From<<O::Encoder as Encoder<&'a O>>::Error> + From<<E::Encoder as Encoder<&'a E>>::Error>,

type Encoder = ResultEncoder<<O as Encode<W>>::Encoder, <E as Encode<W>>::Encoder>

impl<'a, T, W: Sink> Encode<W> for &'a Option<T>

where T: Encode<W>, T::Encoder: Encoder<&'a T>,

type Encoder = OptionEncoder<<T as Encode<W>>::Encoder>

impl<'a, T, W: Sink> Encode<W> for &'a Vec<T>

where T: Encode<W>, T::Encoder: Encoder<&'a T>,

type Encoder = ListEncoder<W>

impl<'a, T, W: Sink> Encode<W> for &'a [T]

where T: Encode<W>, T::Encoder: Encoder<&'a T>,

type Encoder = ListEncoder<W>

impl<'b, W: Sink> Encode<W> for &'b bool

type Encoder = BoolCodec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b char

type Encoder = Utf8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b f32

type Encoder = CanonicalNanF32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b f64

type Encoder = CanonicalNanF64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b i8

type Encoder = S8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b i16

type Encoder = S16Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b i32

type Encoder = S32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b i64

type Encoder = S64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b u8

type Encoder = U8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b u16

type Encoder = U16Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b u32

type Encoder = U32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<'b, W: Sink> Encode<W> for &'b u64

type Encoder = U64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, 'b: 'a,

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<V13, Error = E> + 'static, V14: Encode<W>, V14::Encoder: Encoder<V14, Error = E> + 'static, V15: Encode<W>, V15::Encoder: Encoder<V15, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder, <V14 as Encode<W>>::Encoder, <V15 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<V13, Error = E> + 'static, V14: Encode<W>, V14::Encoder: Encoder<V14, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder, <V14 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<V12, Error = E> + 'static, V13: Encode<W>, V13::Encoder: Encoder<V13, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder, <V13 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<V11, Error = E> + 'static, V12: Encode<W>, V12::Encoder: Encoder<V12, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder, <V12 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static, V11: Encode<W>, V11::Encoder: Encoder<V11, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder, <V11 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static, V10: Encode<W>, V10::Encoder: Encoder<V10, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder, <V10 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static, V9: Encode<W>, V9::Encoder: Encoder<V9, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder, <V9 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7, V8> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static, V8: Encode<W>, V8::Encoder: Encoder<V8, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder, <V8 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6, V7> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static, V7: Encode<W>, V7::Encoder: Encoder<V7, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder, <V7 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5, V6> Encode<W> for (V0, V1, V2, V3, V4, V5, V6)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static, V6: Encode<W>, V6::Encoder: Encoder<V6, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder, <V6 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4, V5> Encode<W> for (V0, V1, V2, V3, V4, V5)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static, V5: Encode<W>, V5::Encoder: Encoder<V5, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder, <V5 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3, V4> Encode<W> for (V0, V1, V2, V3, V4)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static, V4: Encode<W>, V4::Encoder: Encoder<V4, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder, <V4 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2, V3> Encode<W> for (V0, V1, V2, V3)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static, V3: Encode<W>, V3::Encoder: Encoder<V3, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder, <V3 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1, V2> Encode<W> for (V0, V1, V2)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static, V2: Encode<W>, V2::Encoder: Encoder<V2, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder, <V2 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0, V1> Encode<W> for (V0, V1)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static, V1: Encode<W>, V1::Encoder: Encoder<V1, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder, <V1 as Encode<W>>::Encoder)>

impl<E, W: Sink, V0> Encode<W> for (V0,)

where E: From<Error>, V0: Encode<W>, V0::Encoder: Encoder<V0, Error = E> + 'static,

type Encoder = TupleEncoder<(<V0 as Encode<W>>::Encoder,)>

impl<O, E, W: Sink> Encode<W> for Result<O, E>

where O: Encode<W>, E: Encode<W>, Error: From<<O::Encoder as Encoder<O>>::Error> + From<<E::Encoder as Encoder<E>>::Error>,

type Encoder = ResultEncoder<<O as Encode<W>>::Encoder, <E as Encode<W>>::Encoder>

impl<T, W: Sink> Encode<W> for Cursor<T>

where T: AsRef<[u8]> + Send + Unpin + 'static,

type Encoder = StreamEncoderRead<W>

impl<T, W: Sink> Encode<W> for Option<T>

where T: Encode<W>,

type Encoder = OptionEncoder<<T as Encode<W>>::Encoder>

impl<T, W: Sink> Encode<W> for Pin<Box<dyn Future<Output = T> + Send>>

where T: Encode<W> + 'static, Error: From<<T::Encoder as Encoder<T>>::Error>,

type Encoder = FutureEncoder<W>

impl<T, W: Sink> Encode<W> for Pin<Box<dyn Stream<Item = Vec<T>> + Send>>

where T: Encode<W> + Send + 'static, Error: From<<T::Encoder as Encoder<T>>::Error>,

type Encoder = StreamEncoder<W>

impl<T, W: Sink> Encode<W> for Vec<T>

where T: Encode<W>,

type Encoder = ListEncoder<W>

impl<W: Sink> Encode<W> for &&str

type Encoder = CoreNameEncoder

impl<W: Sink> Encode<W> for &Bytes

type Encoder = CoreVecEncoderBytes

impl<W: Sink> Encode<W> for &String

type Encoder = CoreNameEncoder

impl<W: Sink> Encode<W> for &str

type Encoder = CoreNameEncoder

impl<W: Sink> Encode<W> for ()

type Encoder = UnitCodec

impl<W: Sink> Encode<W> for Bytes

type Encoder = CoreVecEncoderBytes

impl<W: Sink> Encode<W> for Empty

type Encoder = StreamEncoderRead<W>

impl<W: Sink> Encode<W> for Pin<Box<dyn AsyncRead + Send>>

type Encoder = StreamEncoderRead<W>

impl<W: Sink> Encode<W> for Pin<Box<dyn Stream<Item = Bytes> + Send>>

type Encoder = StreamEncoderBytes<W>

impl<W: Sink> Encode<W> for Receiver

Available on Unix and crate feature net only.

type Encoder = StreamEncoderRead<W>

impl<W: Sink> Encode<W> for String

type Encoder = CoreNameEncoder

impl<W: Sink> Encode<W> for TcpStream

Available on crate feature net only.

type Encoder = StreamEncoderRead<W>

impl<W: Sink> Encode<W> for UnixStream

Available on Unix and crate feature net only.

type Encoder = StreamEncoderRead<W>

impl<W: Sink> Encode<W> for bool

type Encoder = BoolCodec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for char

type Encoder = Utf8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for f32

type Encoder = CanonicalNanF32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for f64

type Encoder = CanonicalNanF64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for i8

type Encoder = S8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for i16

type Encoder = S16Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for i32

type Encoder = S32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for i64

type Encoder = S64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for u8

type Encoder = U8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

fn encode_list_own( items: Vec<Self>, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

fn encode_list_ref<'a>( items: &'a [Self], enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where Self::Encoder: Encoder<&'a Self>,

impl<W: Sink> Encode<W> for u16

type Encoder = U16Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for u32

type Encoder = U32Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

impl<W: Sink> Encode<W> for u64

type Encoder = U64Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator,

fn encode_iter_ref<'a, I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<W>>, <Self::Encoder as Encoder<&'a Self>>::Error>

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator,

Implementors

impl<T: ?Sized, W: Sink> Encode<W> for &ResourceBorrow<T>

type Encoder = ResourceEncoder

impl<T: ?Sized, W: Sink> Encode<W> for &ResourceOwn<T>

type Encoder = ResourceEncoder

impl<T: ?Sized, W: Sink> Encode<W> for ResourceBorrow<T>

type Encoder = ResourceEncoder

impl<T: ?Sized, W: Sink> Encode<W> for ResourceOwn<T>

type Encoder = ResourceEncoder