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§
Required Methods§
Sourcefn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
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
.
Provided Methods§
Sourcefn serialize_entry<K, V>(
&mut self,
key: &K,
value: &V,
) -> Result<(), Self::Error>
fn serialize_entry<K, V>( &mut self, key: &K, value: &V, ) -> Result<(), Self::Error>
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.