Trait EntriesEncoder 

pub trait EntriesEncoder {
    type Cx: Context<Error = Self::Error>;
    type Error;
    type Mode: 'static;
    type EncodeEntryKey<'this>: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>
       where Self: 'this;
    type EncodeEntryValue<'this>: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>
       where Self: 'this;

    // Required methods
    fn cx(&self) -> Self::Cx;
    fn encode_entry_key(
        &mut self,
    ) -> Result<Self::EncodeEntryKey<'_>, Self::Error>;
    fn encode_entry_value(
        &mut self,
    ) -> Result<Self::EncodeEntryValue<'_>, Self::Error>;
    fn finish_entries(self) -> Result<(), Self::Error>;

    // Provided method
    fn insert_entry<K, V>(
        &mut self,
        key: K,
        value: V,
    ) -> Result<(), Self::Error>
       where K: Encode<Self::Mode>,
             V: Encode<Self::Mode> { ... }
}

Trait governing how to encode a map entry.

This trait exists so that decoders can implement a mode that is compatible with serde serialization.

If you do not intend to implement this, then serde compatibility for your format might be degraded.

Required Associated Types

type Cx: Context<Error = Self::Error>

Context associated with the encoder.

type Error

Error associated with encoding.

type Mode: 'static

The mode of the encoder.

type EncodeEntryKey<'this>: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode> where Self: 'this

The encoder returned when advancing the map encoder to encode the key.

type EncodeEntryValue<'this>: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode> where Self: 'this

The encoder returned when advancing the map encoder to encode the value.

Required Methods

fn cx(&self) -> Self::Cx

Access the context associated with the encoder.

fn encode_entry_key(&mut self) -> Result<Self::EncodeEntryKey<'_>, Self::Error>

Return the encoder for the key in the entry.

fn encode_entry_value( &mut self, ) -> Result<Self::EncodeEntryValue<'_>, Self::Error>

Return encoder for value in the entry.

fn finish_entries(self) -> Result<(), Self::Error>

Complete encoding map entries.

Provided Methods

fn insert_entry<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>

where K: Encode<Self::Mode>, V: Encode<Self::Mode>,

Insert the pair immediately.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors