heapless/
de.rs

1use crate::{
2    binary_heap::Kind as BinaryHeapKind, BinaryHeap, Deque, IndexMap, IndexSet, LinearMap, String,
3    Vec,
4};
5use core::{
6    fmt,
7    hash::{Hash, Hasher},
8    marker::PhantomData,
9};
10use hash32::BuildHasherDefault;
11use serde::de::{self, Deserialize, Deserializer, Error, MapAccess, SeqAccess};
12
13// Sequential containers
14
15impl<'de, T, KIND, const N: usize> Deserialize<'de> for BinaryHeap<T, KIND, N>
16where
17    T: Ord + Deserialize<'de>,
18
19    KIND: BinaryHeapKind,
20{
21    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
22    where
23        D: Deserializer<'de>,
24    {
25        struct ValueVisitor<'de, T, KIND, const N: usize>(PhantomData<(&'de (), T, KIND)>);
26
27        impl<'de, T, KIND, const N: usize> de::Visitor<'de> for ValueVisitor<'de, T, KIND, N>
28        where
29            T: Ord + Deserialize<'de>,
30            KIND: BinaryHeapKind,
31        {
32            type Value = BinaryHeap<T, KIND, N>;
33
34            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
35                formatter.write_str("a sequence")
36            }
37
38            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
39            where
40                A: SeqAccess<'de>,
41            {
42                let mut values = BinaryHeap::new();
43
44                while let Some(value) = seq.next_element()? {
45                    if values.push(value).is_err() {
46                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
47                    }
48                }
49
50                Ok(values)
51            }
52        }
53        deserializer.deserialize_seq(ValueVisitor(PhantomData))
54    }
55}
56
57impl<'de, T, S, const N: usize> Deserialize<'de> for IndexSet<T, BuildHasherDefault<S>, N>
58where
59    T: Eq + Hash + Deserialize<'de>,
60    S: Hasher + Default,
61{
62    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
63    where
64        D: Deserializer<'de>,
65    {
66        struct ValueVisitor<'de, T, S, const N: usize>(PhantomData<(&'de (), T, S)>);
67
68        impl<'de, T, S, const N: usize> de::Visitor<'de> for ValueVisitor<'de, T, S, N>
69        where
70            T: Eq + Hash + Deserialize<'de>,
71            S: Hasher + Default,
72        {
73            type Value = IndexSet<T, BuildHasherDefault<S>, N>;
74
75            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
76                formatter.write_str("a sequence")
77            }
78
79            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
80            where
81                A: SeqAccess<'de>,
82            {
83                let mut values = IndexSet::new();
84
85                while let Some(value) = seq.next_element()? {
86                    if values.insert(value).is_err() {
87                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
88                    }
89                }
90
91                Ok(values)
92            }
93        }
94        deserializer.deserialize_seq(ValueVisitor(PhantomData))
95    }
96}
97
98impl<'de, T, const N: usize> Deserialize<'de> for Vec<T, N>
99where
100    T: Deserialize<'de>,
101{
102    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
103    where
104        D: Deserializer<'de>,
105    {
106        struct ValueVisitor<'de, T, const N: usize>(PhantomData<(&'de (), T)>);
107
108        impl<'de, T, const N: usize> serde::de::Visitor<'de> for ValueVisitor<'de, T, N>
109        where
110            T: Deserialize<'de>,
111        {
112            type Value = Vec<T, N>;
113
114            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
115                formatter.write_str("a sequence")
116            }
117
118            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
119            where
120                A: SeqAccess<'de>,
121            {
122                let mut values = Vec::new();
123
124                while let Some(value) = seq.next_element()? {
125                    if values.push(value).is_err() {
126                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
127                    }
128                }
129
130                Ok(values)
131            }
132        }
133        deserializer.deserialize_seq(ValueVisitor(PhantomData))
134    }
135}
136
137impl<'de, T, const N: usize> Deserialize<'de> for Deque<T, N>
138where
139    T: Deserialize<'de>,
140{
141    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
142    where
143        D: Deserializer<'de>,
144    {
145        struct ValueVisitor<'de, T, const N: usize>(PhantomData<(&'de (), T)>);
146
147        impl<'de, T, const N: usize> serde::de::Visitor<'de> for ValueVisitor<'de, T, N>
148        where
149            T: Deserialize<'de>,
150        {
151            type Value = Deque<T, N>;
152
153            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
154                formatter.write_str("a sequence")
155            }
156
157            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
158            where
159                A: SeqAccess<'de>,
160            {
161                let mut values = Deque::new();
162
163                while let Some(value) = seq.next_element()? {
164                    if values.push_back(value).is_err() {
165                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
166                    }
167                }
168
169                Ok(values)
170            }
171        }
172        deserializer.deserialize_seq(ValueVisitor(PhantomData))
173    }
174}
175
176// Dictionaries
177
178impl<'de, K, V, S, const N: usize> Deserialize<'de> for IndexMap<K, V, BuildHasherDefault<S>, N>
179where
180    K: Eq + Hash + Deserialize<'de>,
181    V: Deserialize<'de>,
182    S: Default + Hasher,
183{
184    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
185    where
186        D: Deserializer<'de>,
187    {
188        struct ValueVisitor<'de, K, V, S, const N: usize>(PhantomData<(&'de (), K, V, S)>);
189
190        impl<'de, K, V, S, const N: usize> de::Visitor<'de> for ValueVisitor<'de, K, V, S, N>
191        where
192            K: Eq + Hash + Deserialize<'de>,
193            V: Deserialize<'de>,
194            S: Default + Hasher,
195        {
196            type Value = IndexMap<K, V, BuildHasherDefault<S>, N>;
197
198            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
199                formatter.write_str("a map")
200            }
201
202            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
203            where
204                A: MapAccess<'de>,
205            {
206                let mut values = IndexMap::new();
207
208                while let Some((key, value)) = map.next_entry()? {
209                    if values.insert(key, value).is_err() {
210                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
211                    }
212                }
213
214                Ok(values)
215            }
216        }
217        deserializer.deserialize_map(ValueVisitor(PhantomData))
218    }
219}
220
221impl<'de, K, V, const N: usize> Deserialize<'de> for LinearMap<K, V, N>
222where
223    K: Eq + Deserialize<'de>,
224    V: Deserialize<'de>,
225{
226    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
227    where
228        D: Deserializer<'de>,
229    {
230        struct ValueVisitor<'de, K, V, const N: usize>(PhantomData<(&'de (), K, V)>);
231
232        impl<'de, K, V, const N: usize> de::Visitor<'de> for ValueVisitor<'de, K, V, N>
233        where
234            K: Eq + Deserialize<'de>,
235            V: Deserialize<'de>,
236        {
237            type Value = LinearMap<K, V, N>;
238
239            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
240                formatter.write_str("a map")
241            }
242
243            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
244            where
245                A: MapAccess<'de>,
246            {
247                let mut values = LinearMap::new();
248
249                while let Some((key, value)) = map.next_entry()? {
250                    if values.insert(key, value).is_err() {
251                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
252                    }
253                }
254
255                Ok(values)
256            }
257        }
258        deserializer.deserialize_map(ValueVisitor(PhantomData))
259    }
260}
261
262// String containers
263
264impl<'de, const N: usize> Deserialize<'de> for String<N> {
265    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
266    where
267        D: Deserializer<'de>,
268    {
269        struct ValueVisitor<'de, const N: usize>(PhantomData<&'de ()>);
270
271        impl<'de, const N: usize> de::Visitor<'de> for ValueVisitor<'de, N> {
272            type Value = String<N>;
273
274            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
275                write!(formatter, "a string no more than {} bytes long", N as u64)
276            }
277
278            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
279            where
280                E: de::Error,
281            {
282                let mut s = String::new();
283                s.push_str(v)
284                    .map_err(|_| E::invalid_length(v.len(), &self))?;
285                Ok(s)
286            }
287
288            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
289            where
290                E: de::Error,
291            {
292                let mut s = String::new();
293
294                s.push_str(
295                    core::str::from_utf8(v)
296                        .map_err(|_| E::invalid_value(de::Unexpected::Bytes(v), &self))?,
297                )
298                .map_err(|_| E::invalid_length(v.len(), &self))?;
299
300                Ok(s)
301            }
302        }
303
304        deserializer.deserialize_str(ValueVisitor::<'de, N>(PhantomData))
305    }
306}
heapless/de.rs

heapless/
de.rs
