Trait Encode 

pub trait Encode {
    // Required methods
    fn size(&self) -> usize;
    fn encode_to<'life0, 'life1, 'async_trait, W>(
        &'life0 self,
        config: &'life1 Config,
        writer: W,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where W: Write + Unpin + Send + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

Trait for encoding values

Required Methods

fn size(&self) -> usize

Returns size of encoded byte array

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Writes encoded byte array to writer and returns the number of bytes written

Equivalent to:

async fn encode_to<W>(&self, writer: W) -> Result<usize>
where
    W: Write + Unpin + Send

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 bool

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for char

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for f32

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for f64

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for i8

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for i16

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for i32

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for i64

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for i128

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for isize

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for str

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for u8

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for u16

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for u32

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for u64

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for u128

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for ()

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, _config: &'life1 Config, _writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for usize

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for CString

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for String

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for CStr

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroI8

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroI16

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroI32

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroI64

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroI128

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroIsize

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroU8

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroU16

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroU32

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroU64

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroU128

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Encode for NonZeroUsize

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<K, V> Encode for BTreeMap<K, V>

where K: Encode + Sync + 'static, V: Encode + Sync + 'static,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<K, V, S> Encode for HashMap<K, V, S>

where K: Encode + Sync, V: Encode + Sync, S: BuildHasher + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T0> Encode for (T0,)

where T0: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where T0: Encode + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

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

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

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

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync, T11: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync, T11: Encode + Send + Sync, T12: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync, T11: Encode + Send + Sync, T12: Encode + Send + Sync, T13: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync, T11: Encode + Send + Sync, T12: Encode + Send + Sync, T13: Encode + Send + Sync, T14: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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 + Send + Sync, T1: Encode + Send + Sync, T2: Encode + Send + Sync, T3: Encode + Send + Sync, T4: Encode + Send + Sync, T5: Encode + Send + Sync, T6: Encode + Send + Sync, T7: Encode + Send + Sync, T8: Encode + Send + Sync, T9: Encode + Send + Sync, T10: Encode + Send + Sync, T11: Encode + Send + Sync, T12: Encode + Send + Sync, T13: Encode + Send + Sync, T14: Encode + Send + Sync, T15: Encode + Send + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for Cow<'_, T>

where T: Encode + ToOwned + Sync + ?Sized, <T as ToOwned>::Owned: Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for Option<T>

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 1]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 2]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 3]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 4]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 5]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 6]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 7]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 8]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 9]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 10]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 11]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 12]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 13]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 14]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 15]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 16]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 17]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 18]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 19]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 20]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 21]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 22]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 23]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 24]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 25]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 26]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 27]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 28]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 29]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 30]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 31]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 32]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 33]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 34]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 35]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 36]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 37]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 38]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 39]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 40]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 41]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 42]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 43]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 44]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 45]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 46]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 47]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 48]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 49]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 50]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 51]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 52]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 53]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 54]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 55]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 56]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 57]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 58]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 59]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 60]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 61]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 62]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 63]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 64]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 128]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 256]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 512]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T; 1024]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for &T

where T: Encode + Sync + ?Sized,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for &mut T

where T: Encode + Sync + ?Sized,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for [T]

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for Box<T>

where T: Encode + Sync + ?Sized,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for BinaryHeap<T>

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for BTreeSet<T>

where T: Encode + Sync + 'static,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for LinkedList<T>

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for VecDeque<T>

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for Arc<T>

where T: Encode + Sync + Send + ?Sized,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for Vec<T>

where T: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Encode for PhantomData<T>

where T: Send + Sync + ?Sized,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, _config: &'life1 Config, _writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Encode for Result<T, E>

where T: Encode + Sync, E: Encode + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, S> Encode for HashSet<T, S>

where T: Encode + Sync, S: BuildHasher + Sync,

fn size(&self) -> usize

fn encode_to<'life0, 'life1, 'async_trait, W>( &'life0 self, config: &'life1 Config, writer: W, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where W: Write + Unpin + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Implementors