indexmap/
serde.rs

1#![cfg_attr(docsrs, doc(cfg(feature = "serde")))]
2
3use serde_core::de::value::{MapDeserializer, SeqDeserializer};
4use serde_core::de::{
5    Deserialize, Deserializer, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor,
6};
7use serde_core::ser::{Serialize, Serializer};
8
9use core::fmt::{self, Formatter};
10use core::hash::{BuildHasher, Hash};
11use core::marker::PhantomData;
12
13use crate::{Bucket, IndexMap, IndexSet};
14
15/// Limit our preallocated capacity from a deserializer `size_hint()`.
16///
17/// We do account for the `Bucket` overhead from its saved `hash` field, but we don't count the
18/// `RawTable` allocation or the fact that its raw capacity will be rounded up to a power of two.
19/// The "max" is an arbitrary choice anyway, not something that needs precise adherence.
20///
21/// This is based on the internal `serde::de::size_hint::cautious(hint)` function.
22pub(crate) fn cautious_capacity<K, V>(hint: Option<usize>) -> usize {
23    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
24
25    Ord::min(
26        hint.unwrap_or(0),
27        MAX_PREALLOC_BYTES / size_of::<Bucket<K, V>>(),
28    )
29}
30
31impl<K, V, S> Serialize for IndexMap<K, V, S>
32where
33    K: Serialize,
34    V: Serialize,
35{
36    fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
37    where
38        T: Serializer,
39    {
40        serializer.collect_map(self)
41    }
42}
43
44struct IndexMapVisitor<K, V, S>(PhantomData<(K, V, S)>);
45
46impl<'de, K, V, S> Visitor<'de> for IndexMapVisitor<K, V, S>
47where
48    K: Deserialize<'de> + Eq + Hash,
49    V: Deserialize<'de>,
50    S: Default + BuildHasher,
51{
52    type Value = IndexMap<K, V, S>;
53
54    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
55        write!(formatter, "a map")
56    }
57
58    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
59    where
60        A: MapAccess<'de>,
61    {
62        let capacity = cautious_capacity::<K, V>(map.size_hint());
63        let mut values = IndexMap::with_capacity_and_hasher(capacity, S::default());
64
65        while let Some((key, value)) = map.next_entry()? {
66            values.insert(key, value);
67        }
68
69        Ok(values)
70    }
71}
72
73impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S>
74where
75    K: Deserialize<'de> + Eq + Hash,
76    V: Deserialize<'de>,
77    S: Default + BuildHasher,
78{
79    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
80    where
81        D: Deserializer<'de>,
82    {
83        deserializer.deserialize_map(IndexMapVisitor(PhantomData))
84    }
85}
86
87impl<'de, K, V, S, E> IntoDeserializer<'de, E> for IndexMap<K, V, S>
88where
89    K: IntoDeserializer<'de, E> + Eq + Hash,
90    V: IntoDeserializer<'de, E>,
91    S: BuildHasher,
92    E: Error,
93{
94    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
95
96    fn into_deserializer(self) -> Self::Deserializer {
97        MapDeserializer::new(self.into_iter())
98    }
99}
100
101impl<T, S> Serialize for IndexSet<T, S>
102where
103    T: Serialize,
104{
105    fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
106    where
107        Se: Serializer,
108    {
109        serializer.collect_seq(self)
110    }
111}
112
113struct IndexSetVisitor<T, S>(PhantomData<(T, S)>);
114
115impl<'de, T, S> Visitor<'de> for IndexSetVisitor<T, S>
116where
117    T: Deserialize<'de> + Eq + Hash,
118    S: Default + BuildHasher,
119{
120    type Value = IndexSet<T, S>;
121
122    fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
123        write!(formatter, "a set")
124    }
125
126    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
127    where
128        A: SeqAccess<'de>,
129    {
130        let capacity = cautious_capacity::<T, ()>(seq.size_hint());
131        let mut values = IndexSet::with_capacity_and_hasher(capacity, S::default());
132
133        while let Some(value) = seq.next_element()? {
134            values.insert(value);
135        }
136
137        Ok(values)
138    }
139}
140
141impl<'de, T, S> Deserialize<'de> for IndexSet<T, S>
142where
143    T: Deserialize<'de> + Eq + Hash,
144    S: Default + BuildHasher,
145{
146    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
147    where
148        D: Deserializer<'de>,
149    {
150        deserializer.deserialize_seq(IndexSetVisitor(PhantomData))
151    }
152}
153
154impl<'de, T, S, E> IntoDeserializer<'de, E> for IndexSet<T, S>
155where
156    T: IntoDeserializer<'de, E> + Eq + Hash,
157    S: BuildHasher,
158    E: Error,
159{
160    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
161
162    fn into_deserializer(self) -> Self::Deserializer {
163        SeqDeserializer::new(self.into_iter())
164    }
165}
indexmap/serde.rs

indexmap/
serde.rs
