]>
Commit | Line | Data |
---|---|---|
7cac9316 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. | |
8bb4bdeb XL |
49 | #[derive(Clone, Debug, PartialEq)] |
50 | pub struct Error { | |
51 | err: ErrorImpl, | |
52 | } | |
53 | ||
54 | #[cfg(any(feature = "std", feature = "collections"))] | |
55 | type ErrorImpl = Box<str>; | |
56 | #[cfg(not(any(feature = "std", feature = "collections")))] | |
57 | type ErrorImpl = (); | |
58 | ||
59 | impl de::Error for Error { | |
60 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
61 | fn custom<T>(msg: T) -> Self |
62 | where | |
63 | T: Display, | |
64 | { | |
8bb4bdeb XL |
65 | Error { err: msg.to_string().into_boxed_str() } |
66 | } | |
67 | ||
68 | #[cfg(not(any(feature = "std", feature = "collections")))] | |
7cac9316 XL |
69 | fn custom<T>(msg: T) -> Self |
70 | where | |
71 | T: Display, | |
72 | { | |
73 | let _ = msg; | |
8bb4bdeb XL |
74 | Error { err: () } |
75 | } | |
76 | } | |
77 | ||
7cac9316 XL |
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 | ||
8bb4bdeb XL |
87 | impl Display for Error { |
88 | #[cfg(any(feature = "std", feature = "collections"))] | |
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 = "collections")))] | |
94 | fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { | |
95 | formatter.write_str("Serde deserialization error") | |
96 | } | |
97 | } | |
98 | ||
7cac9316 | 99 | #[cfg(feature = "std")] |
8bb4bdeb | 100 | impl error::Error for Error { |
8bb4bdeb XL |
101 | fn description(&self) -> &str { |
102 | &self.err | |
103 | } | |
8bb4bdeb XL |
104 | } |
105 | ||
7cac9316 | 106 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 107 | |
7cac9316 XL |
108 | impl<'de, E> IntoDeserializer<'de, E> for () |
109 | where | |
110 | E: de::Error, | |
8bb4bdeb XL |
111 | { |
112 | type Deserializer = UnitDeserializer<E>; | |
113 | ||
114 | fn into_deserializer(self) -> UnitDeserializer<E> { | |
115 | UnitDeserializer { marker: PhantomData } | |
116 | } | |
117 | } | |
118 | ||
7cac9316 XL |
119 | /// A deserializer holding a `()`. |
120 | #[derive(Clone, Debug)] | |
8bb4bdeb XL |
121 | pub struct UnitDeserializer<E> { |
122 | marker: PhantomData<E>, | |
123 | } | |
124 | ||
7cac9316 XL |
125 | impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> |
126 | where | |
127 | E: de::Error, | |
8bb4bdeb XL |
128 | { |
129 | type Error = E; | |
130 | ||
7cac9316 XL |
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 | |
8bb4bdeb XL |
135 | } |
136 | ||
7cac9316 XL |
137 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
138 | where | |
139 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
140 | { |
141 | visitor.visit_unit() | |
142 | } | |
143 | ||
144 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
7cac9316 XL |
145 | where |
146 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
147 | { |
148 | visitor.visit_none() | |
149 | } | |
150 | } | |
151 | ||
7cac9316 | 152 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb XL |
153 | |
154 | macro_rules! primitive_deserializer { | |
7cac9316 XL |
155 | ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => { |
156 | #[doc = "A deserializer holding"] | |
157 | #[doc = $doc] | |
158 | #[derive(Clone, Debug)] | |
8bb4bdeb XL |
159 | pub struct $name<E> { |
160 | value: $ty, | |
161 | marker: PhantomData<E> | |
162 | } | |
163 | ||
7cac9316 XL |
164 | impl<'de, E> IntoDeserializer<'de, E> for $ty |
165 | where | |
166 | E: de::Error, | |
8bb4bdeb XL |
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 | ||
7cac9316 XL |
178 | impl<'de, E> de::Deserializer<'de> for $name<E> |
179 | where | |
180 | E: de::Error, | |
8bb4bdeb XL |
181 | { |
182 | type Error = E; | |
183 | ||
7cac9316 XL |
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 | |
8bb4bdeb XL |
188 | } |
189 | ||
7cac9316 XL |
190 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
191 | where | |
192 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
193 | { |
194 | visitor.$method(self.value $($cast)*) | |
195 | } | |
196 | } | |
197 | } | |
198 | } | |
199 | ||
7cac9316 XL |
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)] | |
8bb4bdeb XL |
288 | pub struct StrDeserializer<'a, E> { |
289 | value: &'a str, | |
290 | marker: PhantomData<E>, | |
291 | } | |
292 | ||
7cac9316 XL |
293 | impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str |
294 | where | |
295 | E: de::Error, | |
8bb4bdeb XL |
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 | ||
7cac9316 XL |
307 | impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E> |
308 | where | |
309 | E: de::Error, | |
8bb4bdeb XL |
310 | { |
311 | type Error = E; | |
312 | ||
7cac9316 XL |
313 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
314 | where | |
315 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
316 | { |
317 | visitor.visit_str(self.value) | |
318 | } | |
319 | ||
7cac9316 XL |
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>, | |
8bb4bdeb | 328 | { |
7cac9316 XL |
329 | let _ = name; |
330 | let _ = variants; | |
8bb4bdeb XL |
331 | visitor.visit_enum(self) |
332 | } | |
333 | ||
7cac9316 XL |
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 | |
8bb4bdeb XL |
338 | } |
339 | } | |
340 | ||
7cac9316 XL |
341 | impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> |
342 | where | |
343 | E: de::Error, | |
8bb4bdeb XL |
344 | { |
345 | type Error = E; | |
346 | type Variant = private::UnitOnly<E>; | |
347 | ||
7cac9316 XL |
348 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> |
349 | where | |
350 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
351 | { |
352 | seed.deserialize(self).map(private::unit_only) | |
353 | } | |
354 | } | |
355 | ||
7cac9316 | 356 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 357 | |
7cac9316 | 358 | /// A deserializer holding a `String`. |
8bb4bdeb | 359 | #[cfg(any(feature = "std", feature = "collections"))] |
7cac9316 | 360 | #[derive(Clone, Debug)] |
8bb4bdeb XL |
361 | pub struct StringDeserializer<E> { |
362 | value: String, | |
363 | marker: PhantomData<E>, | |
364 | } | |
365 | ||
366 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
367 | impl<'de, E> IntoDeserializer<'de, E> for String |
368 | where | |
369 | E: de::Error, | |
8bb4bdeb XL |
370 | { |
371 | type Deserializer = StringDeserializer<E>; | |
372 | ||
373 | fn into_deserializer(self) -> StringDeserializer<E> { | |
374 | StringDeserializer { | |
375 | value: self, | |
376 | marker: PhantomData, | |
377 | } | |
378 | } | |
379 | } | |
380 | ||
381 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
382 | impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> |
383 | where | |
384 | E: de::Error, | |
8bb4bdeb XL |
385 | { |
386 | type Error = E; | |
387 | ||
7cac9316 XL |
388 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
389 | where | |
390 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
391 | { |
392 | visitor.visit_string(self.value) | |
393 | } | |
394 | ||
7cac9316 XL |
395 | fn deserialize_enum<V>( |
396 | self, | |
397 | name: &str, | |
398 | variants: &'static [&'static str], | |
399 | visitor: V, | |
400 | ) -> Result<V::Value, Self::Error> | |
401 | where | |
402 | V: de::Visitor<'de>, | |
8bb4bdeb | 403 | { |
7cac9316 XL |
404 | let _ = name; |
405 | let _ = variants; | |
8bb4bdeb XL |
406 | visitor.visit_enum(self) |
407 | } | |
408 | ||
7cac9316 XL |
409 | forward_to_deserialize_any! { |
410 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
411 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
412 | map struct identifier ignored_any | |
8bb4bdeb XL |
413 | } |
414 | } | |
415 | ||
416 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
417 | impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E> |
418 | where | |
419 | E: de::Error, | |
8bb4bdeb XL |
420 | { |
421 | type Error = E; | |
422 | type Variant = private::UnitOnly<E>; | |
423 | ||
7cac9316 XL |
424 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> |
425 | where | |
426 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
427 | { |
428 | seed.deserialize(self).map(private::unit_only) | |
429 | } | |
430 | } | |
431 | ||
7cac9316 | 432 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 433 | |
7cac9316 | 434 | /// A deserializer holding a `Cow<str>`. |
8bb4bdeb | 435 | #[cfg(any(feature = "std", feature = "collections"))] |
7cac9316 | 436 | #[derive(Clone, Debug)] |
8bb4bdeb XL |
437 | pub struct CowStrDeserializer<'a, E> { |
438 | value: Cow<'a, str>, | |
439 | marker: PhantomData<E>, | |
440 | } | |
441 | ||
442 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
443 | impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> |
444 | where | |
445 | E: de::Error, | |
8bb4bdeb XL |
446 | { |
447 | type Deserializer = CowStrDeserializer<'a, E>; | |
448 | ||
449 | fn into_deserializer(self) -> CowStrDeserializer<'a, E> { | |
450 | CowStrDeserializer { | |
451 | value: self, | |
452 | marker: PhantomData, | |
453 | } | |
454 | } | |
455 | } | |
456 | ||
457 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
458 | impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E> |
459 | where | |
460 | E: de::Error, | |
8bb4bdeb XL |
461 | { |
462 | type Error = E; | |
463 | ||
7cac9316 XL |
464 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
465 | where | |
466 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
467 | { |
468 | match self.value { | |
469 | Cow::Borrowed(string) => visitor.visit_str(string), | |
470 | Cow::Owned(string) => visitor.visit_string(string), | |
471 | } | |
472 | } | |
473 | ||
7cac9316 XL |
474 | fn deserialize_enum<V>( |
475 | self, | |
476 | name: &str, | |
477 | variants: &'static [&'static str], | |
478 | visitor: V, | |
479 | ) -> Result<V::Value, Self::Error> | |
480 | where | |
481 | V: de::Visitor<'de>, | |
8bb4bdeb | 482 | { |
7cac9316 XL |
483 | let _ = name; |
484 | let _ = variants; | |
8bb4bdeb XL |
485 | visitor.visit_enum(self) |
486 | } | |
487 | ||
7cac9316 XL |
488 | forward_to_deserialize_any! { |
489 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
490 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
491 | map struct identifier ignored_any | |
8bb4bdeb XL |
492 | } |
493 | } | |
494 | ||
495 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
496 | impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E> |
497 | where | |
498 | E: de::Error, | |
8bb4bdeb XL |
499 | { |
500 | type Error = E; | |
501 | type Variant = private::UnitOnly<E>; | |
502 | ||
7cac9316 XL |
503 | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error> |
504 | where | |
505 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
506 | { |
507 | seed.deserialize(self).map(private::unit_only) | |
508 | } | |
509 | } | |
510 | ||
7cac9316 | 511 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 512 | |
7cac9316 XL |
513 | /// A deserializer that iterates over a sequence. |
514 | #[derive(Clone, Debug)] | |
8bb4bdeb XL |
515 | pub struct SeqDeserializer<I, E> { |
516 | iter: iter::Fuse<I>, | |
517 | count: usize, | |
518 | marker: PhantomData<E>, | |
519 | } | |
520 | ||
521 | impl<I, E> SeqDeserializer<I, E> | |
7cac9316 XL |
522 | where |
523 | I: Iterator, | |
8bb4bdeb | 524 | { |
7cac9316 | 525 | /// Construct a new `SeqDeserializer<I, E>`. |
8bb4bdeb XL |
526 | pub fn new(iter: I) -> Self { |
527 | SeqDeserializer { | |
528 | iter: iter.fuse(), | |
529 | count: 0, | |
530 | marker: PhantomData, | |
531 | } | |
532 | } | |
7cac9316 | 533 | } |
8bb4bdeb | 534 | |
7cac9316 XL |
535 | impl<I, E> SeqDeserializer<I, E> |
536 | where | |
537 | I: Iterator, | |
538 | E: de::Error, | |
539 | { | |
8bb4bdeb XL |
540 | /// Check for remaining elements after passing a `SeqDeserializer` to |
541 | /// `Visitor::visit_seq`. | |
542 | pub fn end(mut self) -> Result<(), E> { | |
543 | let mut remaining = 0; | |
544 | while self.iter.next().is_some() { | |
545 | remaining += 1; | |
546 | } | |
547 | if remaining == 0 { | |
548 | Ok(()) | |
549 | } else { | |
550 | // First argument is the number of elements in the data, second | |
551 | // argument is the number of elements expected by the Deserialize. | |
7cac9316 | 552 | Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)),) |
8bb4bdeb XL |
553 | } |
554 | } | |
555 | } | |
556 | ||
7cac9316 XL |
557 | impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E> |
558 | where | |
559 | I: Iterator<Item = T>, | |
560 | T: IntoDeserializer<'de, E>, | |
561 | E: de::Error, | |
8bb4bdeb XL |
562 | { |
563 | type Error = E; | |
564 | ||
7cac9316 XL |
565 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> |
566 | where | |
567 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
568 | { |
569 | let v = try!(visitor.visit_seq(&mut self)); | |
570 | try!(self.end()); | |
571 | Ok(v) | |
572 | } | |
573 | ||
7cac9316 XL |
574 | forward_to_deserialize_any! { |
575 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
576 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
577 | map struct enum identifier ignored_any | |
8bb4bdeb XL |
578 | } |
579 | } | |
580 | ||
7cac9316 XL |
581 | impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> |
582 | where | |
583 | I: Iterator<Item = T>, | |
584 | T: IntoDeserializer<'de, E>, | |
585 | E: de::Error, | |
8bb4bdeb XL |
586 | { |
587 | type Error = E; | |
588 | ||
7cac9316 XL |
589 | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error> |
590 | where | |
591 | V: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
592 | { |
593 | match self.iter.next() { | |
594 | Some(value) => { | |
595 | self.count += 1; | |
596 | seed.deserialize(value.into_deserializer()).map(Some) | |
597 | } | |
598 | None => Ok(None), | |
599 | } | |
600 | } | |
601 | ||
7cac9316 XL |
602 | fn size_hint(&self) -> Option<usize> { |
603 | size_hint::from_bounds(&self.iter) | |
8bb4bdeb XL |
604 | } |
605 | } | |
606 | ||
607 | struct ExpectedInSeq(usize); | |
608 | ||
609 | impl Expected for ExpectedInSeq { | |
610 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
611 | if self.0 == 1 { | |
612 | write!(formatter, "1 element in sequence") | |
613 | } else { | |
614 | write!(formatter, "{} elements in sequence", self.0) | |
615 | } | |
616 | } | |
617 | } | |
618 | ||
7cac9316 | 619 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb XL |
620 | |
621 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
622 | impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> |
623 | where | |
624 | T: IntoDeserializer<'de, E>, | |
625 | E: de::Error, | |
8bb4bdeb | 626 | { |
7cac9316 | 627 | type Deserializer = SeqDeserializer<<Vec<T> as IntoIterator>::IntoIter, E>; |
8bb4bdeb XL |
628 | |
629 | fn into_deserializer(self) -> Self::Deserializer { | |
630 | SeqDeserializer::new(self.into_iter()) | |
631 | } | |
632 | } | |
633 | ||
634 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
635 | impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> |
636 | where | |
637 | T: IntoDeserializer<'de, E> + Eq + Ord, | |
638 | E: de::Error, | |
8bb4bdeb | 639 | { |
7cac9316 | 640 | type Deserializer = SeqDeserializer<<BTreeSet<T> as IntoIterator>::IntoIter, E>; |
8bb4bdeb XL |
641 | |
642 | fn into_deserializer(self) -> Self::Deserializer { | |
643 | SeqDeserializer::new(self.into_iter()) | |
644 | } | |
645 | } | |
646 | ||
647 | #[cfg(feature = "std")] | |
7cac9316 XL |
648 | impl<'de, T, E> IntoDeserializer<'de, E> for HashSet<T> |
649 | where | |
650 | T: IntoDeserializer<'de, E> + Eq + Hash, | |
651 | E: de::Error, | |
8bb4bdeb | 652 | { |
7cac9316 | 653 | type Deserializer = SeqDeserializer<<HashSet<T> as IntoIterator>::IntoIter, E>; |
8bb4bdeb XL |
654 | |
655 | fn into_deserializer(self) -> Self::Deserializer { | |
656 | SeqDeserializer::new(self.into_iter()) | |
657 | } | |
658 | } | |
659 | ||
7cac9316 | 660 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 661 | |
7cac9316 XL |
662 | /// A deserializer holding a `SeqAccess`. |
663 | #[derive(Clone, Debug)] | |
664 | pub struct SeqAccessDeserializer<A> { | |
665 | seq: A, | |
8bb4bdeb XL |
666 | } |
667 | ||
7cac9316 XL |
668 | impl<A> SeqAccessDeserializer<A> { |
669 | /// Construct a new `SeqAccessDeserializer<A>`. | |
670 | pub fn new(seq: A) -> Self { | |
671 | SeqAccessDeserializer { seq: seq } | |
8bb4bdeb XL |
672 | } |
673 | } | |
674 | ||
7cac9316 XL |
675 | impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> |
676 | where | |
677 | A: de::SeqAccess<'de>, | |
8bb4bdeb | 678 | { |
7cac9316 | 679 | type Error = A::Error; |
8bb4bdeb | 680 | |
7cac9316 XL |
681 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
682 | where | |
683 | V: de::Visitor<'de>, | |
684 | { | |
685 | visitor.visit_seq(self.seq) | |
8bb4bdeb XL |
686 | } |
687 | ||
7cac9316 XL |
688 | forward_to_deserialize_any! { |
689 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
690 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
691 | map struct enum identifier ignored_any | |
8bb4bdeb XL |
692 | } |
693 | } | |
694 | ||
7cac9316 | 695 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 696 | |
7cac9316 XL |
697 | /// A deserializer that iterates over a map. |
698 | pub struct MapDeserializer<'de, I, E> | |
699 | where | |
700 | I: Iterator, | |
701 | I::Item: private::Pair, | |
8bb4bdeb XL |
702 | { |
703 | iter: iter::Fuse<I>, | |
7cac9316 | 704 | value: Option<Second<I::Item>>, |
8bb4bdeb | 705 | count: usize, |
7cac9316 XL |
706 | lifetime: PhantomData<&'de ()>, |
707 | error: PhantomData<E>, | |
8bb4bdeb XL |
708 | } |
709 | ||
7cac9316 XL |
710 | impl<'de, I, E> MapDeserializer<'de, I, E> |
711 | where | |
712 | I: Iterator, | |
713 | I::Item: private::Pair, | |
8bb4bdeb | 714 | { |
7cac9316 | 715 | /// Construct a new `MapDeserializer<I, E>`. |
8bb4bdeb XL |
716 | pub fn new(iter: I) -> Self { |
717 | MapDeserializer { | |
718 | iter: iter.fuse(), | |
719 | value: None, | |
720 | count: 0, | |
7cac9316 XL |
721 | lifetime: PhantomData, |
722 | error: PhantomData, | |
8bb4bdeb XL |
723 | } |
724 | } | |
7cac9316 | 725 | } |
8bb4bdeb | 726 | |
7cac9316 XL |
727 | impl<'de, I, E> MapDeserializer<'de, I, E> |
728 | where | |
729 | I: Iterator, | |
730 | I::Item: private::Pair, | |
731 | E: de::Error, | |
732 | { | |
8bb4bdeb XL |
733 | /// Check for remaining elements after passing a `MapDeserializer` to |
734 | /// `Visitor::visit_map`. | |
735 | pub fn end(mut self) -> Result<(), E> { | |
736 | let mut remaining = 0; | |
737 | while self.iter.next().is_some() { | |
738 | remaining += 1; | |
739 | } | |
740 | if remaining == 0 { | |
741 | Ok(()) | |
742 | } else { | |
743 | // First argument is the number of elements in the data, second | |
744 | // argument is the number of elements expected by the Deserialize. | |
7cac9316 | 745 | Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)),) |
8bb4bdeb XL |
746 | } |
747 | } | |
7cac9316 | 748 | } |
8bb4bdeb | 749 | |
7cac9316 XL |
750 | impl<'de, I, E> MapDeserializer<'de, I, E> |
751 | where | |
752 | I: Iterator, | |
753 | I::Item: private::Pair, | |
754 | { | |
755 | fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> { | |
8bb4bdeb XL |
756 | match self.iter.next() { |
757 | Some(kv) => { | |
758 | self.count += 1; | |
759 | Some(private::Pair::split(kv)) | |
760 | } | |
761 | None => None, | |
762 | } | |
763 | } | |
764 | } | |
765 | ||
7cac9316 XL |
766 | impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E> |
767 | where | |
768 | I: Iterator, | |
769 | I::Item: private::Pair, | |
770 | First<I::Item>: IntoDeserializer<'de, E>, | |
771 | Second<I::Item>: IntoDeserializer<'de, E>, | |
772 | E: de::Error, | |
8bb4bdeb XL |
773 | { |
774 | type Error = E; | |
775 | ||
7cac9316 XL |
776 | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> |
777 | where | |
778 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
779 | { |
780 | let value = try!(visitor.visit_map(&mut self)); | |
781 | try!(self.end()); | |
782 | Ok(value) | |
783 | } | |
784 | ||
7cac9316 XL |
785 | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> |
786 | where | |
787 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
788 | { |
789 | let value = try!(visitor.visit_seq(&mut self)); | |
790 | try!(self.end()); | |
791 | Ok(value) | |
792 | } | |
793 | ||
7cac9316 XL |
794 | fn deserialize_tuple<V>( |
795 | self, | |
796 | len: usize, | |
797 | visitor: V, | |
798 | ) -> Result<V::Value, Self::Error> | |
799 | where | |
800 | V: de::Visitor<'de>, | |
8bb4bdeb | 801 | { |
7cac9316 | 802 | let _ = len; |
8bb4bdeb XL |
803 | self.deserialize_seq(visitor) |
804 | } | |
805 | ||
7cac9316 XL |
806 | forward_to_deserialize_any! { |
807 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
808 | byte_buf option unit unit_struct newtype_struct tuple_struct map struct | |
809 | enum identifier ignored_any | |
8bb4bdeb XL |
810 | } |
811 | } | |
812 | ||
7cac9316 XL |
813 | impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E> |
814 | where | |
815 | I: Iterator, | |
816 | I::Item: private::Pair, | |
817 | First<I::Item>: IntoDeserializer<'de, E>, | |
818 | Second<I::Item>: IntoDeserializer<'de, E>, | |
819 | E: de::Error, | |
8bb4bdeb XL |
820 | { |
821 | type Error = E; | |
822 | ||
7cac9316 XL |
823 | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> |
824 | where | |
825 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
826 | { |
827 | match self.next_pair() { | |
828 | Some((key, value)) => { | |
829 | self.value = Some(value); | |
830 | seed.deserialize(key.into_deserializer()).map(Some) | |
831 | } | |
832 | None => Ok(None), | |
833 | } | |
834 | } | |
835 | ||
7cac9316 XL |
836 | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> |
837 | where | |
838 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
839 | { |
840 | let value = self.value.take(); | |
841 | // Panic because this indicates a bug in the program rather than an | |
842 | // expected failure. | |
7cac9316 | 843 | let value = value.expect("MapAccess::visit_value called before visit_key"); |
8bb4bdeb XL |
844 | seed.deserialize(value.into_deserializer()) |
845 | } | |
846 | ||
7cac9316 XL |
847 | fn next_entry_seed<TK, TV>( |
848 | &mut self, | |
849 | kseed: TK, | |
850 | vseed: TV, | |
851 | ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error> | |
852 | where | |
853 | TK: de::DeserializeSeed<'de>, | |
854 | TV: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
855 | { |
856 | match self.next_pair() { | |
857 | Some((key, value)) => { | |
858 | let key = try!(kseed.deserialize(key.into_deserializer())); | |
859 | let value = try!(vseed.deserialize(value.into_deserializer())); | |
860 | Ok(Some((key, value))) | |
861 | } | |
862 | None => Ok(None), | |
863 | } | |
864 | } | |
865 | ||
7cac9316 XL |
866 | fn size_hint(&self) -> Option<usize> { |
867 | size_hint::from_bounds(&self.iter) | |
8bb4bdeb XL |
868 | } |
869 | } | |
870 | ||
7cac9316 XL |
871 | impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E> |
872 | where | |
873 | I: Iterator, | |
874 | I::Item: private::Pair, | |
875 | First<I::Item>: IntoDeserializer<'de, E>, | |
876 | Second<I::Item>: IntoDeserializer<'de, E>, | |
877 | E: de::Error, | |
8bb4bdeb XL |
878 | { |
879 | type Error = E; | |
880 | ||
7cac9316 XL |
881 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> |
882 | where | |
883 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
884 | { |
885 | match self.next_pair() { | |
886 | Some((k, v)) => { | |
887 | let de = PairDeserializer(k, v, PhantomData); | |
888 | seed.deserialize(de).map(Some) | |
889 | } | |
890 | None => Ok(None), | |
891 | } | |
892 | } | |
893 | ||
7cac9316 XL |
894 | fn size_hint(&self) -> Option<usize> { |
895 | size_hint::from_bounds(&self.iter) | |
896 | } | |
897 | } | |
898 | ||
899 | // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`. | |
900 | impl<'de, I, E> Clone for MapDeserializer<'de, I, E> | |
901 | where | |
902 | I: Iterator + Clone, | |
903 | I::Item: private::Pair, | |
904 | Second<I::Item>: Clone, | |
905 | { | |
906 | fn clone(&self) -> Self { | |
907 | MapDeserializer { | |
908 | iter: self.iter.clone(), | |
909 | value: self.value.clone(), | |
910 | count: self.count, | |
911 | lifetime: self.lifetime, | |
912 | error: self.error, | |
913 | } | |
914 | } | |
915 | } | |
916 | ||
917 | // Cannot #[derive(Debug)] because of the bound `Second<I::Item>: Debug`. | |
918 | impl<'de, I, E> Debug for MapDeserializer<'de, I, E> | |
919 | where | |
920 | I: Iterator + Debug, | |
921 | I::Item: private::Pair, | |
922 | Second<I::Item>: Debug, | |
923 | { | |
924 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
925 | formatter | |
926 | .debug_struct("MapDeserializer") | |
927 | .field("iter", &self.iter) | |
928 | .field("value", &self.value) | |
929 | .field("count", &self.count) | |
930 | .field("lifetime", &self.lifetime) | |
931 | .field("error", &self.error) | |
932 | .finish() | |
8bb4bdeb XL |
933 | } |
934 | } | |
935 | ||
7cac9316 | 936 | // Used in the `impl SeqAccess for MapDeserializer` to visit the map as a |
8bb4bdeb XL |
937 | // sequence of pairs. |
938 | struct PairDeserializer<A, B, E>(A, B, PhantomData<E>); | |
939 | ||
7cac9316 XL |
940 | impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E> |
941 | where | |
942 | A: IntoDeserializer<'de, E>, | |
943 | B: IntoDeserializer<'de, E>, | |
944 | E: de::Error, | |
8bb4bdeb XL |
945 | { |
946 | type Error = E; | |
947 | ||
7cac9316 XL |
948 | forward_to_deserialize_any! { |
949 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
950 | byte_buf option unit unit_struct newtype_struct tuple_struct map struct | |
951 | enum identifier ignored_any | |
8bb4bdeb XL |
952 | } |
953 | ||
7cac9316 XL |
954 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
955 | where | |
956 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
957 | { |
958 | self.deserialize_seq(visitor) | |
959 | } | |
960 | ||
961 | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> | |
7cac9316 XL |
962 | where |
963 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
964 | { |
965 | let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData); | |
966 | let pair = try!(visitor.visit_seq(&mut pair_visitor)); | |
967 | if pair_visitor.1.is_none() { | |
968 | Ok(pair) | |
969 | } else { | |
7cac9316 | 970 | let remaining = pair_visitor.size_hint().unwrap(); |
8bb4bdeb XL |
971 | // First argument is the number of elements in the data, second |
972 | // argument is the number of elements expected by the Deserialize. | |
973 | Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining))) | |
974 | } | |
975 | } | |
976 | ||
7cac9316 XL |
977 | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> |
978 | where | |
979 | V: de::Visitor<'de>, | |
8bb4bdeb XL |
980 | { |
981 | if len == 2 { | |
982 | self.deserialize_seq(visitor) | |
983 | } else { | |
984 | // First argument is the number of elements in the data, second | |
985 | // argument is the number of elements expected by the Deserialize. | |
986 | Err(de::Error::invalid_length(2, &ExpectedInSeq(len))) | |
987 | } | |
988 | } | |
989 | } | |
990 | ||
991 | struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>); | |
992 | ||
7cac9316 XL |
993 | impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> |
994 | where | |
995 | A: IntoDeserializer<'de, E>, | |
996 | B: IntoDeserializer<'de, E>, | |
997 | E: de::Error, | |
8bb4bdeb XL |
998 | { |
999 | type Error = E; | |
1000 | ||
7cac9316 XL |
1001 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> |
1002 | where | |
1003 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb XL |
1004 | { |
1005 | if let Some(k) = self.0.take() { | |
1006 | seed.deserialize(k.into_deserializer()).map(Some) | |
1007 | } else if let Some(v) = self.1.take() { | |
1008 | seed.deserialize(v.into_deserializer()).map(Some) | |
1009 | } else { | |
1010 | Ok(None) | |
1011 | } | |
1012 | } | |
1013 | ||
7cac9316 XL |
1014 | fn size_hint(&self) -> Option<usize> { |
1015 | if self.0.is_some() { | |
1016 | Some(2) | |
8bb4bdeb | 1017 | } else if self.1.is_some() { |
7cac9316 | 1018 | Some(1) |
8bb4bdeb | 1019 | } else { |
7cac9316 XL |
1020 | Some(0) |
1021 | } | |
8bb4bdeb XL |
1022 | } |
1023 | } | |
1024 | ||
1025 | struct ExpectedInMap(usize); | |
1026 | ||
1027 | impl Expected for ExpectedInMap { | |
1028 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { | |
1029 | if self.0 == 1 { | |
1030 | write!(formatter, "1 element in map") | |
1031 | } else { | |
1032 | write!(formatter, "{} elements in map", self.0) | |
1033 | } | |
1034 | } | |
1035 | } | |
1036 | ||
7cac9316 | 1037 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb XL |
1038 | |
1039 | #[cfg(any(feature = "std", feature = "collections"))] | |
7cac9316 XL |
1040 | impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> |
1041 | where | |
1042 | K: IntoDeserializer<'de, E> + Eq + Ord, | |
1043 | V: IntoDeserializer<'de, E>, | |
1044 | E: de::Error, | |
8bb4bdeb | 1045 | { |
7cac9316 | 1046 | type Deserializer = MapDeserializer<'de, <BTreeMap<K, V> as IntoIterator>::IntoIter, E>; |
8bb4bdeb XL |
1047 | |
1048 | fn into_deserializer(self) -> Self::Deserializer { | |
1049 | MapDeserializer::new(self.into_iter()) | |
1050 | } | |
1051 | } | |
1052 | ||
1053 | #[cfg(feature = "std")] | |
7cac9316 XL |
1054 | impl<'de, K, V, E> IntoDeserializer<'de, E> for HashMap<K, V> |
1055 | where | |
1056 | K: IntoDeserializer<'de, E> + Eq + Hash, | |
1057 | V: IntoDeserializer<'de, E>, | |
1058 | E: de::Error, | |
8bb4bdeb | 1059 | { |
7cac9316 | 1060 | type Deserializer = MapDeserializer<'de, <HashMap<K, V> as IntoIterator>::IntoIter, E>; |
8bb4bdeb XL |
1061 | |
1062 | fn into_deserializer(self) -> Self::Deserializer { | |
1063 | MapDeserializer::new(self.into_iter()) | |
1064 | } | |
1065 | } | |
1066 | ||
7cac9316 | 1067 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb | 1068 | |
7cac9316 XL |
1069 | /// A deserializer holding a `MapAccess`. |
1070 | #[derive(Clone, Debug)] | |
1071 | pub struct MapAccessDeserializer<A> { | |
1072 | map: A, | |
8bb4bdeb XL |
1073 | } |
1074 | ||
7cac9316 XL |
1075 | impl<A> MapAccessDeserializer<A> { |
1076 | /// Construct a new `MapAccessDeserializer<A>`. | |
1077 | pub fn new(map: A) -> Self { | |
1078 | MapAccessDeserializer { map: map } | |
8bb4bdeb XL |
1079 | } |
1080 | } | |
1081 | ||
7cac9316 XL |
1082 | impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> |
1083 | where | |
1084 | A: de::MapAccess<'de>, | |
8bb4bdeb | 1085 | { |
7cac9316 | 1086 | type Error = A::Error; |
8bb4bdeb | 1087 | |
7cac9316 XL |
1088 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
1089 | where | |
1090 | V: de::Visitor<'de>, | |
8bb4bdeb | 1091 | { |
7cac9316 | 1092 | visitor.visit_map(self.map) |
8bb4bdeb XL |
1093 | } |
1094 | ||
7cac9316 XL |
1095 | forward_to_deserialize_any! { |
1096 | bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes | |
1097 | byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct | |
1098 | map struct enum identifier ignored_any | |
8bb4bdeb XL |
1099 | } |
1100 | } | |
1101 | ||
7cac9316 | 1102 | //////////////////////////////////////////////////////////////////////////////// |
8bb4bdeb XL |
1103 | |
1104 | mod private { | |
7cac9316 XL |
1105 | use lib::*; |
1106 | ||
8bb4bdeb | 1107 | use de::{self, Unexpected}; |
8bb4bdeb | 1108 | |
7cac9316 | 1109 | #[derive(Clone, Debug)] |
8bb4bdeb XL |
1110 | pub struct UnitOnly<E> { |
1111 | marker: PhantomData<E>, | |
1112 | } | |
1113 | ||
1114 | pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) { | |
1115 | (t, UnitOnly { marker: PhantomData }) | |
1116 | } | |
1117 | ||
7cac9316 XL |
1118 | impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> |
1119 | where | |
1120 | E: de::Error, | |
8bb4bdeb XL |
1121 | { |
1122 | type Error = E; | |
1123 | ||
7cac9316 | 1124 | fn unit_variant(self) -> Result<(), Self::Error> { |
8bb4bdeb XL |
1125 | Ok(()) |
1126 | } | |
1127 | ||
7cac9316 XL |
1128 | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error> |
1129 | where | |
1130 | T: de::DeserializeSeed<'de>, | |
8bb4bdeb | 1131 | { |
7cac9316 | 1132 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),) |
8bb4bdeb XL |
1133 | } |
1134 | ||
7cac9316 XL |
1135 | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error> |
1136 | where | |
1137 | V: de::Visitor<'de>, | |
8bb4bdeb | 1138 | { |
7cac9316 | 1139 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),) |
8bb4bdeb XL |
1140 | } |
1141 | ||
7cac9316 XL |
1142 | fn struct_variant<V>( |
1143 | self, | |
1144 | _fields: &'static [&'static str], | |
1145 | _visitor: V, | |
1146 | ) -> Result<V::Value, Self::Error> | |
1147 | where | |
1148 | V: de::Visitor<'de>, | |
8bb4bdeb | 1149 | { |
7cac9316 | 1150 | Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),) |
8bb4bdeb XL |
1151 | } |
1152 | } | |
1153 | ||
1154 | /// Avoid having to restate the generic types on `MapDeserializer`. The | |
1155 | /// `Iterator::Item` contains enough information to figure out K and V. | |
1156 | pub trait Pair { | |
1157 | type First; | |
1158 | type Second; | |
1159 | fn split(self) -> (Self::First, Self::Second); | |
1160 | } | |
1161 | ||
1162 | impl<A, B> Pair for (A, B) { | |
1163 | type First = A; | |
1164 | type Second = B; | |
1165 | fn split(self) -> (A, B) { | |
1166 | self | |
1167 | } | |
1168 | } | |
7cac9316 XL |
1169 | |
1170 | pub type First<T> = <T as Pair>::First; | |
1171 | pub type Second<T> = <T as Pair>::Second; | |
8bb4bdeb | 1172 | } |