]>
Commit | Line | Data |
---|---|---|
041b39d2 XL |
1 | //! Building blocks for deserializing basic values using the `IntoDeserializer` |
2 | //! trait. | |
3 | //! | |
dc9dc135 | 4 | //! ```edition2018 |
041b39d2 | 5 | //! use std::str::FromStr; |
dc9dc135 XL |
6 | //! use serde::Deserialize; |
7 | //! use serde::de::{value, IntoDeserializer}; | |
041b39d2 XL |
8 | //! |
9 | //! #[derive(Deserialize)] | |
10 | //! enum Setting { | |
11 | //! On, | |
12 | //! Off, | |
13 | //! } | |
14 | //! | |
15 | //! impl FromStr for Setting { | |
16 | //! type Err = value::Error; | |
17 | //! | |
18 | //! fn from_str(s: &str) -> Result<Self, Self::Err> { | |
19 | //! Self::deserialize(s.into_deserializer()) | |
20 | //! } | |
21 | //! } | |
041b39d2 XL |
22 | //! ``` |
23 | ||
24 | use lib::*; | |
25 | ||
83c7162d | 26 | use self::private::{First, Second}; |
5869c6ff XL |
27 | use __private::size_hint; |
28 | use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor}; | |
041b39d2 | 29 | use ser; |
041b39d2 XL |
30 | |
31 | //////////////////////////////////////////////////////////////////////////////// | |
32 | ||
8faf50e0 XL |
33 | // For structs that contain a PhantomData. We do not want the trait |
34 | // bound `E: Clone` inferred by derive(Clone). | |
35 | macro_rules! impl_copy_clone { | |
36 | ($ty:ident $(<$lifetime:tt>)*) => { | |
37 | impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {} | |
38 | ||
39 | impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> { | |
40 | fn clone(&self) -> Self { | |
41 | *self | |
42 | } | |
43 | } | |
44 | }; | |
45 | } | |
46 | ||
47 | //////////////////////////////////////////////////////////////////////////////// | |
48 | ||
041b39d2 XL |
49 | /// A minimal representation of all possible errors that can occur using the |
50 | /// `IntoDeserializer` trait. | |
5869c6ff | 51 | #[derive(Clone, PartialEq)] |
041b39d2 XL |
52 | pub struct Error { |
53 | err: ErrorImpl, | |
54 | } | |
55 | ||
56 | #[cfg(any(feature = "std", feature = "alloc"))] | |
57 | type ErrorImpl = Box<str>; | |
58 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
59 | type ErrorImpl = (); | |
60 | ||
61 | impl de::Error for Error { | |
62 | #[cfg(any(feature = "std", feature = "alloc"))] | |
8faf50e0 | 63 | #[cold] |
041b39d2 XL |
64 | fn custom<T>(msg: T) -> Self |
65 | where | |
66 | T: Display, | |
67 | { | |
ff7c6d11 XL |
68 | Error { |
69 | err: msg.to_string().into_boxed_str(), | |
70 | } | |
041b39d2 XL |
71 | } |
72 | ||
73 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
8faf50e0 | 74 | #[cold] |
041b39d2 XL |
75 | fn custom<T>(msg: T) -> Self |
76 | where | |
77 | T: Display, | |
78 | { | |
79 | let _ = msg; | |
80 | Error { err: () } | |
81 | } | |
82 | } | |
83 | ||
84 | impl ser::Error for Error { | |
8faf50e0 | 85 | #[cold] |
041b39d2 XL |
86 | fn custom<T>(msg: T) -> Self |
87 | where | |
88 | T: Display, | |
89 | { | |
90 | de::Error::custom(msg) | |
91 | } | |
92 | } | |
93 | ||
94 | impl Display for Error { | |
95 | #[cfg(any(feature = "std", feature = "alloc"))] | |
5869c6ff | 96 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
041b39d2 XL |
97 | formatter.write_str(&self.err) |
98 | } | |
99 | ||
100 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
5869c6ff | 101 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
041b39d2 XL |
102 | formatter.write_str("Serde deserialization error") |
103 | } | |
104 | } | |
105 | ||
5869c6ff XL |
106 | impl Debug for Error { |
107 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
108 | let mut debug = formatter.debug_tuple("Error"); | |
109 | #[cfg(any(feature = "std", feature = "alloc"))] | |
110 | debug.field(&self.err); | |
111 | debug.finish() | |
112 | } | |
113 | } | |
114 | ||
041b39d2 XL |
115 | #[cfg(feature = "std")] |
116 | impl error::Error for Error { | |
117 | fn description(&self) -> &str { | |
118 | &self.err | |
119 | } | |
120 | } | |
121 | ||
122 | //////////////////////////////////////////////////////////////////////////////// | |
123 | ||
124 | impl<'de, E> IntoDeserializer<'de, E> for () | |
125 | where | |
126 | E: de::Error, | |
127 | { | |
128 | type Deserializer = UnitDeserializer<E>; | |
129 | ||
130 | fn into_deserializer(self) -> UnitDeserializer<E> { | |
064997fb | 131 | UnitDeserializer::new() |
041b39d2 XL |
132 | } |
133 | } | |
134 | ||
135 | /// A deserializer holding a `()`. | |
041b39d2 XL |
136 | pub struct UnitDeserializer<E> { |
137 | marker: PhantomData<E>, | |
138 | } | |
139 | ||
8faf50e0 XL |
140 | impl_copy_clone!(UnitDeserializer); |
141 | ||
064997fb FG |
142 | impl<E> UnitDeserializer<E> { |
143 | #[allow(missing_docs)] | |
144 | pub fn new() -> Self { | |
145 | UnitDeserializer { | |
146 | marker: PhantomData, | |
147 | } | |
148 | } | |
149 | } | |
150 | ||
041b39d2 XL |
151 | impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> |
152 | where | |
153 | E: de::Error, | |
154 | { | |
155 | type Error = E; | |
156 | ||
157 | forward_to_deserialize_any! { | |
8faf50e0 XL |
158 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
159 | bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct | |
160 | map struct enum identifier ignored_any | |
041b39d2 XL |
161 | } |
162 | ||
163 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
164 | where | |
165 | V: de::Visitor<'de>, | |
166 | { | |
167 | visitor.visit_unit() | |
168 | } | |
169 | ||
170 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
171 | where | |
172 | V: de::Visitor<'de>, | |
173 | { | |
174 | visitor.visit_none() | |
175 | } | |
176 | } | |
177 | ||
5869c6ff XL |
178 | impl<E> Debug for UnitDeserializer<E> { |
179 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
180 | formatter.debug_struct("UnitDeserializer").finish() | |
181 | } | |
182 | } | |
183 | ||
041b39d2 XL |
184 | //////////////////////////////////////////////////////////////////////////////// |
185 | ||
8faf50e0 XL |
186 | /// A deserializer that cannot be instantiated. |
187 | #[cfg(feature = "unstable")] | |
188 | pub struct NeverDeserializer<E> { | |
189 | never: !, | |
190 | marker: PhantomData<E>, | |
191 | } | |
192 | ||
193 | #[cfg(feature = "unstable")] | |
194 | impl<'de, E> IntoDeserializer<'de, E> for ! | |
195 | where | |
196 | E: de::Error, | |
197 | { | |
198 | type Deserializer = NeverDeserializer<E>; | |
199 | ||
200 | fn into_deserializer(self) -> Self::Deserializer { | |
201 | self | |
202 | } | |
203 | } | |
204 | ||
205 | #[cfg(feature = "unstable")] | |
206 | impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E> | |
207 | where | |
208 | E: de::Error, | |
209 | { | |
210 | type Error = E; | |
211 | ||
212 | fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error> | |
213 | where | |
214 | V: de::Visitor<'de>, | |
215 | { | |
216 | self.never | |
217 | } | |
218 | ||
219 | forward_to_deserialize_any! { | |
220 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string | |
221 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
222 | tuple_struct map struct enum identifier ignored_any | |
223 | } | |
224 | } | |
225 | ||
226 | //////////////////////////////////////////////////////////////////////////////// | |
227 | ||
041b39d2 XL |
228 | macro_rules! primitive_deserializer { |
229 | ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => { | |
230 | #[doc = "A deserializer holding"] | |
231 | #[doc = $doc] | |
041b39d2 XL |
232 | pub struct $name<E> { |
233 | value: $ty, | |
234 | marker: PhantomData<E> | |
235 | } | |
236 | ||
8faf50e0 XL |
237 | impl_copy_clone!($name); |
238 | ||
041b39d2 XL |
239 | impl<'de, E> IntoDeserializer<'de, E> for $ty |
240 | where | |
241 | E: de::Error, | |
242 | { | |
243 | type Deserializer = $name<E>; | |
244 | ||
245 | fn into_deserializer(self) -> $name<E> { | |
064997fb FG |
246 | $name::new(self) |
247 | } | |
248 | } | |
249 | ||
250 | impl<E> $name<E> { | |
251 | #[allow(missing_docs)] | |
252 | pub fn new(value: $ty) -> Self { | |
041b39d2 | 253 | $name { |
064997fb | 254 | value: value, |
041b39d2 XL |
255 | marker: PhantomData, |
256 | } | |
257 | } | |
258 | } | |
259 | ||
260 | impl<'de, E> de::Deserializer<'de> for $name<E> | |
261 | where | |
262 | E: de::Error, | |
263 | { | |
264 | type Error = E; | |
265 | ||
266 | forward_to_deserialize_any! { | |
8faf50e0 XL |
267 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str |
268 | string bytes byte_buf option unit unit_struct newtype_struct seq | |
269 | tuple tuple_struct map struct enum identifier ignored_any | |
041b39d2 XL |
270 | } |
271 | ||
272 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
273 | where | |
274 | V: de::Visitor<'de>, | |
275 | { | |
276 | visitor.$method(self.value $($cast)*) | |
277 | } | |
278 | } | |
5869c6ff XL |
279 | |
280 | impl<E> Debug for $name<E> { | |
281 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
282 | formatter | |
283 | .debug_struct(stringify!($name)) | |
284 | .field("value", &self.value) | |
285 | .finish() | |
286 | } | |
287 | } | |
041b39d2 XL |
288 | } |
289 | } | |
290 | ||
291 | primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool); | |
292 | primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8); | |
293 | primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16); | |
294 | primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32); | |
295 | primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64); | |
296 | primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64); | |
297 | primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8); | |
298 | primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16); | |
299 | primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64); | |
300 | primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64); | |
301 | primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32); | |
302 | primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64); | |
303 | primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char); | |
304 | ||
8faf50e0 XL |
305 | serde_if_integer128! { |
306 | primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128); | |
307 | primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128); | |
308 | } | |
309 | ||
041b39d2 | 310 | /// A deserializer holding a `u32`. |
041b39d2 XL |
311 | pub struct U32Deserializer<E> { |
312 | value: u32, | |
313 | marker: PhantomData<E>, | |
314 | } | |
315 | ||
8faf50e0 XL |
316 | impl_copy_clone!(U32Deserializer); |
317 | ||
041b39d2 XL |
318 | impl<'de, E> IntoDeserializer<'de, E> for u32 |
319 | where | |
320 | E: de::Error, | |
321 | { | |
322 | type Deserializer = U32Deserializer<E>; | |
323 | ||
324 | fn into_deserializer(self) -> U32Deserializer<E> { | |
064997fb FG |
325 | U32Deserializer::new(self) |
326 | } | |
327 | } | |
328 | ||
329 | impl<E> U32Deserializer<E> { | |
330 | #[allow(missing_docs)] | |
331 | pub fn new(value: u32) -> Self { | |
041b39d2 | 332 | U32Deserializer { |
064997fb | 333 | value: value, |
041b39d2 XL |
334 | marker: PhantomData, |
335 | } | |
336 | } | |
337 | } | |
338 | ||
339 | impl<'de, E> de::Deserializer<'de> for U32Deserializer<E> | |
340 | where | |
341 | E: de::Error, | |
342 | { | |
343 | type Error = E; | |
344 | ||
345 | forward_to_deserialize_any! { | |
8faf50e0 XL |
346 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
347 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
348 | tuple_struct map struct identifier ignored_any | |
041b39d2 XL |
349 | } |
350 | ||
351 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
352 | where | |
353 | V: de::Visitor<'de>, | |
354 | { | |
355 | visitor.visit_u32(self.value) | |
356 | } | |
357 | ||
358 | fn deserialize_enum<V>( | |
359 | self, | |
360 | name: &str, | |
361 | variants: &'static [&'static str], | |
362 | visitor: V, | |
363 | ) -> Result<V::Value, Self::Error> | |
364 | where | |
365 | V: de::Visitor<'de>, | |
366 | { | |
367 | let _ = name; | |
368 | let _ = variants; | |
369 | visitor.visit_enum(self) | |
370 | } | |
371 | } | |
372 | ||
373 | impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E> | |
374 | where | |
375 | E: de::Error, | |
376 | { | |
377 | type Error = E; | |
378 | type Variant = private::UnitOnly<E>; | |
379 | ||
380 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
381 | where | |
382 | T: de::DeserializeSeed<'de>, | |
383 | { | |
384 | seed.deserialize(self).map(private::unit_only) | |
385 | } | |
386 | } | |
387 | ||
5869c6ff XL |
388 | impl<E> Debug for U32Deserializer<E> { |
389 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
390 | formatter | |
391 | .debug_struct("U32Deserializer") | |
392 | .field("value", &self.value) | |
393 | .finish() | |
394 | } | |
395 | } | |
396 | ||
041b39d2 XL |
397 | //////////////////////////////////////////////////////////////////////////////// |
398 | ||
399 | /// A deserializer holding a `&str`. | |
041b39d2 XL |
400 | pub struct StrDeserializer<'a, E> { |
401 | value: &'a str, | |
402 | marker: PhantomData<E>, | |
403 | } | |
404 | ||
8faf50e0 XL |
405 | impl_copy_clone!(StrDeserializer<'de>); |
406 | ||
041b39d2 XL |
407 | impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str |
408 | where | |
409 | E: de::Error, | |
410 | { | |
411 | type Deserializer = StrDeserializer<'a, E>; | |
412 | ||
413 | fn into_deserializer(self) -> StrDeserializer<'a, E> { | |
064997fb FG |
414 | StrDeserializer::new(self) |
415 | } | |
416 | } | |
417 | ||
418 | impl<'a, E> StrDeserializer<'a, E> { | |
419 | #[allow(missing_docs)] | |
420 | pub fn new(value: &'a str) -> Self { | |
041b39d2 | 421 | StrDeserializer { |
064997fb | 422 | value: value, |
041b39d2 XL |
423 | marker: PhantomData, |
424 | } | |
425 | } | |
426 | } | |
427 | ||
428 | impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E> | |
429 | where | |
430 | E: de::Error, | |
431 | { | |
432 | type Error = E; | |
433 | ||
434 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
435 | where | |
436 | V: de::Visitor<'de>, | |
437 | { | |
438 | visitor.visit_str(self.value) | |
439 | } | |
440 | ||
441 | fn deserialize_enum<V>( | |
442 | self, | |
443 | name: &str, | |
444 | variants: &'static [&'static str], | |
445 | visitor: V, | |
446 | ) -> Result<V::Value, Self::Error> | |
447 | where | |
448 | V: de::Visitor<'de>, | |
449 | { | |
450 | let _ = name; | |
451 | let _ = variants; | |
452 | visitor.visit_enum(self) | |
453 | } | |
454 | ||
455 | forward_to_deserialize_any! { | |
8faf50e0 XL |
456 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
457 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
458 | tuple_struct map struct identifier ignored_any | |
041b39d2 XL |
459 | } |
460 | } | |
461 | ||
462 | impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> | |
463 | where | |
464 | E: de::Error, | |
465 | { | |
466 | type Error = E; | |
467 | type Variant = private::UnitOnly<E>; | |
468 | ||
469 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
470 | where | |
471 | T: de::DeserializeSeed<'de>, | |
472 | { | |
473 | seed.deserialize(self).map(private::unit_only) | |
474 | } | |
475 | } | |
476 | ||
5869c6ff XL |
477 | impl<'a, E> Debug for StrDeserializer<'a, E> { |
478 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
479 | formatter | |
480 | .debug_struct("StrDeserializer") | |
481 | .field("value", &self.value) | |
482 | .finish() | |
483 | } | |
484 | } | |
485 | ||
041b39d2 XL |
486 | //////////////////////////////////////////////////////////////////////////////// |
487 | ||
488 | /// A deserializer holding a `&str` with a lifetime tied to another | |
489 | /// deserializer. | |
041b39d2 XL |
490 | pub struct BorrowedStrDeserializer<'de, E> { |
491 | value: &'de str, | |
492 | marker: PhantomData<E>, | |
493 | } | |
494 | ||
8faf50e0 XL |
495 | impl_copy_clone!(BorrowedStrDeserializer<'de>); |
496 | ||
041b39d2 XL |
497 | impl<'de, E> BorrowedStrDeserializer<'de, E> { |
498 | /// Create a new borrowed deserializer from the given string. | |
499 | pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> { | |
500 | BorrowedStrDeserializer { | |
501 | value: value, | |
502 | marker: PhantomData, | |
503 | } | |
504 | } | |
505 | } | |
506 | ||
507 | impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E> | |
508 | where | |
509 | E: de::Error, | |
510 | { | |
511 | type Error = E; | |
512 | ||
513 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
514 | where | |
515 | V: de::Visitor<'de>, | |
516 | { | |
517 | visitor.visit_borrowed_str(self.value) | |
518 | } | |
519 | ||
520 | fn deserialize_enum<V>( | |
521 | self, | |
522 | name: &str, | |
523 | variants: &'static [&'static str], | |
524 | visitor: V, | |
525 | ) -> Result<V::Value, Self::Error> | |
526 | where | |
527 | V: de::Visitor<'de>, | |
528 | { | |
529 | let _ = name; | |
530 | let _ = variants; | |
531 | visitor.visit_enum(self) | |
532 | } | |
533 | ||
534 | forward_to_deserialize_any! { | |
8faf50e0 XL |
535 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
536 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
537 | tuple_struct map struct identifier ignored_any | |
041b39d2 XL |
538 | } |
539 | } | |
540 | ||
541 | impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E> | |
542 | where | |
543 | E: de::Error, | |
544 | { | |
545 | type Error = E; | |
546 | type Variant = private::UnitOnly<E>; | |
547 | ||
548 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
549 | where | |
550 | T: de::DeserializeSeed<'de>, | |
551 | { | |
552 | seed.deserialize(self).map(private::unit_only) | |
553 | } | |
554 | } | |
555 | ||
5869c6ff XL |
556 | impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> { |
557 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
558 | formatter | |
559 | .debug_struct("BorrowedStrDeserializer") | |
560 | .field("value", &self.value) | |
561 | .finish() | |
562 | } | |
563 | } | |
564 | ||
041b39d2 XL |
565 | //////////////////////////////////////////////////////////////////////////////// |
566 | ||
567 | /// A deserializer holding a `String`. | |
568 | #[cfg(any(feature = "std", feature = "alloc"))] | |
041b39d2 XL |
569 | pub struct StringDeserializer<E> { |
570 | value: String, | |
571 | marker: PhantomData<E>, | |
572 | } | |
573 | ||
8faf50e0 XL |
574 | #[cfg(any(feature = "std", feature = "alloc"))] |
575 | impl<E> Clone for StringDeserializer<E> { | |
576 | fn clone(&self) -> Self { | |
577 | StringDeserializer { | |
578 | value: self.value.clone(), | |
579 | marker: PhantomData, | |
580 | } | |
581 | } | |
582 | } | |
583 | ||
041b39d2 XL |
584 | #[cfg(any(feature = "std", feature = "alloc"))] |
585 | impl<'de, E> IntoDeserializer<'de, E> for String | |
586 | where | |
587 | E: de::Error, | |
588 | { | |
589 | type Deserializer = StringDeserializer<E>; | |
590 | ||
591 | fn into_deserializer(self) -> StringDeserializer<E> { | |
064997fb FG |
592 | StringDeserializer::new(self) |
593 | } | |
594 | } | |
595 | ||
596 | #[cfg(any(feature = "std", feature = "alloc"))] | |
597 | impl<E> StringDeserializer<E> { | |
598 | #[allow(missing_docs)] | |
599 | pub fn new(value: String) -> Self { | |
041b39d2 | 600 | StringDeserializer { |
064997fb | 601 | value: value, |
041b39d2 XL |
602 | marker: PhantomData, |
603 | } | |
604 | } | |
605 | } | |
606 | ||
607 | #[cfg(any(feature = "std", feature = "alloc"))] | |
608 | impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> | |
609 | where | |
610 | E: de::Error, | |
611 | { | |
612 | type Error = E; | |
613 | ||
614 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
615 | where | |
616 | V: de::Visitor<'de>, | |
617 | { | |
618 | visitor.visit_string(self.value) | |
619 | } | |
620 | ||
621 | fn deserialize_enum<V>( | |
622 | self, | |
623 | name: &str, | |
624 | variants: &'static [&'static str], | |
625 | visitor: V, | |
626 | ) -> Result<V::Value, Self::Error> | |
627 | where | |
628 | V: de::Visitor<'de>, | |
629 | { | |
630 | let _ = name; | |
631 | let _ = variants; | |
632 | visitor.visit_enum(self) | |
633 | } | |
634 | ||
635 | forward_to_deserialize_any! { | |
8faf50e0 XL |
636 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
637 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
638 | tuple_struct map struct identifier ignored_any | |
041b39d2 XL |
639 | } |
640 | } | |
641 | ||
642 | #[cfg(any(feature = "std", feature = "alloc"))] | |
064997fb | 643 | impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E> |
041b39d2 XL |
644 | where |
645 | E: de::Error, | |
646 | { | |
647 | type Error = E; | |
648 | type Variant = private::UnitOnly<E>; | |
649 | ||
650 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
651 | where | |
652 | T: de::DeserializeSeed<'de>, | |
653 | { | |
654 | seed.deserialize(self).map(private::unit_only) | |
655 | } | |
656 | } | |
657 | ||
5869c6ff XL |
658 | #[cfg(any(feature = "std", feature = "alloc"))] |
659 | impl<E> Debug for StringDeserializer<E> { | |
660 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
661 | formatter | |
662 | .debug_struct("StringDeserializer") | |
663 | .field("value", &self.value) | |
664 | .finish() | |
665 | } | |
666 | } | |
667 | ||
041b39d2 XL |
668 | //////////////////////////////////////////////////////////////////////////////// |
669 | ||
670 | /// A deserializer holding a `Cow<str>`. | |
671 | #[cfg(any(feature = "std", feature = "alloc"))] | |
041b39d2 XL |
672 | pub struct CowStrDeserializer<'a, E> { |
673 | value: Cow<'a, str>, | |
674 | marker: PhantomData<E>, | |
675 | } | |
676 | ||
8faf50e0 XL |
677 | #[cfg(any(feature = "std", feature = "alloc"))] |
678 | impl<'a, E> Clone for CowStrDeserializer<'a, E> { | |
679 | fn clone(&self) -> Self { | |
680 | CowStrDeserializer { | |
681 | value: self.value.clone(), | |
682 | marker: PhantomData, | |
683 | } | |
684 | } | |
685 | } | |
686 | ||
041b39d2 XL |
687 | #[cfg(any(feature = "std", feature = "alloc"))] |
688 | impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> | |
689 | where | |
690 | E: de::Error, | |
691 | { | |
692 | type Deserializer = CowStrDeserializer<'a, E>; | |
693 | ||
694 | fn into_deserializer(self) -> CowStrDeserializer<'a, E> { | |
064997fb FG |
695 | CowStrDeserializer::new(self) |
696 | } | |
697 | } | |
698 | ||
699 | #[cfg(any(feature = "std", feature = "alloc"))] | |
700 | impl<'a, E> CowStrDeserializer<'a, E> { | |
701 | #[allow(missing_docs)] | |
702 | pub fn new(value: Cow<'a, str>) -> Self { | |
041b39d2 | 703 | CowStrDeserializer { |
064997fb | 704 | value: value, |
041b39d2 XL |
705 | marker: PhantomData, |
706 | } | |
707 | } | |
708 | } | |
709 | ||
710 | #[cfg(any(feature = "std", feature = "alloc"))] | |
711 | impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E> | |
712 | where | |
713 | E: de::Error, | |
714 | { | |
715 | type Error = E; | |
716 | ||
717 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
718 | where | |
719 | V: de::Visitor<'de>, | |
720 | { | |
721 | match self.value { | |
722 | Cow::Borrowed(string) => visitor.visit_str(string), | |
723 | Cow::Owned(string) => visitor.visit_string(string), | |
724 | } | |
725 | } | |
726 | ||
727 | fn deserialize_enum<V>( | |
728 | self, | |
729 | name: &str, | |
730 | variants: &'static [&'static str], | |
731 | visitor: V, | |
732 | ) -> Result<V::Value, Self::Error> | |
733 | where | |
734 | V: de::Visitor<'de>, | |
735 | { | |
736 | let _ = name; | |
737 | let _ = variants; | |
738 | visitor.visit_enum(self) | |
739 | } | |
740 | ||
741 | forward_to_deserialize_any! { | |
8faf50e0 XL |
742 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
743 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
744 | tuple_struct map struct identifier ignored_any | |
041b39d2 XL |
745 | } |
746 | } | |
747 | ||
748 | #[cfg(any(feature = "std", feature = "alloc"))] | |
749 | impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E> | |
750 | where | |
751 | E: de::Error, | |
752 | { | |
753 | type Error = E; | |
754 | type Variant = private::UnitOnly<E>; | |
755 | ||
756 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
757 | where | |
758 | T: de::DeserializeSeed<'de>, | |
759 | { | |
760 | seed.deserialize(self).map(private::unit_only) | |
761 | } | |
762 | } | |
763 | ||
5869c6ff XL |
764 | #[cfg(any(feature = "std", feature = "alloc"))] |
765 | impl<'a, E> Debug for CowStrDeserializer<'a, E> { | |
766 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
767 | formatter | |
768 | .debug_struct("CowStrDeserializer") | |
769 | .field("value", &self.value) | |
770 | .finish() | |
771 | } | |
772 | } | |
773 | ||
041b39d2 XL |
774 | //////////////////////////////////////////////////////////////////////////////// |
775 | ||
5869c6ff XL |
776 | /// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`]. |
777 | pub struct BytesDeserializer<'a, E> { | |
778 | value: &'a [u8], | |
779 | marker: PhantomData<E>, | |
780 | } | |
781 | ||
782 | impl<'a, E> BytesDeserializer<'a, E> { | |
783 | /// Create a new deserializer from the given bytes. | |
784 | pub fn new(value: &'a [u8]) -> Self { | |
785 | BytesDeserializer { | |
786 | value: value, | |
787 | marker: PhantomData, | |
788 | } | |
789 | } | |
790 | } | |
791 | ||
792 | impl_copy_clone!(BytesDeserializer<'a>); | |
793 | ||
794 | impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8] | |
795 | where | |
796 | E: de::Error, | |
797 | { | |
798 | type Deserializer = BytesDeserializer<'a, E>; | |
799 | ||
800 | fn into_deserializer(self) -> BytesDeserializer<'a, E> { | |
801 | BytesDeserializer::new(self) | |
802 | } | |
803 | } | |
804 | ||
805 | impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E> | |
806 | where | |
807 | E: de::Error, | |
808 | { | |
809 | type Error = E; | |
810 | ||
811 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
812 | where | |
813 | V: Visitor<'de>, | |
814 | { | |
815 | visitor.visit_bytes(self.value) | |
816 | } | |
817 | ||
818 | forward_to_deserialize_any! { | |
819 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string | |
820 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
821 | tuple_struct map struct enum identifier ignored_any | |
822 | } | |
823 | } | |
824 | ||
825 | impl<'a, E> Debug for BytesDeserializer<'a, E> { | |
826 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
827 | formatter | |
828 | .debug_struct("BytesDeserializer") | |
829 | .field("value", &self.value) | |
830 | .finish() | |
831 | } | |
832 | } | |
833 | ||
041b39d2 | 834 | /// A deserializer holding a `&[u8]` with a lifetime tied to another |
5869c6ff | 835 | /// deserializer. Always calls [`Visitor::visit_borrowed_bytes`]. |
041b39d2 XL |
836 | pub struct BorrowedBytesDeserializer<'de, E> { |
837 | value: &'de [u8], | |
838 | marker: PhantomData<E>, | |
839 | } | |
840 | ||
841 | impl<'de, E> BorrowedBytesDeserializer<'de, E> { | |
5869c6ff XL |
842 | /// Create a new borrowed deserializer from the given borrowed bytes. |
843 | pub fn new(value: &'de [u8]) -> Self { | |
041b39d2 XL |
844 | BorrowedBytesDeserializer { |
845 | value: value, | |
846 | marker: PhantomData, | |
847 | } | |
848 | } | |
849 | } | |
850 | ||
5869c6ff XL |
851 | impl_copy_clone!(BorrowedBytesDeserializer<'de>); |
852 | ||
853 | impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E> | |
041b39d2 XL |
854 | where |
855 | E: de::Error, | |
856 | { | |
857 | type Error = E; | |
858 | ||
859 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
860 | where | |
5869c6ff | 861 | V: Visitor<'de>, |
041b39d2 XL |
862 | { |
863 | visitor.visit_borrowed_bytes(self.value) | |
864 | } | |
865 | ||
866 | forward_to_deserialize_any! { | |
8faf50e0 XL |
867 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
868 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
5869c6ff XL |
869 | tuple_struct map struct enum identifier ignored_any |
870 | } | |
871 | } | |
872 | ||
873 | impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> { | |
874 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
875 | formatter | |
876 | .debug_struct("BorrowedBytesDeserializer") | |
877 | .field("value", &self.value) | |
878 | .finish() | |
041b39d2 XL |
879 | } |
880 | } | |
881 | ||
882 | //////////////////////////////////////////////////////////////////////////////// | |
883 | ||
884 | /// A deserializer that iterates over a sequence. | |
5869c6ff | 885 | #[derive(Clone)] |
041b39d2 XL |
886 | pub struct SeqDeserializer<I, E> { |
887 | iter: iter::Fuse<I>, | |
888 | count: usize, | |
889 | marker: PhantomData<E>, | |
890 | } | |
891 | ||
892 | impl<I, E> SeqDeserializer<I, E> | |
893 | where | |
894 | I: Iterator, | |
895 | { | |
896 | /// Construct a new `SeqDeserializer<I, E>`. | |
897 | pub fn new(iter: I) -> Self { | |
898 | SeqDeserializer { | |
899 | iter: iter.fuse(), | |
900 | count: 0, | |
901 | marker: PhantomData, | |
902 | } | |
903 | } | |
904 | } | |
905 | ||
906 | impl<I, E> SeqDeserializer<I, E> | |
907 | where | |
908 | I: Iterator, | |
909 | E: de::Error, | |
910 | { | |
911 | /// Check for remaining elements after passing a `SeqDeserializer` to | |
912 | /// `Visitor::visit_seq`. | |
83c7162d XL |
913 | pub fn end(self) -> Result<(), E> { |
914 | let remaining = self.iter.count(); | |
041b39d2 XL |
915 | if remaining == 0 { |
916 | Ok(()) | |
917 | } else { | |
918 | // First argument is the number of elements in the data, second | |
919 | // argument is the number of elements expected by the Deserialize. | |
ff7c6d11 XL |
920 | Err(de::Error::invalid_length( |
921 | self.count + remaining, | |
922 | &ExpectedInSeq(self.count), | |
923 | )) | |
041b39d2 XL |
924 | } |
925 | } | |
926 | } | |
927 | ||
928 | impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E> | |
929 | where | |
930 | I: Iterator<Item = T>, | |
931 | T: IntoDeserializer<'de, E>, | |
932 | E: de::Error, | |
933 | { | |
934 | type Error = E; | |
935 | ||
936 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
937 | where | |
938 | V: de::Visitor<'de>, | |
939 | { | |
940 | let v = try!(visitor.visit_seq(&mut self)); | |
941 | try!(self.end()); | |
942 | Ok(v) | |
943 | } | |
944 | ||
945 | forward_to_deserialize_any! { | |
8faf50e0 XL |
946 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
947 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
948 | tuple_struct map struct enum identifier ignored_any | |
041b39d2 XL |
949 | } |
950 | } | |
951 | ||
952 | impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> | |
953 | where | |
954 | I: Iterator<Item = T>, | |
955 | T: IntoDeserializer<'de, E>, | |
956 | E: de::Error, | |
957 | { | |
958 | type Error = E; | |
959 | ||
960 | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> | |
961 | where | |
962 | V: de::DeserializeSeed<'de>, | |
963 | { | |
964 | match self.iter.next() { | |
965 | Some(value) => { | |
966 | self.count += 1; | |
967 | seed.deserialize(value.into_deserializer()).map(Some) | |
968 | } | |
969 | None => Ok(None), | |
970 | } | |
971 | } | |
972 | ||
973 | fn size_hint(&self) -> Option<usize> { | |
974 | size_hint::from_bounds(&self.iter) | |
975 | } | |
976 | } | |
977 | ||
978 | struct ExpectedInSeq(usize); | |
979 | ||
980 | impl Expected for ExpectedInSeq { | |
981 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
982 | if self.0 == 1 { | |
983 | write!(formatter, "1 element in sequence") | |
984 | } else { | |
985 | write!(formatter, "{} elements in sequence", self.0) | |
986 | } | |
987 | } | |
988 | } | |
989 | ||
5869c6ff XL |
990 | impl<I, E> Debug for SeqDeserializer<I, E> |
991 | where | |
992 | I: Debug, | |
993 | { | |
994 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
995 | formatter | |
996 | .debug_struct("SeqDeserializer") | |
997 | .field("iter", &self.iter) | |
998 | .field("count", &self.count) | |
999 | .finish() | |
1000 | } | |
1001 | } | |
1002 | ||
041b39d2 XL |
1003 | //////////////////////////////////////////////////////////////////////////////// |
1004 | ||
1005 | #[cfg(any(feature = "std", feature = "alloc"))] | |
1006 | impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> | |
1007 | where | |
1008 | T: IntoDeserializer<'de, E>, | |
1009 | E: de::Error, | |
1010 | { | |
abe05a73 | 1011 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1012 | |
1013 | fn into_deserializer(self) -> Self::Deserializer { | |
1014 | SeqDeserializer::new(self.into_iter()) | |
1015 | } | |
1016 | } | |
1017 | ||
1018 | #[cfg(any(feature = "std", feature = "alloc"))] | |
1019 | impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> | |
1020 | where | |
1021 | T: IntoDeserializer<'de, E> + Eq + Ord, | |
1022 | E: de::Error, | |
1023 | { | |
abe05a73 | 1024 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1025 | |
1026 | fn into_deserializer(self) -> Self::Deserializer { | |
1027 | SeqDeserializer::new(self.into_iter()) | |
1028 | } | |
1029 | } | |
1030 | ||
1031 | #[cfg(feature = "std")] | |
abe05a73 | 1032 | impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> |
041b39d2 XL |
1033 | where |
1034 | T: IntoDeserializer<'de, E> + Eq + Hash, | |
abe05a73 | 1035 | S: BuildHasher, |
041b39d2 XL |
1036 | E: de::Error, |
1037 | { | |
abe05a73 | 1038 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1039 | |
1040 | fn into_deserializer(self) -> Self::Deserializer { | |
1041 | SeqDeserializer::new(self.into_iter()) | |
1042 | } | |
1043 | } | |
1044 | ||
1045 | //////////////////////////////////////////////////////////////////////////////// | |
1046 | ||
1047 | /// A deserializer holding a `SeqAccess`. | |
1048 | #[derive(Clone, Debug)] | |
1049 | pub struct SeqAccessDeserializer<A> { | |
1050 | seq: A, | |
1051 | } | |
1052 | ||
1053 | impl<A> SeqAccessDeserializer<A> { | |
1054 | /// Construct a new `SeqAccessDeserializer<A>`. | |
1055 | pub fn new(seq: A) -> Self { | |
1056 | SeqAccessDeserializer { seq: seq } | |
1057 | } | |
1058 | } | |
1059 | ||
1060 | impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> | |
1061 | where | |
1062 | A: de::SeqAccess<'de>, | |
1063 | { | |
1064 | type Error = A::Error; | |
1065 | ||
1066 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1067 | where | |
1068 | V: de::Visitor<'de>, | |
1069 | { | |
1070 | visitor.visit_seq(self.seq) | |
1071 | } | |
1072 | ||
1073 | forward_to_deserialize_any! { | |
8faf50e0 XL |
1074 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
1075 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
1076 | tuple_struct map struct enum identifier ignored_any | |
041b39d2 XL |
1077 | } |
1078 | } | |
1079 | ||
1080 | //////////////////////////////////////////////////////////////////////////////// | |
1081 | ||
1082 | /// A deserializer that iterates over a map. | |
1083 | pub struct MapDeserializer<'de, I, E> | |
1084 | where | |
1085 | I: Iterator, | |
1086 | I::Item: private::Pair, | |
1087 | { | |
1088 | iter: iter::Fuse<I>, | |
1089 | value: Option<Second<I::Item>>, | |
1090 | count: usize, | |
1091 | lifetime: PhantomData<&'de ()>, | |
1092 | error: PhantomData<E>, | |
1093 | } | |
1094 | ||
1095 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
1096 | where | |
1097 | I: Iterator, | |
1098 | I::Item: private::Pair, | |
1099 | { | |
1100 | /// Construct a new `MapDeserializer<I, E>`. | |
1101 | pub fn new(iter: I) -> Self { | |
1102 | MapDeserializer { | |
1103 | iter: iter.fuse(), | |
1104 | value: None, | |
1105 | count: 0, | |
1106 | lifetime: PhantomData, | |
1107 | error: PhantomData, | |
1108 | } | |
1109 | } | |
1110 | } | |
1111 | ||
1112 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
1113 | where | |
1114 | I: Iterator, | |
1115 | I::Item: private::Pair, | |
1116 | E: de::Error, | |
1117 | { | |
1118 | /// Check for remaining elements after passing a `MapDeserializer` to | |
1119 | /// `Visitor::visit_map`. | |
83c7162d XL |
1120 | pub fn end(self) -> Result<(), E> { |
1121 | let remaining = self.iter.count(); | |
041b39d2 XL |
1122 | if remaining == 0 { |
1123 | Ok(()) | |
1124 | } else { | |
1125 | // First argument is the number of elements in the data, second | |
1126 | // argument is the number of elements expected by the Deserialize. | |
ff7c6d11 XL |
1127 | Err(de::Error::invalid_length( |
1128 | self.count + remaining, | |
1129 | &ExpectedInMap(self.count), | |
1130 | )) | |
041b39d2 XL |
1131 | } |
1132 | } | |
1133 | } | |
1134 | ||
1135 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
1136 | where | |
1137 | I: Iterator, | |
1138 | I::Item: private::Pair, | |
1139 | { | |
1140 | fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> { | |
1141 | match self.iter.next() { | |
1142 | Some(kv) => { | |
1143 | self.count += 1; | |
1144 | Some(private::Pair::split(kv)) | |
1145 | } | |
1146 | None => None, | |
1147 | } | |
1148 | } | |
1149 | } | |
1150 | ||
1151 | impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E> | |
1152 | where | |
1153 | I: Iterator, | |
1154 | I::Item: private::Pair, | |
1155 | First<I::Item>: IntoDeserializer<'de, E>, | |
1156 | Second<I::Item>: IntoDeserializer<'de, E>, | |
1157 | E: de::Error, | |
1158 | { | |
1159 | type Error = E; | |
1160 | ||
1161 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
1162 | where | |
1163 | V: de::Visitor<'de>, | |
1164 | { | |
1165 | let value = try!(visitor.visit_map(&mut self)); | |
1166 | try!(self.end()); | |
1167 | Ok(value) | |
1168 | } | |
1169 | ||
1170 | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
1171 | where | |
1172 | V: de::Visitor<'de>, | |
1173 | { | |
1174 | let value = try!(visitor.visit_seq(&mut self)); | |
1175 | try!(self.end()); | |
1176 | Ok(value) | |
1177 | } | |
1178 | ||
ff7c6d11 | 1179 | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> |
041b39d2 XL |
1180 | where |
1181 | V: de::Visitor<'de>, | |
1182 | { | |
1183 | let _ = len; | |
1184 | self.deserialize_seq(visitor) | |
1185 | } | |
1186 | ||
1187 | forward_to_deserialize_any! { | |
8faf50e0 XL |
1188 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
1189 | bytes byte_buf option unit unit_struct newtype_struct tuple_struct map | |
1190 | struct enum identifier ignored_any | |
041b39d2 XL |
1191 | } |
1192 | } | |
1193 | ||
1194 | impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E> | |
1195 | where | |
1196 | I: Iterator, | |
1197 | I::Item: private::Pair, | |
1198 | First<I::Item>: IntoDeserializer<'de, E>, | |
1199 | Second<I::Item>: IntoDeserializer<'de, E>, | |
1200 | E: de::Error, | |
1201 | { | |
1202 | type Error = E; | |
1203 | ||
1204 | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
1205 | where | |
1206 | T: de::DeserializeSeed<'de>, | |
1207 | { | |
1208 | match self.next_pair() { | |
1209 | Some((key, value)) => { | |
1210 | self.value = Some(value); | |
1211 | seed.deserialize(key.into_deserializer()).map(Some) | |
1212 | } | |
1213 | None => Ok(None), | |
1214 | } | |
1215 | } | |
1216 | ||
1217 | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> | |
1218 | where | |
1219 | T: de::DeserializeSeed<'de>, | |
1220 | { | |
1221 | let value = self.value.take(); | |
1222 | // Panic because this indicates a bug in the program rather than an | |
1223 | // expected failure. | |
fc512014 | 1224 | let value = value.expect("MapAccess::next_value called before next_key"); |
041b39d2 XL |
1225 | seed.deserialize(value.into_deserializer()) |
1226 | } | |
1227 | ||
1228 | fn next_entry_seed<TK, TV>( | |
1229 | &mut self, | |
1230 | kseed: TK, | |
1231 | vseed: TV, | |
1232 | ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> | |
1233 | where | |
1234 | TK: de::DeserializeSeed<'de>, | |
1235 | TV: de::DeserializeSeed<'de>, | |
1236 | { | |
1237 | match self.next_pair() { | |
1238 | Some((key, value)) => { | |
1239 | let key = try!(kseed.deserialize(key.into_deserializer())); | |
1240 | let value = try!(vseed.deserialize(value.into_deserializer())); | |
1241 | Ok(Some((key, value))) | |
1242 | } | |
1243 | None => Ok(None), | |
1244 | } | |
1245 | } | |
1246 | ||
1247 | fn size_hint(&self) -> Option<usize> { | |
1248 | size_hint::from_bounds(&self.iter) | |
1249 | } | |
1250 | } | |
1251 | ||
1252 | impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E> | |
1253 | where | |
1254 | I: Iterator, | |
1255 | I::Item: private::Pair, | |
1256 | First<I::Item>: IntoDeserializer<'de, E>, | |
1257 | Second<I::Item>: IntoDeserializer<'de, E>, | |
1258 | E: de::Error, | |
1259 | { | |
1260 | type Error = E; | |
1261 | ||
1262 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
1263 | where | |
1264 | T: de::DeserializeSeed<'de>, | |
1265 | { | |
1266 | match self.next_pair() { | |
1267 | Some((k, v)) => { | |
1268 | let de = PairDeserializer(k, v, PhantomData); | |
1269 | seed.deserialize(de).map(Some) | |
1270 | } | |
1271 | None => Ok(None), | |
1272 | } | |
1273 | } | |
1274 | ||
1275 | fn size_hint(&self) -> Option<usize> { | |
1276 | size_hint::from_bounds(&self.iter) | |
1277 | } | |
1278 | } | |
1279 | ||
1280 | // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`. | |
1281 | impl<'de, I, E> Clone for MapDeserializer<'de, I, E> | |
1282 | where | |
1283 | I: Iterator + Clone, | |
1284 | I::Item: private::Pair, | |
1285 | Second<I::Item>: Clone, | |
1286 | { | |
1287 | fn clone(&self) -> Self { | |
1288 | MapDeserializer { | |
1289 | iter: self.iter.clone(), | |
1290 | value: self.value.clone(), | |
1291 | count: self.count, | |
1292 | lifetime: self.lifetime, | |
1293 | error: self.error, | |
1294 | } | |
1295 | } | |
1296 | } | |
1297 | ||
041b39d2 XL |
1298 | impl<'de, I, E> Debug for MapDeserializer<'de, I, E> |
1299 | where | |
1300 | I: Iterator + Debug, | |
1301 | I::Item: private::Pair, | |
1302 | Second<I::Item>: Debug, | |
1303 | { | |
1304 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
1305 | formatter | |
1306 | .debug_struct("MapDeserializer") | |
1307 | .field("iter", &self.iter) | |
1308 | .field("value", &self.value) | |
1309 | .field("count", &self.count) | |
041b39d2 XL |
1310 | .finish() |
1311 | } | |
1312 | } | |
1313 | ||
1314 | // Used in the `impl SeqAccess for MapDeserializer` to visit the map as a | |
1315 | // sequence of pairs. | |
1316 | struct PairDeserializer<A, B, E>(A, B, PhantomData<E>); | |
1317 | ||
1318 | impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E> | |
1319 | where | |
1320 | A: IntoDeserializer<'de, E>, | |
1321 | B: IntoDeserializer<'de, E>, | |
1322 | E: de::Error, | |
1323 | { | |
1324 | type Error = E; | |
1325 | ||
1326 | forward_to_deserialize_any! { | |
8faf50e0 XL |
1327 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
1328 | bytes byte_buf option unit unit_struct newtype_struct tuple_struct map | |
1329 | struct enum identifier ignored_any | |
041b39d2 XL |
1330 | } |
1331 | ||
1332 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1333 | where | |
1334 | V: de::Visitor<'de>, | |
1335 | { | |
1336 | self.deserialize_seq(visitor) | |
1337 | } | |
1338 | ||
1339 | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1340 | where | |
1341 | V: de::Visitor<'de>, | |
1342 | { | |
1343 | let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData); | |
1344 | let pair = try!(visitor.visit_seq(&mut pair_visitor)); | |
1345 | if pair_visitor.1.is_none() { | |
1346 | Ok(pair) | |
1347 | } else { | |
1348 | let remaining = pair_visitor.size_hint().unwrap(); | |
1349 | // First argument is the number of elements in the data, second | |
1350 | // argument is the number of elements expected by the Deserialize. | |
1351 | Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining))) | |
1352 | } | |
1353 | } | |
1354 | ||
1355 | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> | |
1356 | where | |
1357 | V: de::Visitor<'de>, | |
1358 | { | |
1359 | if len == 2 { | |
1360 | self.deserialize_seq(visitor) | |
1361 | } else { | |
1362 | // First argument is the number of elements in the data, second | |
1363 | // argument is the number of elements expected by the Deserialize. | |
1364 | Err(de::Error::invalid_length(2, &ExpectedInSeq(len))) | |
1365 | } | |
1366 | } | |
1367 | } | |
1368 | ||
1369 | struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>); | |
1370 | ||
1371 | impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> | |
1372 | where | |
1373 | A: IntoDeserializer<'de, E>, | |
1374 | B: IntoDeserializer<'de, E>, | |
1375 | E: de::Error, | |
1376 | { | |
1377 | type Error = E; | |
1378 | ||
1379 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
1380 | where | |
1381 | T: de::DeserializeSeed<'de>, | |
1382 | { | |
1383 | if let Some(k) = self.0.take() { | |
1384 | seed.deserialize(k.into_deserializer()).map(Some) | |
1385 | } else if let Some(v) = self.1.take() { | |
1386 | seed.deserialize(v.into_deserializer()).map(Some) | |
1387 | } else { | |
1388 | Ok(None) | |
1389 | } | |
1390 | } | |
1391 | ||
1392 | fn size_hint(&self) -> Option<usize> { | |
1393 | if self.0.is_some() { | |
1394 | Some(2) | |
1395 | } else if self.1.is_some() { | |
1396 | Some(1) | |
1397 | } else { | |
1398 | Some(0) | |
1399 | } | |
1400 | } | |
1401 | } | |
1402 | ||
1403 | struct ExpectedInMap(usize); | |
1404 | ||
1405 | impl Expected for ExpectedInMap { | |
1406 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
1407 | if self.0 == 1 { | |
1408 | write!(formatter, "1 element in map") | |
1409 | } else { | |
1410 | write!(formatter, "{} elements in map", self.0) | |
1411 | } | |
1412 | } | |
1413 | } | |
1414 | ||
1415 | //////////////////////////////////////////////////////////////////////////////// | |
1416 | ||
1417 | #[cfg(any(feature = "std", feature = "alloc"))] | |
1418 | impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> | |
1419 | where | |
1420 | K: IntoDeserializer<'de, E> + Eq + Ord, | |
1421 | V: IntoDeserializer<'de, E>, | |
1422 | E: de::Error, | |
1423 | { | |
abe05a73 | 1424 | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1425 | |
1426 | fn into_deserializer(self) -> Self::Deserializer { | |
1427 | MapDeserializer::new(self.into_iter()) | |
1428 | } | |
1429 | } | |
1430 | ||
1431 | #[cfg(feature = "std")] | |
abe05a73 | 1432 | impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S> |
041b39d2 XL |
1433 | where |
1434 | K: IntoDeserializer<'de, E> + Eq + Hash, | |
1435 | V: IntoDeserializer<'de, E>, | |
abe05a73 | 1436 | S: BuildHasher, |
041b39d2 XL |
1437 | E: de::Error, |
1438 | { | |
abe05a73 | 1439 | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1440 | |
1441 | fn into_deserializer(self) -> Self::Deserializer { | |
1442 | MapDeserializer::new(self.into_iter()) | |
1443 | } | |
1444 | } | |
1445 | ||
1446 | //////////////////////////////////////////////////////////////////////////////// | |
1447 | ||
1448 | /// A deserializer holding a `MapAccess`. | |
1449 | #[derive(Clone, Debug)] | |
1450 | pub struct MapAccessDeserializer<A> { | |
1451 | map: A, | |
1452 | } | |
1453 | ||
1454 | impl<A> MapAccessDeserializer<A> { | |
1455 | /// Construct a new `MapAccessDeserializer<A>`. | |
1456 | pub fn new(map: A) -> Self { | |
1457 | MapAccessDeserializer { map: map } | |
1458 | } | |
1459 | } | |
1460 | ||
1461 | impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> | |
1462 | where | |
1463 | A: de::MapAccess<'de>, | |
1464 | { | |
1465 | type Error = A::Error; | |
1466 | ||
1467 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1468 | where | |
1469 | V: de::Visitor<'de>, | |
1470 | { | |
1471 | visitor.visit_map(self.map) | |
1472 | } | |
1473 | ||
dc9dc135 XL |
1474 | fn deserialize_enum<V>( |
1475 | self, | |
1476 | _name: &str, | |
1477 | _variants: &'static [&'static str], | |
1478 | visitor: V, | |
1479 | ) -> Result<V::Value, Self::Error> | |
1480 | where | |
1481 | V: de::Visitor<'de>, | |
1482 | { | |
1483 | visitor.visit_enum(self) | |
1484 | } | |
1485 | ||
041b39d2 | 1486 | forward_to_deserialize_any! { |
8faf50e0 XL |
1487 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
1488 | bytes byte_buf option unit unit_struct newtype_struct seq tuple | |
dc9dc135 XL |
1489 | tuple_struct map struct identifier ignored_any |
1490 | } | |
1491 | } | |
1492 | ||
1493 | impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A> | |
1494 | where | |
1495 | A: de::MapAccess<'de>, | |
1496 | { | |
1497 | type Error = A::Error; | |
1498 | type Variant = private::MapAsEnum<A>; | |
1499 | ||
1500 | fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
1501 | where | |
1502 | T: de::DeserializeSeed<'de>, | |
1503 | { | |
1504 | match self.map.next_key_seed(seed)? { | |
1505 | Some(key) => Ok((key, private::map_as_enum(self.map))), | |
1506 | None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")), | |
1507 | } | |
041b39d2 XL |
1508 | } |
1509 | } | |
1510 | ||
1511 | //////////////////////////////////////////////////////////////////////////////// | |
1512 | ||
1513 | mod private { | |
1514 | use lib::*; | |
1515 | ||
dc9dc135 | 1516 | use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor}; |
041b39d2 | 1517 | |
041b39d2 XL |
1518 | pub struct UnitOnly<E> { |
1519 | marker: PhantomData<E>, | |
1520 | } | |
1521 | ||
1522 | pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) { | |
ff7c6d11 XL |
1523 | ( |
1524 | t, | |
1525 | UnitOnly { | |
1526 | marker: PhantomData, | |
1527 | }, | |
1528 | ) | |
041b39d2 XL |
1529 | } |
1530 | ||
1531 | impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> | |
1532 | where | |
1533 | E: de::Error, | |
1534 | { | |
1535 | type Error = E; | |
1536 | ||
1537 | fn unit_variant(self) -> Result<(), Self::Error> { | |
1538 | Ok(()) | |
1539 | } | |
1540 | ||
1541 | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> | |
1542 | where | |
1543 | T: de::DeserializeSeed<'de>, | |
1544 | { | |
ff7c6d11 XL |
1545 | Err(de::Error::invalid_type( |
1546 | Unexpected::UnitVariant, | |
1547 | &"newtype variant", | |
1548 | )) | |
041b39d2 XL |
1549 | } |
1550 | ||
1551 | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> | |
1552 | where | |
1553 | V: de::Visitor<'de>, | |
1554 | { | |
ff7c6d11 XL |
1555 | Err(de::Error::invalid_type( |
1556 | Unexpected::UnitVariant, | |
1557 | &"tuple variant", | |
1558 | )) | |
041b39d2 XL |
1559 | } |
1560 | ||
1561 | fn struct_variant<V>( | |
1562 | self, | |
1563 | _fields: &'static [&'static str], | |
1564 | _visitor: V, | |
1565 | ) -> Result<V::Value, Self::Error> | |
1566 | where | |
1567 | V: de::Visitor<'de>, | |
1568 | { | |
ff7c6d11 XL |
1569 | Err(de::Error::invalid_type( |
1570 | Unexpected::UnitVariant, | |
1571 | &"struct variant", | |
1572 | )) | |
041b39d2 XL |
1573 | } |
1574 | } | |
1575 | ||
dc9dc135 XL |
1576 | pub struct MapAsEnum<A> { |
1577 | map: A, | |
1578 | } | |
1579 | ||
1580 | pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> { | |
1581 | MapAsEnum { map: map } | |
1582 | } | |
1583 | ||
1584 | impl<'de, A> VariantAccess<'de> for MapAsEnum<A> | |
1585 | where | |
1586 | A: MapAccess<'de>, | |
1587 | { | |
1588 | type Error = A::Error; | |
1589 | ||
1590 | fn unit_variant(mut self) -> Result<(), Self::Error> { | |
1591 | self.map.next_value() | |
1592 | } | |
1593 | ||
1594 | fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error> | |
1595 | where | |
1596 | T: DeserializeSeed<'de>, | |
1597 | { | |
1598 | self.map.next_value_seed(seed) | |
1599 | } | |
1600 | ||
1601 | fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error> | |
1602 | where | |
1603 | V: Visitor<'de>, | |
1604 | { | |
1605 | self.map.next_value_seed(SeedTupleVariant { | |
1606 | len: len, | |
1607 | visitor: visitor, | |
1608 | }) | |
1609 | } | |
1610 | ||
1611 | fn struct_variant<V>( | |
1612 | mut self, | |
1613 | _fields: &'static [&'static str], | |
1614 | visitor: V, | |
1615 | ) -> Result<V::Value, Self::Error> | |
1616 | where | |
1617 | V: Visitor<'de>, | |
1618 | { | |
1619 | self.map | |
1620 | .next_value_seed(SeedStructVariant { visitor: visitor }) | |
1621 | } | |
1622 | } | |
1623 | ||
1624 | struct SeedTupleVariant<V> { | |
1625 | len: usize, | |
1626 | visitor: V, | |
1627 | } | |
1628 | ||
1629 | impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V> | |
1630 | where | |
1631 | V: Visitor<'de>, | |
1632 | { | |
1633 | type Value = V::Value; | |
1634 | ||
1635 | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> | |
1636 | where | |
1637 | D: Deserializer<'de>, | |
1638 | { | |
1639 | deserializer.deserialize_tuple(self.len, self.visitor) | |
1640 | } | |
1641 | } | |
1642 | ||
1643 | struct SeedStructVariant<V> { | |
1644 | visitor: V, | |
1645 | } | |
1646 | ||
1647 | impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V> | |
1648 | where | |
1649 | V: Visitor<'de>, | |
1650 | { | |
1651 | type Value = V::Value; | |
1652 | ||
1653 | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> | |
1654 | where | |
1655 | D: Deserializer<'de>, | |
1656 | { | |
1657 | deserializer.deserialize_map(self.visitor) | |
1658 | } | |
1659 | } | |
1660 | ||
041b39d2 XL |
1661 | /// Avoid having to restate the generic types on `MapDeserializer`. The |
1662 | /// `Iterator::Item` contains enough information to figure out K and V. | |
1663 | pub trait Pair { | |
1664 | type First; | |
1665 | type Second; | |
1666 | fn split(self) -> (Self::First, Self::Second); | |
1667 | } | |
1668 | ||
1669 | impl<A, B> Pair for (A, B) { | |
1670 | type First = A; | |
1671 | type Second = B; | |
1672 | fn split(self) -> (A, B) { | |
1673 | self | |
1674 | } | |
1675 | } | |
1676 | ||
1677 | pub type First<T> = <T as Pair>::First; | |
1678 | pub type Second<T> = <T as Pair>::Second; | |
1679 | } |