Trait Encode

pub trait Encode {
    // Required methods
    fn encode_by_ref<A>(
        &self,
        buf: &mut BytesMut,
        encoder: &mut A,
    ) -> Result<(), <A as Encoder>::Error>
       where A: Encoder;
    fn bytes_count(&self) -> usize;

    // Provided method
    fn encode<A>(
        self,
        buf: &mut BytesMut,
        encoder: &mut A,
    ) -> Result<(), <A as Encoder>::Error>
       where A: Encoder,
             Self: Sized { ... }
}

Required Methods

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

encode by references

fn bytes_count(&self) -> usize

be careful to calculate the number of bytes

Provided Methods

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, Self: Sized,

encode by moved values

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Encode for &[u8]

fn encode_by_ref<A>( &self, buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for bool

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, bool: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for f32

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, f32: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for f64

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, f64: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for i8

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, i8: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for i16

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, i16: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for i32

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, i32: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for i64

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, i64: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for i128

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, i128: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for u8

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, u8: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for u16

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, u16: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for u32

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, u32: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for u64

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, u64: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for u128

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, u128: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for ()

fn encode_by_ref<A>( &self, _buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (): Sized,

fn bytes_count(&self) -> usize

impl Encode for Bytes

fn encode_by_ref<A>( &self, buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for SocketAddr

fn encode_by_ref<A>( &self, buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl Encode for EncapsulationHeader

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, EncapsulationHeader: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<P> Encode for ForwardCloseRequest<P>

where P: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<P, D> Encode for MessageRequest<P, D>

where P: Encode, D: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, MessageRequest<P, D>: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<T0> Encode for (T0,)

where T0: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0,): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0,): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1> Encode for (T0, T1)

where T0: Encode, T1: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2> Encode for (T0, T1, T2)

where T0: Encode, T1: Encode, T2: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3> Encode for (T0, T1, T2, T3)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4> Encode for (T0, T1, T2, T3, T4)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5> Encode for (T0, T1, T2, T3, T4, T5)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6> Encode for (T0, T1, T2, T3, T4, T5, T6)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7> Encode for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode, T11: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode, T11: Encode, T12: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode, T11: Encode, T12: Encode, T13: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode, T11: Encode, T12: Encode, T13: Encode, T14: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14): Sized,

fn bytes_count(&self) -> usize

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: Encode, T1: Encode, T2: Encode, T3: Encode, T4: Encode, T5: Encode, T6: Encode, T7: Encode, T8: Encode, T9: Encode, T10: Encode, T11: Encode, T12: Encode, T13: Encode, T14: Encode, T15: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15): Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15): Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for Option<T>

where T: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, Option<T>: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, Option<T>: Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for &T

where T: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, &T: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, &T: Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for Rc<T>

where T: Encode,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<T> Encode for Arc<T>

where T: Encode,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<T> Encode for Vec<T>

where T: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, Vec<T>: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, Vec<T>: Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for PhantomData<T>

where T: Encode,

fn encode_by_ref<A>( &self, _buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, PhantomData<T>: Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for EncapsulationPacket<T>

where T: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, EncapsulationPacket<T>: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder,

fn bytes_count(&self) -> usize

impl<T> Encode for SmallVec<T>

where T: Array, <T as Array>::Item: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, SmallVec<T>: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, SmallVec<T>: Sized,

fn bytes_count(&self) -> usize

impl<T, const N: usize> Encode for [T; N]

where T: Encode,

fn encode<A>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, [T; N]: Sized,

fn encode_by_ref<A>( &self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), <A as Encoder>::Error>

where A: Encoder, [T; N]: Sized,

fn bytes_count(&self) -> usize

Implementors

impl Encode for TagType

impl Encode for Segment

impl Encode for TagValue<bool>

impl Encode for TagValue<f32>

impl Encode for TagValue<f64>

impl Encode for TagValue<i8>

impl Encode for TagValue<i16>

impl Encode for TagValue<i32>

impl Encode for TagValue<i64>

impl Encode for TagValue<u8>

impl Encode for TagValue<u16>

impl Encode for TagValue<u32>

impl Encode for TagValue<u64>

impl Encode for EPath

impl Encode for PortSegment

impl<'a, T> Encode for SliceContainer<'a, T>

where T: Encode,

impl<CP, P, D> Encode for UnconnectedSend<CP, MessageRequest<P, D>>

where CP: Encode, P: Encode, D: Encode,

impl<P> Encode for OpenOptions<P>

where P: Encode,

impl<T> Encode for TagValue<&[T]>

where T: Encode,

impl<T> Encode for TagValue<Vec<T>>

where T: Encode,

impl<T> Encode for CommonPacket<T>

where T: Encode,

impl<T> Encode for CommonPacketItem<T>

where T: Encode,

impl<T, const N: usize> Encode for TagValue<[T; N]>

where T: Encode,