serde::ser

Trait SerializeMap

Source
pub trait SerializeMap {
    type Ok;
    type Error: Error;

    // Required methods
    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
       where T: ?Sized + Serialize;
    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
       where T: ?Sized + Serialize;
    fn end(self) -> Result<Self::Ok, Self::Error>;

    // Provided method
    fn serialize_entry<K, V>(
        &mut self,
        key: &K,
        value: &V,
    ) -> Result<(), Self::Error>
       where K: ?Sized + Serialize,
             V: ?Sized + Serialize { ... }
}
Expand description

Returned from Serializer::serialize_map.

§Example use

use serde::ser::{Serialize, SerializeMap, Serializer};

impl<K, V> Serialize for HashMap<K, V>
where
    K: Serialize,
    V: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.len()))?;
        for (k, v) in self {
            map.serialize_entry(k, v)?;
        }
        map.end()
    }
}

§Example implementation

The example data format presented on the website demonstrates an implementation of SerializeMap for a basic JSON data format.

Required Associated Types§

Source

type Ok

Must match the Ok type of our Serializer.

Source

type Error: Error

Must match the Error type of our Serializer.

Required Methods§

Source

fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
where T: ?Sized + Serialize,

Serialize a map key.

If possible, Serialize implementations are encouraged to use serialize_entry instead as it may be implemented more efficiently in some formats compared to a pair of calls to serialize_key and serialize_value.

Source

fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
where T: ?Sized + Serialize,

Serialize a map value.

§Panics

Calling serialize_value before serialize_key is incorrect and is allowed to panic or produce bogus results.

Source

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

Finish serializing a map.

Provided Methods§

Source

fn serialize_entry<K, V>( &mut self, key: &K, value: &V, ) -> Result<(), Self::Error>
where K: ?Sized + Serialize, V: ?Sized + Serialize,

Serialize a map entry consisting of a key and a value.

Some Serialize types are not able to hold a key and value in memory at the same time so SerializeMap implementations are required to support serialize_key and serialize_value individually. The serialize_entry method allows serializers to optimize for the case where key and value are both available. Serialize implementations are encouraged to use serialize_entry if possible.

The default implementation delegates to serialize_key and serialize_value. This is appropriate for serializers that do not care about performance or are not able to optimize serialize_entry any better than this.

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.

Implementors§

Source§

impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
where Error: Error,

Source§

type Ok = Ok

Source§

type Error = Error