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