Trait wrpc_transport::Encode

source ·
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> { ... }
}
Expand description

Defines value encoding

Required Associated Types§

source

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

Encoder used to encode the value

Provided Methods§

source

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

source

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

source

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

source

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

source

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

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

source§

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

source§

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

source§

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

source§

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,

source§

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,

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

impl<'b, T> Encode<T> for &'b u8

source§

type Encoder = U8Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = BoolCodec

source§

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,

source§

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,

source§

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

source§

type Encoder = Utf8Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = F32Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = F64Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = S8Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = S16Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = S32Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = S64Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = U16Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = U32Codec

source§

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,

source§

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,

source§

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

source§

type Encoder = U64Codec

source§

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,

source§

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,

source§

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

source§

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

source§

impl<T> Encode<T> for u8

source§

type Encoder = U8Codec

source§

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,

source§

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,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<W> Encode<W> for &str

source§

impl<W> Encode<W> for &Bytes

source§

impl<W> Encode<W> for &String

source§

impl<W> Encode<W> for bool

source§

type Encoder = BoolCodec

source§

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,

source§

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,

source§

impl<W> Encode<W> for char

source§

type Encoder = Utf8Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for f32

source§

type Encoder = F32Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for f64

source§

type Encoder = F64Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for i8

source§

type Encoder = S8Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for i16

source§

type Encoder = S16Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for i32

source§

type Encoder = S32Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for i64

source§

type Encoder = S64Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for u16

source§

type Encoder = U16Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for u32

source§

type Encoder = U32Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for u64

source§

type Encoder = U64Codec

source§

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,

source§

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,

source§

impl<W> Encode<W> for ()

source§

impl<W> Encode<W> for Bytes

source§

impl<W> Encode<W> for Empty
where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

source§

impl<W> Encode<W> for String

source§

impl<W> Encode<W> for Pin<Box<dyn Stream<Item = Bytes> + Send>>
where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

source§

impl<W> Encode<W> for Pin<Box<dyn AsyncRead + Send>>
where W: AsyncWrite + Index<W> + Send + Sync + Unpin + 'static,

source§

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,

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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

source§

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,

source§

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§