wrpc_transport

Trait 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

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§

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§

Source§

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

Source§

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

Source§

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

Source§

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

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

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

impl<W> Encode<W> for &DeleteResult

impl<W> Encode<W> for &DeployResult

impl<W> Encode<W> for &GetResult

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

impl<W> Encode<W> for &PutResult

impl<W> Encode<W> for &StatusResult

impl<W> Encode<W> for &StatusType

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<W> Encode<W> for DeleteResult

impl<W> Encode<W> for DeployResult

impl<W> Encode<W> for GetResult

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

impl<W> Encode<W> for PutResult

impl<W> Encode<W> for StatusResult

impl<W> Encode<W> for StatusType

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<W> Encode<W> for &&HeaderError

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

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

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

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

impl<W> Encode<W> for &HeaderError

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

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

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

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

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

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

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

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

impl<W> Encode<W> for HeaderError

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

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

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

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

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

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

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

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

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