# Trait serde::ser::SerializeMap [−] [src]

    pub trait SerializeMap {
        type Ok;
        type Error: Error;
        fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
        where
            T: Serialize;
        fn serialize_value<T: ?Sized>(
            &mut self,
            value: &T
        ) -> Result<(), Self::Error>
        where
            T: Serialize;
        fn end(self) -> Result<Self::Ok, Self::Error>;

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

Returned from `Serializer::serialize_map`.

# Example use

ⓘ

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

    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.

## Associated Types

### `type Ok` [src]

Must match the `Ok` type of our `Serializer`.

### `type Error: Error` [src]

Must match the `Error` type of our `Serializer`.

Loading content...

## Required methods

### `fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> where
T: Serialize,` [src]

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`.

### `fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
T: Serialize,` [src]

Serialize a map value.

# Panics

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

### `fn end(self) -> Result<Self::Ok, Self::Error>` [src]

Finish serializing a map.

Loading content...

## Provided methods

### `fn serialize_entry<K: ?Sized, V: ?Sized>(
&mut self,
key: &K,
value: &V
) -> Result<(), Self::Error> where
K: Serialize,
V: Serialize,` [src]

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.

Loading content...

## Implementors

### `impl<Ok, Error> SerializeMap for Impossible<Ok, Error> where
Error: Error,` [src]

#### `type Ok = Ok`

#### `type Error = Error`

#### `fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error> where
T: Serialize,` [src]

#### `fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> where
T: Serialize,` [src]

#### `fn end(self) -> Result<Ok, Error>` [src]

Loading content...