1mod size_hint {
2 use core::cmp;
3
4 /// This presumably exists to prevent denial of service attacks.
5 ///
6 /// Original discussion: https://github.com/serde-rs/serde/issues/1114.
7 #[cfg_attr(feature = "inline-more", inline)]
8 pub(super) fn cautious(hint: Option<usize>) -> usize {
9 cmp::min(v1:hint.unwrap_or(0), v2:4096)
10 }
11}
12
13mod map {
14 use crate::raw::Allocator;
15 use core::fmt;
16 use core::hash::{BuildHasher, Hash};
17 use core::marker::PhantomData;
18 use serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
19 use serde::ser::{Serialize, Serializer};
20
21 use crate::hash_map::HashMap;
22
23 use super::size_hint;
24
25 impl<K, V, H, A> Serialize for HashMap<K, V, H, A>
26 where
27 K: Serialize + Eq + Hash,
28 V: Serialize,
29 H: BuildHasher,
30 A: Allocator,
31 {
32 #[cfg_attr(feature = "inline-more", inline)]
33 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
34 where
35 S: Serializer,
36 {
37 serializer.collect_map(self)
38 }
39 }
40
41 impl<'de, K, V, S, A> Deserialize<'de> for HashMap<K, V, S, A>
42 where
43 K: Deserialize<'de> + Eq + Hash,
44 V: Deserialize<'de>,
45 S: BuildHasher + Default,
46 A: Allocator + Default,
47 {
48 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
49 where
50 D: Deserializer<'de>,
51 {
52 struct MapVisitor<K, V, S, A>
53 where
54 A: Allocator,
55 {
56 marker: PhantomData<HashMap<K, V, S, A>>,
57 }
58
59 impl<'de, K, V, S, A> Visitor<'de> for MapVisitor<K, V, S, A>
60 where
61 K: Deserialize<'de> + Eq + Hash,
62 V: Deserialize<'de>,
63 S: BuildHasher + Default,
64 A: Allocator + Default,
65 {
66 type Value = HashMap<K, V, S, A>;
67
68 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
69 formatter.write_str("a map")
70 }
71
72 #[cfg_attr(feature = "inline-more", inline)]
73 fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
74 where
75 M: MapAccess<'de>,
76 {
77 let mut values = HashMap::with_capacity_and_hasher_in(
78 size_hint::cautious(map.size_hint()),
79 S::default(),
80 A::default(),
81 );
82
83 while let Some((key, value)) = map.next_entry()? {
84 values.insert(key, value);
85 }
86
87 Ok(values)
88 }
89 }
90
91 let visitor = MapVisitor {
92 marker: PhantomData,
93 };
94 deserializer.deserialize_map(visitor)
95 }
96 }
97}
98
99mod set {
100 use crate::raw::Allocator;
101 use core::fmt;
102 use core::hash::{BuildHasher, Hash};
103 use core::marker::PhantomData;
104 use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
105 use serde::ser::{Serialize, Serializer};
106
107 use crate::hash_set::HashSet;
108
109 use super::size_hint;
110
111 impl<T, H, A> Serialize for HashSet<T, H, A>
112 where
113 T: Serialize + Eq + Hash,
114 H: BuildHasher,
115 A: Allocator,
116 {
117 #[cfg_attr(feature = "inline-more", inline)]
118 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
119 where
120 S: Serializer,
121 {
122 serializer.collect_seq(self)
123 }
124 }
125
126 impl<'de, T, S, A> Deserialize<'de> for HashSet<T, S, A>
127 where
128 T: Deserialize<'de> + Eq + Hash,
129 S: BuildHasher + Default,
130 A: Allocator + Default,
131 {
132 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
133 where
134 D: Deserializer<'de>,
135 {
136 struct SeqVisitor<T, S, A>
137 where
138 A: Allocator,
139 {
140 marker: PhantomData<HashSet<T, S, A>>,
141 }
142
143 impl<'de, T, S, A> Visitor<'de> for SeqVisitor<T, S, A>
144 where
145 T: Deserialize<'de> + Eq + Hash,
146 S: BuildHasher + Default,
147 A: Allocator + Default,
148 {
149 type Value = HashSet<T, S, A>;
150
151 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
152 formatter.write_str("a sequence")
153 }
154
155 #[cfg_attr(feature = "inline-more", inline)]
156 fn visit_seq<M>(self, mut seq: M) -> Result<Self::Value, M::Error>
157 where
158 M: SeqAccess<'de>,
159 {
160 let mut values = HashSet::with_capacity_and_hasher_in(
161 size_hint::cautious(seq.size_hint()),
162 S::default(),
163 A::default(),
164 );
165
166 while let Some(value) = seq.next_element()? {
167 values.insert(value);
168 }
169
170 Ok(values)
171 }
172 }
173
174 let visitor = SeqVisitor {
175 marker: PhantomData,
176 };
177 deserializer.deserialize_seq(visitor)
178 }
179
180 #[allow(clippy::missing_errors_doc)]
181 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
182 where
183 D: Deserializer<'de>,
184 {
185 struct SeqInPlaceVisitor<'a, T, S, A>(&'a mut HashSet<T, S, A>)
186 where
187 A: Allocator;
188
189 impl<'a, 'de, T, S, A> Visitor<'de> for SeqInPlaceVisitor<'a, T, S, A>
190 where
191 T: Deserialize<'de> + Eq + Hash,
192 S: BuildHasher + Default,
193 A: Allocator,
194 {
195 type Value = ();
196
197 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
198 formatter.write_str("a sequence")
199 }
200
201 #[cfg_attr(feature = "inline-more", inline)]
202 fn visit_seq<M>(self, mut seq: M) -> Result<Self::Value, M::Error>
203 where
204 M: SeqAccess<'de>,
205 {
206 self.0.clear();
207 self.0.reserve(size_hint::cautious(seq.size_hint()));
208
209 while let Some(value) = seq.next_element()? {
210 self.0.insert(value);
211 }
212
213 Ok(())
214 }
215 }
216
217 deserializer.deserialize_seq(SeqInPlaceVisitor(place))
218 }
219 }
220}
221