Trait Encode 

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

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

Required Methods

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

encode by references

fn bytes_count(&self) -> usize

be careful to calculate the number of bytes

Provided Methods

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

where 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: Encoder>( &self, buf: &mut BytesMut, _encoder: &mut A, ) -> Result<(), A::Error>

fn bytes_count(&self) -> usize

impl Encode for bool

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for f32

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for f64

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for i8

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for i16

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for i32

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for i64

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for i128

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for u8

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for u16

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for u32

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for u64

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for u128

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

where Self: Sized,

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

fn bytes_count(&self) -> usize

impl Encode for ()

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl Encode for Bytes

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

fn bytes_count(&self) -> usize

impl<T0> Encode for (T0,)

where T0: Encode,

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

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

where T0: Encode, T1: Encode,

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

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: 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: Encoder>( self, buf: &mut BytesMut, encoder: &mut A, ) -> Result<(), A::Error>

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl<T> Encode for SmallVec<T>

where T: Array, T::Item: Encode,

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for Option<T>

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for &T

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for Rc<T>

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

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for Arc<T>

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

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for Vec<T>

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

impl<T: Encode> Encode for PhantomData<T>

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

where Self: Sized,

fn bytes_count(&self) -> usize

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

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

where Self: Sized,

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

where Self: Sized,

fn bytes_count(&self) -> usize

Implementors

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

where T: Encode,

impl<T: Encode> Encode for CommonPacket<T>

impl<T: Encode> Encode for CommonPacketItem<T>