]>
Commit | Line | Data |
---|---|---|
041b39d2 XL |
1 | // Copyright 2017 Serde Developers |
2 | // | |
3 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
4 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
5 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
6 | // option. This file may not be copied, modified, or distributed | |
7 | // except according to those terms. | |
8 | ||
9 | //! Building blocks for deserializing basic values using the `IntoDeserializer` | |
10 | //! trait. | |
11 | //! | |
12 | //! ```rust | |
13 | //! #[macro_use] | |
14 | //! extern crate serde_derive; | |
15 | //! | |
16 | //! extern crate serde; | |
17 | //! | |
18 | //! use std::str::FromStr; | |
19 | //! use serde::de::{value, Deserialize, IntoDeserializer}; | |
20 | //! | |
21 | //! #[derive(Deserialize)] | |
22 | //! enum Setting { | |
23 | //! On, | |
24 | //! Off, | |
25 | //! } | |
26 | //! | |
27 | //! impl FromStr for Setting { | |
28 | //! type Err = value::Error; | |
29 | //! | |
30 | //! fn from_str(s: &str) -> Result<Self, Self::Err> { | |
31 | //! Self::deserialize(s.into_deserializer()) | |
32 | //! } | |
33 | //! } | |
34 | //! # | |
35 | //! # fn main() {} | |
36 | //! ``` | |
37 | ||
38 | use lib::*; | |
39 | ||
40 | use de::{self, IntoDeserializer, Expected, SeqAccess}; | |
41 | use private::de::size_hint; | |
42 | use ser; | |
43 | use self::private::{First, Second}; | |
44 | ||
45 | //////////////////////////////////////////////////////////////////////////////// | |
46 | ||
47 | /// A minimal representation of all possible errors that can occur using the | |
48 | /// `IntoDeserializer` trait. | |
49 | #[derive(Clone, Debug, PartialEq)] | |
50 | pub struct Error { | |
51 | err: ErrorImpl, | |
52 | } | |
53 | ||
54 | #[cfg(any(feature = "std", feature = "alloc"))] | |
55 | type ErrorImpl = Box<str>; | |
56 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
57 | type ErrorImpl = (); | |
58 | ||
59 | impl de::Error for Error { | |
60 | #[cfg(any(feature = "std", feature = "alloc"))] | |
61 | fn custom<T>(msg: T) -> Self | |
62 | where | |
63 | T: Display, | |
64 | { | |
65 | Error { err: msg.to_string().into_boxed_str() } | |
66 | } | |
67 | ||
68 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
69 | fn custom<T>(msg: T) -> Self | |
70 | where | |
71 | T: Display, | |
72 | { | |
73 | let _ = msg; | |
74 | Error { err: () } | |
75 | } | |
76 | } | |
77 | ||
78 | impl ser::Error for Error { | |
79 | fn custom<T>(msg: T) -> Self | |
80 | where | |
81 | T: Display, | |
82 | { | |
83 | de::Error::custom(msg) | |
84 | } | |
85 | } | |
86 | ||
87 | impl Display for Error { | |
88 | #[cfg(any(feature = "std", feature = "alloc"))] | |
89 | fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { | |
90 | formatter.write_str(&self.err) | |
91 | } | |
92 | ||
93 | #[cfg(not(any(feature = "std", feature = "alloc")))] | |
94 | fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { | |
95 | formatter.write_str("Serde deserialization error") | |
96 | } | |
97 | } | |
98 | ||
99 | #[cfg(feature = "std")] | |
100 | impl error::Error for Error { | |
101 | fn description(&self) -> &str { | |
102 | &self.err | |
103 | } | |
104 | } | |
105 | ||
106 | //////////////////////////////////////////////////////////////////////////////// | |
107 | ||
108 | impl<'de, E> IntoDeserializer<'de, E> for () | |
109 | where | |
110 | E: de::Error, | |
111 | { | |
112 | type Deserializer = UnitDeserializer<E>; | |
113 | ||
114 | fn into_deserializer(self) -> UnitDeserializer<E> { | |
115 | UnitDeserializer { marker: PhantomData } | |
116 | } | |
117 | } | |
118 | ||
119 | /// A deserializer holding a `()`. | |
120 | #[derive(Clone, Debug)] | |
121 | pub struct UnitDeserializer<E> { | |
122 | marker: PhantomData<E>, | |
123 | } | |
124 | ||
125 | impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> | |
126 | where | |
127 | E: de::Error, | |
128 | { | |
129 | type Error = E; | |
130 | ||
131 | forward_to_deserialize_any! { | |
132 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
133 | byte_buf unit unit_struct newtype_struct seq tuple tuple_struct map | |
134 | struct enum identifier ignored_any | |
135 | } | |
136 | ||
137 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
138 | where | |
139 | V: de::Visitor<'de>, | |
140 | { | |
141 | visitor.visit_unit() | |
142 | } | |
143 | ||
144 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
145 | where | |
146 | V: de::Visitor<'de>, | |
147 | { | |
148 | visitor.visit_none() | |
149 | } | |
150 | } | |
151 | ||
152 | //////////////////////////////////////////////////////////////////////////////// | |
153 | ||
154 | macro_rules! primitive_deserializer { | |
155 | ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => { | |
156 | #[doc = "A deserializer holding"] | |
157 | #[doc = $doc] | |
158 | #[derive(Clone, Debug)] | |
159 | pub struct $name<E> { | |
160 | value: $ty, | |
161 | marker: PhantomData<E> | |
162 | } | |
163 | ||
164 | impl<'de, E> IntoDeserializer<'de, E> for $ty | |
165 | where | |
166 | E: de::Error, | |
167 | { | |
168 | type Deserializer = $name<E>; | |
169 | ||
170 | fn into_deserializer(self) -> $name<E> { | |
171 | $name { | |
172 | value: self, | |
173 | marker: PhantomData, | |
174 | } | |
175 | } | |
176 | } | |
177 | ||
178 | impl<'de, E> de::Deserializer<'de> for $name<E> | |
179 | where | |
180 | E: de::Error, | |
181 | { | |
182 | type Error = E; | |
183 | ||
184 | forward_to_deserialize_any! { | |
185 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
186 | byte_buf option unit unit_struct newtype_struct seq tuple | |
187 | tuple_struct map struct enum identifier ignored_any | |
188 | } | |
189 | ||
190 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
191 | where | |
192 | V: de::Visitor<'de>, | |
193 | { | |
194 | visitor.$method(self.value $($cast)*) | |
195 | } | |
196 | } | |
197 | } | |
198 | } | |
199 | ||
200 | primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool); | |
201 | primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8); | |
202 | primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16); | |
203 | primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32); | |
204 | primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64); | |
205 | primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64); | |
206 | primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8); | |
207 | primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16); | |
208 | primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64); | |
209 | primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64); | |
210 | primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32); | |
211 | primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64); | |
212 | primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char); | |
213 | ||
214 | /// A deserializer holding a `u32`. | |
215 | #[derive(Clone, Debug)] | |
216 | pub struct U32Deserializer<E> { | |
217 | value: u32, | |
218 | marker: PhantomData<E>, | |
219 | } | |
220 | ||
221 | impl<'de, E> IntoDeserializer<'de, E> for u32 | |
222 | where | |
223 | E: de::Error, | |
224 | { | |
225 | type Deserializer = U32Deserializer<E>; | |
226 | ||
227 | fn into_deserializer(self) -> U32Deserializer<E> { | |
228 | U32Deserializer { | |
229 | value: self, | |
230 | marker: PhantomData, | |
231 | } | |
232 | } | |
233 | } | |
234 | ||
235 | impl<'de, E> de::Deserializer<'de> for U32Deserializer<E> | |
236 | where | |
237 | E: de::Error, | |
238 | { | |
239 | type Error = E; | |
240 | ||
241 | forward_to_deserialize_any! { | |
242 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
243 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
244 | map struct identifier ignored_any | |
245 | } | |
246 | ||
247 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
248 | where | |
249 | V: de::Visitor<'de>, | |
250 | { | |
251 | visitor.visit_u32(self.value) | |
252 | } | |
253 | ||
254 | fn deserialize_enum<V>( | |
255 | self, | |
256 | name: &str, | |
257 | variants: &'static [&'static str], | |
258 | visitor: V, | |
259 | ) -> Result<V::Value, Self::Error> | |
260 | where | |
261 | V: de::Visitor<'de>, | |
262 | { | |
263 | let _ = name; | |
264 | let _ = variants; | |
265 | visitor.visit_enum(self) | |
266 | } | |
267 | } | |
268 | ||
269 | impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E> | |
270 | where | |
271 | E: de::Error, | |
272 | { | |
273 | type Error = E; | |
274 | type Variant = private::UnitOnly<E>; | |
275 | ||
276 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
277 | where | |
278 | T: de::DeserializeSeed<'de>, | |
279 | { | |
280 | seed.deserialize(self).map(private::unit_only) | |
281 | } | |
282 | } | |
283 | ||
284 | //////////////////////////////////////////////////////////////////////////////// | |
285 | ||
286 | /// A deserializer holding a `&str`. | |
287 | #[derive(Clone, Debug)] | |
288 | pub struct StrDeserializer<'a, E> { | |
289 | value: &'a str, | |
290 | marker: PhantomData<E>, | |
291 | } | |
292 | ||
293 | impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str | |
294 | where | |
295 | E: de::Error, | |
296 | { | |
297 | type Deserializer = StrDeserializer<'a, E>; | |
298 | ||
299 | fn into_deserializer(self) -> StrDeserializer<'a, E> { | |
300 | StrDeserializer { | |
301 | value: self, | |
302 | marker: PhantomData, | |
303 | } | |
304 | } | |
305 | } | |
306 | ||
307 | impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E> | |
308 | where | |
309 | E: de::Error, | |
310 | { | |
311 | type Error = E; | |
312 | ||
313 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
314 | where | |
315 | V: de::Visitor<'de>, | |
316 | { | |
317 | visitor.visit_str(self.value) | |
318 | } | |
319 | ||
320 | fn deserialize_enum<V>( | |
321 | self, | |
322 | name: &str, | |
323 | variants: &'static [&'static str], | |
324 | visitor: V, | |
325 | ) -> Result<V::Value, Self::Error> | |
326 | where | |
327 | V: de::Visitor<'de>, | |
328 | { | |
329 | let _ = name; | |
330 | let _ = variants; | |
331 | visitor.visit_enum(self) | |
332 | } | |
333 | ||
334 | forward_to_deserialize_any! { | |
335 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
336 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
337 | map struct identifier ignored_any | |
338 | } | |
339 | } | |
340 | ||
341 | impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> | |
342 | where | |
343 | E: de::Error, | |
344 | { | |
345 | type Error = E; | |
346 | type Variant = private::UnitOnly<E>; | |
347 | ||
348 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
349 | where | |
350 | T: de::DeserializeSeed<'de>, | |
351 | { | |
352 | seed.deserialize(self).map(private::unit_only) | |
353 | } | |
354 | } | |
355 | ||
356 | //////////////////////////////////////////////////////////////////////////////// | |
357 | ||
358 | /// A deserializer holding a `&str` with a lifetime tied to another | |
359 | /// deserializer. | |
360 | #[derive(Clone, Debug)] | |
361 | pub struct BorrowedStrDeserializer<'de, E> { | |
362 | value: &'de str, | |
363 | marker: PhantomData<E>, | |
364 | } | |
365 | ||
366 | impl<'de, E> BorrowedStrDeserializer<'de, E> { | |
367 | /// Create a new borrowed deserializer from the given string. | |
368 | pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> { | |
369 | BorrowedStrDeserializer { | |
370 | value: value, | |
371 | marker: PhantomData, | |
372 | } | |
373 | } | |
374 | } | |
375 | ||
376 | impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E> | |
377 | where | |
378 | E: de::Error, | |
379 | { | |
380 | type Error = E; | |
381 | ||
382 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
383 | where | |
384 | V: de::Visitor<'de>, | |
385 | { | |
386 | visitor.visit_borrowed_str(self.value) | |
387 | } | |
388 | ||
389 | fn deserialize_enum<V>( | |
390 | self, | |
391 | name: &str, | |
392 | variants: &'static [&'static str], | |
393 | visitor: V, | |
394 | ) -> Result<V::Value, Self::Error> | |
395 | where | |
396 | V: de::Visitor<'de>, | |
397 | { | |
398 | let _ = name; | |
399 | let _ = variants; | |
400 | visitor.visit_enum(self) | |
401 | } | |
402 | ||
403 | forward_to_deserialize_any! { | |
404 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
405 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
406 | map struct identifier ignored_any | |
407 | } | |
408 | } | |
409 | ||
410 | impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E> | |
411 | where | |
412 | E: de::Error, | |
413 | { | |
414 | type Error = E; | |
415 | type Variant = private::UnitOnly<E>; | |
416 | ||
417 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
418 | where | |
419 | T: de::DeserializeSeed<'de>, | |
420 | { | |
421 | seed.deserialize(self).map(private::unit_only) | |
422 | } | |
423 | } | |
424 | ||
425 | //////////////////////////////////////////////////////////////////////////////// | |
426 | ||
427 | /// A deserializer holding a `String`. | |
428 | #[cfg(any(feature = "std", feature = "alloc"))] | |
429 | #[derive(Clone, Debug)] | |
430 | pub struct StringDeserializer<E> { | |
431 | value: String, | |
432 | marker: PhantomData<E>, | |
433 | } | |
434 | ||
435 | #[cfg(any(feature = "std", feature = "alloc"))] | |
436 | impl<'de, E> IntoDeserializer<'de, E> for String | |
437 | where | |
438 | E: de::Error, | |
439 | { | |
440 | type Deserializer = StringDeserializer<E>; | |
441 | ||
442 | fn into_deserializer(self) -> StringDeserializer<E> { | |
443 | StringDeserializer { | |
444 | value: self, | |
445 | marker: PhantomData, | |
446 | } | |
447 | } | |
448 | } | |
449 | ||
450 | #[cfg(any(feature = "std", feature = "alloc"))] | |
451 | impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> | |
452 | where | |
453 | E: de::Error, | |
454 | { | |
455 | type Error = E; | |
456 | ||
457 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
458 | where | |
459 | V: de::Visitor<'de>, | |
460 | { | |
461 | visitor.visit_string(self.value) | |
462 | } | |
463 | ||
464 | fn deserialize_enum<V>( | |
465 | self, | |
466 | name: &str, | |
467 | variants: &'static [&'static str], | |
468 | visitor: V, | |
469 | ) -> Result<V::Value, Self::Error> | |
470 | where | |
471 | V: de::Visitor<'de>, | |
472 | { | |
473 | let _ = name; | |
474 | let _ = variants; | |
475 | visitor.visit_enum(self) | |
476 | } | |
477 | ||
478 | forward_to_deserialize_any! { | |
479 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
480 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
481 | map struct identifier ignored_any | |
482 | } | |
483 | } | |
484 | ||
485 | #[cfg(any(feature = "std", feature = "alloc"))] | |
486 | impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E> | |
487 | where | |
488 | E: de::Error, | |
489 | { | |
490 | type Error = E; | |
491 | type Variant = private::UnitOnly<E>; | |
492 | ||
493 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
494 | where | |
495 | T: de::DeserializeSeed<'de>, | |
496 | { | |
497 | seed.deserialize(self).map(private::unit_only) | |
498 | } | |
499 | } | |
500 | ||
501 | //////////////////////////////////////////////////////////////////////////////// | |
502 | ||
503 | /// A deserializer holding a `Cow<str>`. | |
504 | #[cfg(any(feature = "std", feature = "alloc"))] | |
505 | #[derive(Clone, Debug)] | |
506 | pub struct CowStrDeserializer<'a, E> { | |
507 | value: Cow<'a, str>, | |
508 | marker: PhantomData<E>, | |
509 | } | |
510 | ||
511 | #[cfg(any(feature = "std", feature = "alloc"))] | |
512 | impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> | |
513 | where | |
514 | E: de::Error, | |
515 | { | |
516 | type Deserializer = CowStrDeserializer<'a, E>; | |
517 | ||
518 | fn into_deserializer(self) -> CowStrDeserializer<'a, E> { | |
519 | CowStrDeserializer { | |
520 | value: self, | |
521 | marker: PhantomData, | |
522 | } | |
523 | } | |
524 | } | |
525 | ||
526 | #[cfg(any(feature = "std", feature = "alloc"))] | |
527 | impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E> | |
528 | where | |
529 | E: de::Error, | |
530 | { | |
531 | type Error = E; | |
532 | ||
533 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
534 | where | |
535 | V: de::Visitor<'de>, | |
536 | { | |
537 | match self.value { | |
538 | Cow::Borrowed(string) => visitor.visit_str(string), | |
539 | Cow::Owned(string) => visitor.visit_string(string), | |
540 | } | |
541 | } | |
542 | ||
543 | fn deserialize_enum<V>( | |
544 | self, | |
545 | name: &str, | |
546 | variants: &'static [&'static str], | |
547 | visitor: V, | |
548 | ) -> Result<V::Value, Self::Error> | |
549 | where | |
550 | V: de::Visitor<'de>, | |
551 | { | |
552 | let _ = name; | |
553 | let _ = variants; | |
554 | visitor.visit_enum(self) | |
555 | } | |
556 | ||
557 | forward_to_deserialize_any! { | |
558 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
559 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
560 | map struct identifier ignored_any | |
561 | } | |
562 | } | |
563 | ||
564 | #[cfg(any(feature = "std", feature = "alloc"))] | |
565 | impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E> | |
566 | where | |
567 | E: de::Error, | |
568 | { | |
569 | type Error = E; | |
570 | type Variant = private::UnitOnly<E>; | |
571 | ||
572 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> | |
573 | where | |
574 | T: de::DeserializeSeed<'de>, | |
575 | { | |
576 | seed.deserialize(self).map(private::unit_only) | |
577 | } | |
578 | } | |
579 | ||
580 | //////////////////////////////////////////////////////////////////////////////// | |
581 | ||
582 | /// A deserializer holding a `&[u8]` with a lifetime tied to another | |
583 | /// deserializer. | |
584 | #[derive(Clone, Debug)] | |
585 | pub struct BorrowedBytesDeserializer<'de, E> { | |
586 | value: &'de [u8], | |
587 | marker: PhantomData<E>, | |
588 | } | |
589 | ||
590 | impl<'de, E> BorrowedBytesDeserializer<'de, E> { | |
591 | /// Create a new borrowed deserializer from the given byte slice. | |
592 | pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> { | |
593 | BorrowedBytesDeserializer { | |
594 | value: value, | |
595 | marker: PhantomData, | |
596 | } | |
597 | } | |
598 | } | |
599 | ||
600 | impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E> | |
601 | where | |
602 | E: de::Error, | |
603 | { | |
604 | type Error = E; | |
605 | ||
606 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
607 | where | |
608 | V: de::Visitor<'de>, | |
609 | { | |
610 | visitor.visit_borrowed_bytes(self.value) | |
611 | } | |
612 | ||
613 | forward_to_deserialize_any! { | |
614 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
615 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
616 | map struct identifier ignored_any enum | |
617 | } | |
618 | } | |
619 | ||
620 | //////////////////////////////////////////////////////////////////////////////// | |
621 | ||
622 | /// A deserializer that iterates over a sequence. | |
623 | #[derive(Clone, Debug)] | |
624 | pub struct SeqDeserializer<I, E> { | |
625 | iter: iter::Fuse<I>, | |
626 | count: usize, | |
627 | marker: PhantomData<E>, | |
628 | } | |
629 | ||
630 | impl<I, E> SeqDeserializer<I, E> | |
631 | where | |
632 | I: Iterator, | |
633 | { | |
634 | /// Construct a new `SeqDeserializer<I, E>`. | |
635 | pub fn new(iter: I) -> Self { | |
636 | SeqDeserializer { | |
637 | iter: iter.fuse(), | |
638 | count: 0, | |
639 | marker: PhantomData, | |
640 | } | |
641 | } | |
642 | } | |
643 | ||
644 | impl<I, E> SeqDeserializer<I, E> | |
645 | where | |
646 | I: Iterator, | |
647 | E: de::Error, | |
648 | { | |
649 | /// Check for remaining elements after passing a `SeqDeserializer` to | |
650 | /// `Visitor::visit_seq`. | |
651 | pub fn end(mut self) -> Result<(), E> { | |
652 | let mut remaining = 0; | |
653 | while self.iter.next().is_some() { | |
654 | remaining += 1; | |
655 | } | |
656 | if remaining == 0 { | |
657 | Ok(()) | |
658 | } else { | |
659 | // First argument is the number of elements in the data, second | |
660 | // argument is the number of elements expected by the Deserialize. | |
661 | Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)),) | |
662 | } | |
663 | } | |
664 | } | |
665 | ||
666 | impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E> | |
667 | where | |
668 | I: Iterator<Item = T>, | |
669 | T: IntoDeserializer<'de, E>, | |
670 | E: de::Error, | |
671 | { | |
672 | type Error = E; | |
673 | ||
674 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
675 | where | |
676 | V: de::Visitor<'de>, | |
677 | { | |
678 | let v = try!(visitor.visit_seq(&mut self)); | |
679 | try!(self.end()); | |
680 | Ok(v) | |
681 | } | |
682 | ||
683 | forward_to_deserialize_any! { | |
684 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
685 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
686 | map struct enum identifier ignored_any | |
687 | } | |
688 | } | |
689 | ||
690 | impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> | |
691 | where | |
692 | I: Iterator<Item = T>, | |
693 | T: IntoDeserializer<'de, E>, | |
694 | E: de::Error, | |
695 | { | |
696 | type Error = E; | |
697 | ||
698 | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> | |
699 | where | |
700 | V: de::DeserializeSeed<'de>, | |
701 | { | |
702 | match self.iter.next() { | |
703 | Some(value) => { | |
704 | self.count += 1; | |
705 | seed.deserialize(value.into_deserializer()).map(Some) | |
706 | } | |
707 | None => Ok(None), | |
708 | } | |
709 | } | |
710 | ||
711 | fn size_hint(&self) -> Option<usize> { | |
712 | size_hint::from_bounds(&self.iter) | |
713 | } | |
714 | } | |
715 | ||
716 | struct ExpectedInSeq(usize); | |
717 | ||
718 | impl Expected for ExpectedInSeq { | |
719 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
720 | if self.0 == 1 { | |
721 | write!(formatter, "1 element in sequence") | |
722 | } else { | |
723 | write!(formatter, "{} elements in sequence", self.0) | |
724 | } | |
725 | } | |
726 | } | |
727 | ||
728 | //////////////////////////////////////////////////////////////////////////////// | |
729 | ||
730 | #[cfg(any(feature = "std", feature = "alloc"))] | |
731 | impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> | |
732 | where | |
733 | T: IntoDeserializer<'de, E>, | |
734 | E: de::Error, | |
735 | { | |
abe05a73 | 736 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
737 | |
738 | fn into_deserializer(self) -> Self::Deserializer { | |
739 | SeqDeserializer::new(self.into_iter()) | |
740 | } | |
741 | } | |
742 | ||
743 | #[cfg(any(feature = "std", feature = "alloc"))] | |
744 | impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> | |
745 | where | |
746 | T: IntoDeserializer<'de, E> + Eq + Ord, | |
747 | E: de::Error, | |
748 | { | |
abe05a73 | 749 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
750 | |
751 | fn into_deserializer(self) -> Self::Deserializer { | |
752 | SeqDeserializer::new(self.into_iter()) | |
753 | } | |
754 | } | |
755 | ||
756 | #[cfg(feature = "std")] | |
abe05a73 | 757 | impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> |
041b39d2 XL |
758 | where |
759 | T: IntoDeserializer<'de, E> + Eq + Hash, | |
abe05a73 | 760 | S: BuildHasher, |
041b39d2 XL |
761 | E: de::Error, |
762 | { | |
abe05a73 | 763 | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
764 | |
765 | fn into_deserializer(self) -> Self::Deserializer { | |
766 | SeqDeserializer::new(self.into_iter()) | |
767 | } | |
768 | } | |
769 | ||
770 | //////////////////////////////////////////////////////////////////////////////// | |
771 | ||
772 | /// A deserializer holding a `SeqAccess`. | |
773 | #[derive(Clone, Debug)] | |
774 | pub struct SeqAccessDeserializer<A> { | |
775 | seq: A, | |
776 | } | |
777 | ||
778 | impl<A> SeqAccessDeserializer<A> { | |
779 | /// Construct a new `SeqAccessDeserializer<A>`. | |
780 | pub fn new(seq: A) -> Self { | |
781 | SeqAccessDeserializer { seq: seq } | |
782 | } | |
783 | } | |
784 | ||
785 | impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> | |
786 | where | |
787 | A: de::SeqAccess<'de>, | |
788 | { | |
789 | type Error = A::Error; | |
790 | ||
791 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
792 | where | |
793 | V: de::Visitor<'de>, | |
794 | { | |
795 | visitor.visit_seq(self.seq) | |
796 | } | |
797 | ||
798 | forward_to_deserialize_any! { | |
799 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
800 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
801 | map struct enum identifier ignored_any | |
802 | } | |
803 | } | |
804 | ||
805 | //////////////////////////////////////////////////////////////////////////////// | |
806 | ||
807 | /// A deserializer that iterates over a map. | |
808 | pub struct MapDeserializer<'de, I, E> | |
809 | where | |
810 | I: Iterator, | |
811 | I::Item: private::Pair, | |
812 | { | |
813 | iter: iter::Fuse<I>, | |
814 | value: Option<Second<I::Item>>, | |
815 | count: usize, | |
816 | lifetime: PhantomData<&'de ()>, | |
817 | error: PhantomData<E>, | |
818 | } | |
819 | ||
820 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
821 | where | |
822 | I: Iterator, | |
823 | I::Item: private::Pair, | |
824 | { | |
825 | /// Construct a new `MapDeserializer<I, E>`. | |
826 | pub fn new(iter: I) -> Self { | |
827 | MapDeserializer { | |
828 | iter: iter.fuse(), | |
829 | value: None, | |
830 | count: 0, | |
831 | lifetime: PhantomData, | |
832 | error: PhantomData, | |
833 | } | |
834 | } | |
835 | } | |
836 | ||
837 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
838 | where | |
839 | I: Iterator, | |
840 | I::Item: private::Pair, | |
841 | E: de::Error, | |
842 | { | |
843 | /// Check for remaining elements after passing a `MapDeserializer` to | |
844 | /// `Visitor::visit_map`. | |
845 | pub fn end(mut self) -> Result<(), E> { | |
846 | let mut remaining = 0; | |
847 | while self.iter.next().is_some() { | |
848 | remaining += 1; | |
849 | } | |
850 | if remaining == 0 { | |
851 | Ok(()) | |
852 | } else { | |
853 | // First argument is the number of elements in the data, second | |
854 | // argument is the number of elements expected by the Deserialize. | |
855 | Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)),) | |
856 | } | |
857 | } | |
858 | } | |
859 | ||
860 | impl<'de, I, E> MapDeserializer<'de, I, E> | |
861 | where | |
862 | I: Iterator, | |
863 | I::Item: private::Pair, | |
864 | { | |
865 | fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> { | |
866 | match self.iter.next() { | |
867 | Some(kv) => { | |
868 | self.count += 1; | |
869 | Some(private::Pair::split(kv)) | |
870 | } | |
871 | None => None, | |
872 | } | |
873 | } | |
874 | } | |
875 | ||
876 | impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E> | |
877 | where | |
878 | I: Iterator, | |
879 | I::Item: private::Pair, | |
880 | First<I::Item>: IntoDeserializer<'de, E>, | |
881 | Second<I::Item>: IntoDeserializer<'de, E>, | |
882 | E: de::Error, | |
883 | { | |
884 | type Error = E; | |
885 | ||
886 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
887 | where | |
888 | V: de::Visitor<'de>, | |
889 | { | |
890 | let value = try!(visitor.visit_map(&mut self)); | |
891 | try!(self.end()); | |
892 | Ok(value) | |
893 | } | |
894 | ||
895 | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> | |
896 | where | |
897 | V: de::Visitor<'de>, | |
898 | { | |
899 | let value = try!(visitor.visit_seq(&mut self)); | |
900 | try!(self.end()); | |
901 | Ok(value) | |
902 | } | |
903 | ||
904 | fn deserialize_tuple<V>( | |
905 | self, | |
906 | len: usize, | |
907 | visitor: V, | |
908 | ) -> Result<V::Value, Self::Error> | |
909 | where | |
910 | V: de::Visitor<'de>, | |
911 | { | |
912 | let _ = len; | |
913 | self.deserialize_seq(visitor) | |
914 | } | |
915 | ||
916 | forward_to_deserialize_any! { | |
917 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
918 | byte_buf option unit unit_struct newtype_struct tuple_struct map struct | |
919 | enum identifier ignored_any | |
920 | } | |
921 | } | |
922 | ||
923 | impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E> | |
924 | where | |
925 | I: Iterator, | |
926 | I::Item: private::Pair, | |
927 | First<I::Item>: IntoDeserializer<'de, E>, | |
928 | Second<I::Item>: IntoDeserializer<'de, E>, | |
929 | E: de::Error, | |
930 | { | |
931 | type Error = E; | |
932 | ||
933 | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
934 | where | |
935 | T: de::DeserializeSeed<'de>, | |
936 | { | |
937 | match self.next_pair() { | |
938 | Some((key, value)) => { | |
939 | self.value = Some(value); | |
940 | seed.deserialize(key.into_deserializer()).map(Some) | |
941 | } | |
942 | None => Ok(None), | |
943 | } | |
944 | } | |
945 | ||
946 | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> | |
947 | where | |
948 | T: de::DeserializeSeed<'de>, | |
949 | { | |
950 | let value = self.value.take(); | |
951 | // Panic because this indicates a bug in the program rather than an | |
952 | // expected failure. | |
953 | let value = value.expect("MapAccess::visit_value called before visit_key"); | |
954 | seed.deserialize(value.into_deserializer()) | |
955 | } | |
956 | ||
957 | fn next_entry_seed<TK, TV>( | |
958 | &mut self, | |
959 | kseed: TK, | |
960 | vseed: TV, | |
961 | ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> | |
962 | where | |
963 | TK: de::DeserializeSeed<'de>, | |
964 | TV: de::DeserializeSeed<'de>, | |
965 | { | |
966 | match self.next_pair() { | |
967 | Some((key, value)) => { | |
968 | let key = try!(kseed.deserialize(key.into_deserializer())); | |
969 | let value = try!(vseed.deserialize(value.into_deserializer())); | |
970 | Ok(Some((key, value))) | |
971 | } | |
972 | None => Ok(None), | |
973 | } | |
974 | } | |
975 | ||
976 | fn size_hint(&self) -> Option<usize> { | |
977 | size_hint::from_bounds(&self.iter) | |
978 | } | |
979 | } | |
980 | ||
981 | impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E> | |
982 | where | |
983 | I: Iterator, | |
984 | I::Item: private::Pair, | |
985 | First<I::Item>: IntoDeserializer<'de, E>, | |
986 | Second<I::Item>: IntoDeserializer<'de, E>, | |
987 | E: de::Error, | |
988 | { | |
989 | type Error = E; | |
990 | ||
991 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
992 | where | |
993 | T: de::DeserializeSeed<'de>, | |
994 | { | |
995 | match self.next_pair() { | |
996 | Some((k, v)) => { | |
997 | let de = PairDeserializer(k, v, PhantomData); | |
998 | seed.deserialize(de).map(Some) | |
999 | } | |
1000 | None => Ok(None), | |
1001 | } | |
1002 | } | |
1003 | ||
1004 | fn size_hint(&self) -> Option<usize> { | |
1005 | size_hint::from_bounds(&self.iter) | |
1006 | } | |
1007 | } | |
1008 | ||
1009 | // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`. | |
1010 | impl<'de, I, E> Clone for MapDeserializer<'de, I, E> | |
1011 | where | |
1012 | I: Iterator + Clone, | |
1013 | I::Item: private::Pair, | |
1014 | Second<I::Item>: Clone, | |
1015 | { | |
1016 | fn clone(&self) -> Self { | |
1017 | MapDeserializer { | |
1018 | iter: self.iter.clone(), | |
1019 | value: self.value.clone(), | |
1020 | count: self.count, | |
1021 | lifetime: self.lifetime, | |
1022 | error: self.error, | |
1023 | } | |
1024 | } | |
1025 | } | |
1026 | ||
1027 | // Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`. | |
1028 | impl<'de, I, E> Debug for MapDeserializer<'de, I, E> | |
1029 | where | |
1030 | I: Iterator + Debug, | |
1031 | I::Item: private::Pair, | |
1032 | Second<I::Item>: Debug, | |
1033 | { | |
1034 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
1035 | formatter | |
1036 | .debug_struct("MapDeserializer") | |
1037 | .field("iter", &self.iter) | |
1038 | .field("value", &self.value) | |
1039 | .field("count", &self.count) | |
1040 | .field("lifetime", &self.lifetime) | |
1041 | .field("error", &self.error) | |
1042 | .finish() | |
1043 | } | |
1044 | } | |
1045 | ||
1046 | // Used in the `impl SeqAccess for MapDeserializer` to visit the map as a | |
1047 | // sequence of pairs. | |
1048 | struct PairDeserializer<A, B, E>(A, B, PhantomData<E>); | |
1049 | ||
1050 | impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E> | |
1051 | where | |
1052 | A: IntoDeserializer<'de, E>, | |
1053 | B: IntoDeserializer<'de, E>, | |
1054 | E: de::Error, | |
1055 | { | |
1056 | type Error = E; | |
1057 | ||
1058 | forward_to_deserialize_any! { | |
1059 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
1060 | byte_buf option unit unit_struct newtype_struct tuple_struct map struct | |
1061 | enum identifier ignored_any | |
1062 | } | |
1063 | ||
1064 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1065 | where | |
1066 | V: de::Visitor<'de>, | |
1067 | { | |
1068 | self.deserialize_seq(visitor) | |
1069 | } | |
1070 | ||
1071 | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1072 | where | |
1073 | V: de::Visitor<'de>, | |
1074 | { | |
1075 | let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData); | |
1076 | let pair = try!(visitor.visit_seq(&mut pair_visitor)); | |
1077 | if pair_visitor.1.is_none() { | |
1078 | Ok(pair) | |
1079 | } else { | |
1080 | let remaining = pair_visitor.size_hint().unwrap(); | |
1081 | // First argument is the number of elements in the data, second | |
1082 | // argument is the number of elements expected by the Deserialize. | |
1083 | Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining))) | |
1084 | } | |
1085 | } | |
1086 | ||
1087 | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> | |
1088 | where | |
1089 | V: de::Visitor<'de>, | |
1090 | { | |
1091 | if len == 2 { | |
1092 | self.deserialize_seq(visitor) | |
1093 | } else { | |
1094 | // First argument is the number of elements in the data, second | |
1095 | // argument is the number of elements expected by the Deserialize. | |
1096 | Err(de::Error::invalid_length(2, &ExpectedInSeq(len))) | |
1097 | } | |
1098 | } | |
1099 | } | |
1100 | ||
1101 | struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>); | |
1102 | ||
1103 | impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> | |
1104 | where | |
1105 | A: IntoDeserializer<'de, E>, | |
1106 | B: IntoDeserializer<'de, E>, | |
1107 | E: de::Error, | |
1108 | { | |
1109 | type Error = E; | |
1110 | ||
1111 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> | |
1112 | where | |
1113 | T: de::DeserializeSeed<'de>, | |
1114 | { | |
1115 | if let Some(k) = self.0.take() { | |
1116 | seed.deserialize(k.into_deserializer()).map(Some) | |
1117 | } else if let Some(v) = self.1.take() { | |
1118 | seed.deserialize(v.into_deserializer()).map(Some) | |
1119 | } else { | |
1120 | Ok(None) | |
1121 | } | |
1122 | } | |
1123 | ||
1124 | fn size_hint(&self) -> Option<usize> { | |
1125 | if self.0.is_some() { | |
1126 | Some(2) | |
1127 | } else if self.1.is_some() { | |
1128 | Some(1) | |
1129 | } else { | |
1130 | Some(0) | |
1131 | } | |
1132 | } | |
1133 | } | |
1134 | ||
1135 | struct ExpectedInMap(usize); | |
1136 | ||
1137 | impl Expected for ExpectedInMap { | |
1138 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
1139 | if self.0 == 1 { | |
1140 | write!(formatter, "1 element in map") | |
1141 | } else { | |
1142 | write!(formatter, "{} elements in map", self.0) | |
1143 | } | |
1144 | } | |
1145 | } | |
1146 | ||
1147 | //////////////////////////////////////////////////////////////////////////////// | |
1148 | ||
1149 | #[cfg(any(feature = "std", feature = "alloc"))] | |
1150 | impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> | |
1151 | where | |
1152 | K: IntoDeserializer<'de, E> + Eq + Ord, | |
1153 | V: IntoDeserializer<'de, E>, | |
1154 | E: de::Error, | |
1155 | { | |
abe05a73 | 1156 | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1157 | |
1158 | fn into_deserializer(self) -> Self::Deserializer { | |
1159 | MapDeserializer::new(self.into_iter()) | |
1160 | } | |
1161 | } | |
1162 | ||
1163 | #[cfg(feature = "std")] | |
abe05a73 | 1164 | impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S> |
041b39d2 XL |
1165 | where |
1166 | K: IntoDeserializer<'de, E> + Eq + Hash, | |
1167 | V: IntoDeserializer<'de, E>, | |
abe05a73 | 1168 | S: BuildHasher, |
041b39d2 XL |
1169 | E: de::Error, |
1170 | { | |
abe05a73 | 1171 | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>; |
041b39d2 XL |
1172 | |
1173 | fn into_deserializer(self) -> Self::Deserializer { | |
1174 | MapDeserializer::new(self.into_iter()) | |
1175 | } | |
1176 | } | |
1177 | ||
1178 | //////////////////////////////////////////////////////////////////////////////// | |
1179 | ||
1180 | /// A deserializer holding a `MapAccess`. | |
1181 | #[derive(Clone, Debug)] | |
1182 | pub struct MapAccessDeserializer<A> { | |
1183 | map: A, | |
1184 | } | |
1185 | ||
1186 | impl<A> MapAccessDeserializer<A> { | |
1187 | /// Construct a new `MapAccessDeserializer<A>`. | |
1188 | pub fn new(map: A) -> Self { | |
1189 | MapAccessDeserializer { map: map } | |
1190 | } | |
1191 | } | |
1192 | ||
1193 | impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> | |
1194 | where | |
1195 | A: de::MapAccess<'de>, | |
1196 | { | |
1197 | type Error = A::Error; | |
1198 | ||
1199 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
1200 | where | |
1201 | V: de::Visitor<'de>, | |
1202 | { | |
1203 | visitor.visit_map(self.map) | |
1204 | } | |
1205 | ||
1206 | forward_to_deserialize_any! { | |
1207 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
1208 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
1209 | map struct enum identifier ignored_any | |
1210 | } | |
1211 | } | |
1212 | ||
1213 | //////////////////////////////////////////////////////////////////////////////// | |
1214 | ||
1215 | mod private { | |
1216 | use lib::*; | |
1217 | ||
1218 | use de::{self, Unexpected}; | |
1219 | ||
1220 | #[derive(Clone, Debug)] | |
1221 | pub struct UnitOnly<E> { | |
1222 | marker: PhantomData<E>, | |
1223 | } | |
1224 | ||
1225 | pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) { | |
1226 | (t, UnitOnly { marker: PhantomData }) | |
1227 | } | |
1228 | ||
1229 | impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> | |
1230 | where | |
1231 | E: de::Error, | |
1232 | { | |
1233 | type Error = E; | |
1234 | ||
1235 | fn unit_variant(self) -> Result<(), Self::Error> { | |
1236 | Ok(()) | |
1237 | } | |
1238 | ||
1239 | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> | |
1240 | where | |
1241 | T: de::DeserializeSeed<'de>, | |
1242 | { | |
1243 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),) | |
1244 | } | |
1245 | ||
1246 | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> | |
1247 | where | |
1248 | V: de::Visitor<'de>, | |
1249 | { | |
1250 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),) | |
1251 | } | |
1252 | ||
1253 | fn struct_variant<V>( | |
1254 | self, | |
1255 | _fields: &'static [&'static str], | |
1256 | _visitor: V, | |
1257 | ) -> Result<V::Value, Self::Error> | |
1258 | where | |
1259 | V: de::Visitor<'de>, | |
1260 | { | |
1261 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),) | |
1262 | } | |
1263 | } | |
1264 | ||
1265 | /// Avoid having to restate the generic types on `MapDeserializer`. The | |
1266 | /// `Iterator::Item` contains enough information to figure out K and V. | |
1267 | pub trait Pair { | |
1268 | type First; | |
1269 | type Second; | |
1270 | fn split(self) -> (Self::First, Self::Second); | |
1271 | } | |
1272 | ||
1273 | impl<A, B> Pair for (A, B) { | |
1274 | type First = A; | |
1275 | type Second = B; | |
1276 | fn split(self) -> (A, B) { | |
1277 | self | |
1278 | } | |
1279 | } | |
1280 | ||
1281 | pub type First<T> = <T as Pair>::First; | |
1282 | pub type Second<T> = <T as Pair>::Second; | |
1283 | } |