Trait Encode 

pub trait Encode<T>: Sized {
    type Encoder: Encoder<Self> + Deferred<T> + Default + Send;

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

Defines value encoding

Required Associated Types

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

Encoder used to encode the value

Provided Methods

fn encode( self, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<T>>, <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<T>>, <Self::Encoder as Encoder<Self>>::Error>

where I: IntoIterator<Item = Self>, I::IntoIter: ExactSizeIterator, T: Index<T> + Send + Sync + 'static,

Encode an iterator of owned values

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

where I: IntoIterator<Item = &'a Self>, I::IntoIter: ExactSizeIterator, T: Index<T> + Send + Sync + 'static, 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<T>>, <Self::Encoder as Encoder<Self>>::Error>

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

Encode a list of owned values

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

where T: Index<T> + Send + Sync + 'static, 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", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, O, E, W> 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> 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> Encode<W> for &'a [T]

where T: Encode<W>, T::Encoder: Encoder<&'a T>, W: Index<W> + Send + Sync + 'static,

type Encoder = ListEncoder<W>

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

where T: Encode<W>, T::Encoder: Encoder<&'a T>, W: Index<W> + Send + Sync + 'static,

type Encoder = ListEncoder<W>

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

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

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

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

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2> Encode<W> for &'a (V0, V1, V2)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3> Encode<W> for &'a (V0, V1, V2, V3)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3, V4> Encode<W> for &'a (V0, V1, V2, V3, V4)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3, V4, V5> Encode<W> for &'a (V0, V1, V2, V3, V4, V5)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3, V4, V5, V6> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3, V4, V5, V6, V7> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7)

where W: Index<W> + Send + Sync + 'static, 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, W, E, V0, V1, V2, V3, V4, V5, V6, V7, V8> Encode<W> for &'a (V0, V1, V2, V3, V4, V5, V6, V7, V8)

where W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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, W, E, 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 W: Index<W> + Send + Sync + 'static, 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<'b, T> Encode<T> for &'b u8

type Encoder = U8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<T>>, <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<T>>, <Self::Encoder as Encoder<&'a Self>>::Error>

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

impl<'b, W> 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> 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> Encode<W> for &'b f32

type Encoder = F32Codec

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> Encode<W> for &'b f64

type Encoder = F64Codec

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> 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> 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> 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> 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> 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> 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> 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<O, E, W> 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> Encode<T> for u8

type Encoder = U8Codec

fn encode_iter_own<I>( items: I, enc: &mut Self::Encoder, dst: &mut BytesMut, ) -> Result<Option<DeferredFn<T>>, <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<T>>, <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<T>>, <Self::Encoder as Encoder<Self>>::Error>

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

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

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

where T: Encode<W>,

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

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

where T: Encode<W>, W: Index<W> + Send + Sync + 'static,

type Encoder = ListEncoder<W>

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

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

type Encoder = FutureEncoder<W>

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

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

type Encoder = StreamEncoder<W>

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

where T: AsRef<[u8]> + Send + Unpin + 'static, W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

type Encoder = StreamEncoderRead<W>

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

type Encoder = CoreNameEncoder

impl<W> Encode<W> for &str

type Encoder = CoreNameEncoder

impl<W> Encode<W> for &String

type Encoder = CoreNameEncoder

impl<W> Encode<W> for &Bytes

type Encoder = CoreVecEncoderBytes

impl<W> 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> 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> Encode<W> for f32

type Encoder = F32Codec

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> Encode<W> for f64

type Encoder = F64Codec

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

impl<W> Encode<W> for ()

type Encoder = UnitCodec

impl<W> Encode<W> for String

type Encoder = CoreNameEncoder

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

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

type Encoder = StreamEncoderBytes<W>

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

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for Bytes

type Encoder = CoreVecEncoderBytes

impl<W> Encode<W> for File

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

Available on crate feature fs only.

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for Stdin

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

Available on crate feature io-std only.

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for Empty

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for TcpStream

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

Available on crate feature net only.

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for Receiver

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

Available on Unix and crate feature net only.

type Encoder = StreamEncoderRead<W>

impl<W> Encode<W> for UnixStream

where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

Available on Unix and crate feature net only.

type Encoder = StreamEncoderRead<W>

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

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

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

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

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2> Encode<W> for (V0, V1, V2)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3> Encode<W> for (V0, V1, V2, V3)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4> Encode<W> for (V0, V1, V2, V3, V4)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4, V5> Encode<W> for (V0, V1, V2, V3, V4, V5)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4, V5, V6> Encode<W> for (V0, V1, V2, V3, V4, V5, V6)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4, V5, V6, V7> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4, V5, V6, V7, V8> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8)

where W: Index<W> + Send + Sync + 'static, 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<W, E, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9> Encode<W> for (V0, V1, V2, V3, V4, V5, V6, V7, V8, V9)

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

Implementors

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

type Encoder = ResourceEncoder

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

type Encoder = ResourceEncoder

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

type Encoder = ResourceEncoder

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

type Encoder = ResourceEncoder