1use crate::de::{Deserialize, Map, Seq, Visitor};
2use crate::error::{Error, Result};
3use crate::ignore::Ignore;
4use crate::ptr::NonuniqueBox;
5use alloc::borrow::ToOwned;
6use alloc::boxed::Box;
7use alloc::collections::BTreeMap;
8use alloc::string::String;
9use alloc::vec::Vec;
10use core::mem::{self, ManuallyDrop, MaybeUninit};
11use core::ptr;
12use core::str::{self, FromStr};
13#[cfg(feature = "std")]
14use std::collections::HashMap;
15#[cfg(feature = "std")]
16use std::hash::{BuildHasher, Hash};
17
18impl Deserialize for () {
19 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
20 make_place!(Place);
21
22 impl Visitor for Place<()> {
23 fn null(&mut self) -> Result<()> {
24 self.out = Some(());
25 Ok(())
26 }
27 }
28
29 Place::new(out)
30 }
31}
32
33impl Deserialize for bool {
34 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
35 make_place!(Place);
36
37 impl Visitor for Place<bool> {
38 fn boolean(&mut self, b: bool) -> Result<()> {
39 self.out = Some(b);
40 Ok(())
41 }
42 }
43
44 Place::new(out)
45 }
46}
47
48impl Deserialize for String {
49 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
50 make_place!(Place);
51
52 impl Visitor for Place<String> {
53 fn string(&mut self, s: &str) -> Result<()> {
54 self.out = Some(s.to_owned());
55 Ok(())
56 }
57 }
58
59 Place::new(out)
60 }
61}
62
63macro_rules! signed {
64 ($ty:ident) => {
65 impl Deserialize for $ty {
66 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
67 make_place!(Place);
68
69 impl Visitor for Place<$ty> {
70 fn negative(&mut self, n: i64) -> Result<()> {
71 if n >= $ty::MIN as i64 {
72 self.out = Some(n as $ty);
73 Ok(())
74 } else {
75 Err(Error)
76 }
77 }
78
79 fn nonnegative(&mut self, n: u64) -> Result<()> {
80 if n <= $ty::MAX as u64 {
81 self.out = Some(n as $ty);
82 Ok(())
83 } else {
84 Err(Error)
85 }
86 }
87 }
88
89 Place::new(out)
90 }
91 }
92 };
93}
94signed!(i8);
95signed!(i16);
96signed!(i32);
97signed!(i64);
98signed!(isize);
99
100macro_rules! unsigned {
101 ($ty:ident) => {
102 impl Deserialize for $ty {
103 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
104 make_place!(Place);
105
106 impl Visitor for Place<$ty> {
107 fn nonnegative(&mut self, n: u64) -> Result<()> {
108 if n <= $ty::MAX as u64 {
109 self.out = Some(n as $ty);
110 Ok(())
111 } else {
112 Err(Error)
113 }
114 }
115 }
116
117 Place::new(out)
118 }
119 }
120 };
121}
122unsigned!(u8);
123unsigned!(u16);
124unsigned!(u32);
125unsigned!(u64);
126unsigned!(usize);
127
128macro_rules! float {
129 ($ty:ident) => {
130 impl Deserialize for $ty {
131 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
132 make_place!(Place);
133
134 impl Visitor for Place<$ty> {
135 fn negative(&mut self, n: i64) -> Result<()> {
136 self.out = Some(n as $ty);
137 Ok(())
138 }
139
140 fn nonnegative(&mut self, n: u64) -> Result<()> {
141 self.out = Some(n as $ty);
142 Ok(())
143 }
144
145 fn float(&mut self, n: f64) -> Result<()> {
146 self.out = Some(n as $ty);
147 Ok(())
148 }
149 }
150
151 Place::new(out)
152 }
153 }
154 };
155}
156float!(f32);
157float!(f64);
158
159impl<T> Deserialize for Box<T>
160where
161 T: Deserialize,
162{
163 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
164 make_place!(Place);
165
166 impl<T> Visitor for Place<Box<T>>
167 where
168 T: Deserialize,
169 {
170 fn null(&mut self) -> Result<()> {
171 let mut out = None;
172 Deserialize::begin(&mut out).null()?;
173 self.out = Some(Box::new(out.unwrap()));
174 Ok(())
175 }
176
177 fn boolean(&mut self, b: bool) -> Result<()> {
178 let mut out = None;
179 Deserialize::begin(&mut out).boolean(b)?;
180 self.out = Some(Box::new(out.unwrap()));
181 Ok(())
182 }
183
184 fn string(&mut self, s: &str) -> Result<()> {
185 let mut out = None;
186 Deserialize::begin(&mut out).string(s)?;
187 self.out = Some(Box::new(out.unwrap()));
188 Ok(())
189 }
190
191 fn negative(&mut self, n: i64) -> Result<()> {
192 let mut out = None;
193 Deserialize::begin(&mut out).negative(n)?;
194 self.out = Some(Box::new(out.unwrap()));
195 Ok(())
196 }
197
198 fn nonnegative(&mut self, n: u64) -> Result<()> {
199 let mut out = None;
200 Deserialize::begin(&mut out).nonnegative(n)?;
201 self.out = Some(Box::new(out.unwrap()));
202 Ok(())
203 }
204
205 fn float(&mut self, n: f64) -> Result<()> {
206 let mut out = None;
207 Deserialize::begin(&mut out).float(n)?;
208 self.out = Some(Box::new(out.unwrap()));
209 Ok(())
210 }
211
212 fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
213 let mut value = NonuniqueBox::new(None);
214 let ptr = unsafe { extend_lifetime!(&mut *value as &mut Option<T>) };
215 Ok(Box::new(BoxSeq {
216 out: &mut self.out,
217 value,
218 seq: ManuallyDrop::new(Deserialize::begin(ptr).seq()?),
219 }))
220 }
221
222 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
223 let mut value = NonuniqueBox::new(None);
224 let ptr = unsafe { extend_lifetime!(&mut *value as &mut Option<T>) };
225 Ok(Box::new(BoxMap {
226 out: &mut self.out,
227 value,
228 map: ManuallyDrop::new(Deserialize::begin(ptr).map()?),
229 }))
230 }
231 }
232
233 struct BoxSeq<'a, T: 'a> {
234 out: &'a mut Option<Box<T>>,
235 value: NonuniqueBox<Option<T>>,
236 seq: ManuallyDrop<Box<dyn Seq + 'a>>,
238 }
239
240 impl<'a, T: 'a> Drop for BoxSeq<'a, T> {
241 fn drop(&mut self) {
242 unsafe { ManuallyDrop::drop(&mut self.seq) }
243 }
244 }
245
246 impl<'a, T> Seq for BoxSeq<'a, T>
247 where
248 T: Deserialize,
249 {
250 fn element(&mut self) -> Result<&mut dyn Visitor> {
251 self.seq.element()
252 }
253
254 fn finish(&mut self) -> Result<()> {
255 self.seq.finish()?;
256 *self.seq = Box::new(Ignore);
257 *self.out = Some(Box::new(self.value.take().unwrap()));
258 Ok(())
259 }
260 }
261
262 struct BoxMap<'a, T: 'a> {
263 out: &'a mut Option<Box<T>>,
264 value: NonuniqueBox<Option<T>>,
265 map: ManuallyDrop<Box<dyn Map + 'a>>,
267 }
268
269 impl<'a, T: 'a> Drop for BoxMap<'a, T> {
270 fn drop(&mut self) {
271 unsafe { ManuallyDrop::drop(&mut self.map) }
272 }
273 }
274
275 impl<'a, T> Map for BoxMap<'a, T>
276 where
277 T: Deserialize,
278 {
279 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
280 self.map.key(k)
281 }
282
283 fn finish(&mut self) -> Result<()> {
284 self.map.finish()?;
285 *self.map = Box::new(Ignore);
286 *self.out = Some(Box::new(self.value.take().unwrap()));
287 Ok(())
288 }
289 }
290
291 Place::new(out)
292 }
293}
294
295impl<T> Deserialize for Option<T>
296where
297 T: Deserialize,
298{
299 #[inline]
300 fn default() -> Option<Self> {
301 Some(None)
302 }
303
304 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
305 make_place!(Place);
306
307 impl<T> Visitor for Place<Option<T>>
308 where
309 T: Deserialize,
310 {
311 fn null(&mut self) -> Result<()> {
312 self.out = Some(None);
313 Ok(())
314 }
315
316 fn boolean(&mut self, b: bool) -> Result<()> {
317 self.out = Some(None);
318 Deserialize::begin(self.out.as_mut().unwrap()).boolean(b)
319 }
320
321 fn string(&mut self, s: &str) -> Result<()> {
322 self.out = Some(None);
323 Deserialize::begin(self.out.as_mut().unwrap()).string(s)
324 }
325
326 fn negative(&mut self, n: i64) -> Result<()> {
327 self.out = Some(None);
328 Deserialize::begin(self.out.as_mut().unwrap()).negative(n)
329 }
330
331 fn nonnegative(&mut self, n: u64) -> Result<()> {
332 self.out = Some(None);
333 Deserialize::begin(self.out.as_mut().unwrap()).nonnegative(n)
334 }
335
336 fn float(&mut self, n: f64) -> Result<()> {
337 self.out = Some(None);
338 Deserialize::begin(self.out.as_mut().unwrap()).float(n)
339 }
340
341 fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
342 self.out = Some(None);
343 Deserialize::begin(self.out.as_mut().unwrap()).seq()
344 }
345
346 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
347 self.out = Some(None);
348 Deserialize::begin(self.out.as_mut().unwrap()).map()
349 }
350 }
351
352 Place::new(out)
353 }
354}
355
356impl<A, B> Deserialize for (A, B)
357where
358 A: Deserialize,
359 B: Deserialize,
360{
361 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
362 make_place!(Place);
363
364 impl<A, B> Visitor for Place<(A, B)>
365 where
366 A: Deserialize,
367 B: Deserialize,
368 {
369 fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
370 Ok(Box::new(TupleBuilder {
371 out: &mut self.out,
372 tuple: (None, None),
373 }))
374 }
375 }
376
377 struct TupleBuilder<'a, A: 'a, B: 'a> {
378 out: &'a mut Option<(A, B)>,
379 tuple: (Option<A>, Option<B>),
380 }
381
382 impl<'a, A, B> Seq for TupleBuilder<'a, A, B>
383 where
384 A: Deserialize,
385 B: Deserialize,
386 {
387 fn element(&mut self) -> Result<&mut dyn Visitor> {
388 if self.tuple.0.is_none() {
389 Ok(Deserialize::begin(&mut self.tuple.0))
390 } else if self.tuple.1.is_none() {
391 Ok(Deserialize::begin(&mut self.tuple.1))
392 } else {
393 Err(Error)
394 }
395 }
396
397 fn finish(&mut self) -> Result<()> {
398 if let (Some(a), Some(b)) = (self.tuple.0.take(), self.tuple.1.take()) {
399 *self.out = Some((a, b));
400 Ok(())
401 } else {
402 Err(Error)
403 }
404 }
405 }
406
407 Place::new(out)
408 }
409}
410
411impl<T> Deserialize for Vec<T>
412where
413 T: Deserialize,
414{
415 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
416 make_place!(Place);
417
418 impl<T> Visitor for Place<Vec<T>>
419 where
420 T: Deserialize,
421 {
422 fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
423 Ok(Box::new(VecBuilder {
424 out: &mut self.out,
425 vec: Vec::new(),
426 element: None,
427 }))
428 }
429 }
430
431 struct VecBuilder<'a, T: 'a> {
432 out: &'a mut Option<Vec<T>>,
433 vec: Vec<T>,
434 element: Option<T>,
435 }
436
437 impl<'a, T> VecBuilder<'a, T> {
438 fn shift(&mut self) {
439 if let Some(e) = self.element.take() {
440 self.vec.push(e);
441 }
442 }
443 }
444
445 impl<'a, T> Seq for VecBuilder<'a, T>
446 where
447 T: Deserialize,
448 {
449 fn element(&mut self) -> Result<&mut dyn Visitor> {
450 self.shift();
451 Ok(Deserialize::begin(&mut self.element))
452 }
453
454 fn finish(&mut self) -> Result<()> {
455 self.shift();
456 *self.out = Some(mem::take(&mut self.vec));
457 Ok(())
458 }
459 }
460
461 Place::new(out)
462 }
463}
464
465impl<T, const N: usize> Deserialize for [T; N]
466where
467 T: Deserialize,
468{
469 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
470 make_place!(Place);
471
472 impl<T, const N: usize> Visitor for Place<[T; N]>
473 where
474 T: Deserialize,
475 {
476 fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
477 Ok(Box::new(ArrayBuilder {
478 out: &mut self.out,
479 array: unsafe { MaybeUninit::<[MaybeUninit<T>; N]>::uninit().assume_init() },
480 len: 0,
481 element: None,
482 }))
483 }
484 }
485
486 struct ArrayBuilder<'a, T: 'a, const N: usize> {
487 out: &'a mut Option<[T; N]>,
488 array: [MaybeUninit<T>; N],
489 len: usize,
490 element: Option<T>,
491 }
492
493 impl<'a, T, const N: usize> ArrayBuilder<'a, T, N> {
494 fn shift(&mut self) -> Result<()> {
495 if let Some(e) = self.element.take() {
496 self.array.get_mut(self.len).ok_or(Error)?.write(e);
497 self.len += 1;
498 }
499 Ok(())
500 }
501 }
502
503 impl<'a, T, const N: usize> Seq for ArrayBuilder<'a, T, N>
504 where
505 T: Deserialize,
506 {
507 fn element(&mut self) -> Result<&mut dyn Visitor> {
508 self.shift()?;
509 Ok(Deserialize::begin(&mut self.element))
510 }
511
512 fn finish(&mut self) -> Result<()> {
513 self.shift()?;
514 if self.len < N {
515 return Err(Error);
516 }
517 *self.out = None;
522 *self.out = Some(unsafe { ptr::addr_of_mut!(self.array).cast::<[T; N]>().read() });
523 self.len = 0;
524 Ok(())
525 }
526 }
527
528 impl<'a, T: 'a, const N: usize> Drop for ArrayBuilder<'a, T, N> {
529 fn drop(&mut self) {
530 for element in &mut self.array[..self.len] {
531 unsafe { ptr::drop_in_place(element.assume_init_mut()) };
532 }
533 }
534 }
535
536 Place::new(out)
537 }
538}
539
540#[cfg(feature = "std")]
541impl<K, V, H> Deserialize for HashMap<K, V, H>
542where
543 K: FromStr + Hash + Eq,
544 V: Deserialize,
545 H: BuildHasher + Default,
546{
547 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
548 make_place!(Place);
549
550 impl<K, V, H> Visitor for Place<HashMap<K, V, H>>
551 where
552 K: FromStr + Hash + Eq,
553 V: Deserialize,
554 H: BuildHasher + Default,
555 {
556 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
557 Ok(Box::new(MapBuilder {
558 out: &mut self.out,
559 map: HashMap::with_hasher(H::default()),
560 key: None,
561 value: None,
562 }))
563 }
564 }
565
566 struct MapBuilder<'a, K: 'a, V: 'a, H: 'a> {
567 out: &'a mut Option<HashMap<K, V, H>>,
568 map: HashMap<K, V, H>,
569 key: Option<K>,
570 value: Option<V>,
571 }
572
573 impl<'a, K, V, H> MapBuilder<'a, K, V, H>
574 where
575 K: Hash + Eq,
576 H: BuildHasher,
577 {
578 fn shift(&mut self) {
579 if let (Some(k), Some(v)) = (self.key.take(), self.value.take()) {
580 self.map.insert(k, v);
581 }
582 }
583 }
584
585 impl<'a, K, V, H> Map for MapBuilder<'a, K, V, H>
586 where
587 K: FromStr + Hash + Eq,
588 V: Deserialize,
589 H: BuildHasher + Default,
590 {
591 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
592 self.shift();
593 self.key = Some(match K::from_str(k) {
594 Ok(key) => key,
595 Err(_) => return Err(Error),
596 });
597 Ok(Deserialize::begin(&mut self.value))
598 }
599
600 fn finish(&mut self) -> Result<()> {
601 self.shift();
602 let substitute = HashMap::with_hasher(H::default());
603 *self.out = Some(mem::replace(&mut self.map, substitute));
604 Ok(())
605 }
606 }
607
608 Place::new(out)
609 }
610}
611
612impl<K, V> Deserialize for BTreeMap<K, V>
613where
614 K: FromStr + Ord,
615 V: Deserialize,
616{
617 fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
618 make_place!(Place);
619
620 impl<K, V> Visitor for Place<BTreeMap<K, V>>
621 where
622 K: FromStr + Ord,
623 V: Deserialize,
624 {
625 fn map(&mut self) -> Result<Box<dyn Map + '_>> {
626 Ok(Box::new(MapBuilder {
627 out: &mut self.out,
628 map: BTreeMap::new(),
629 key: None,
630 value: None,
631 }))
632 }
633 }
634
635 struct MapBuilder<'a, K: 'a, V: 'a> {
636 out: &'a mut Option<BTreeMap<K, V>>,
637 map: BTreeMap<K, V>,
638 key: Option<K>,
639 value: Option<V>,
640 }
641
642 impl<'a, K, V> MapBuilder<'a, K, V>
643 where
644 K: Ord,
645 {
646 fn shift(&mut self) {
647 if let (Some(k), Some(v)) = (self.key.take(), self.value.take()) {
648 self.map.insert(k, v);
649 }
650 }
651 }
652
653 impl<'a, K, V> Map for MapBuilder<'a, K, V>
654 where
655 K: FromStr + Ord,
656 V: Deserialize,
657 {
658 fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
659 self.shift();
660 self.key = Some(match K::from_str(k) {
661 Ok(key) => key,
662 Err(_) => return Err(Error),
663 });
664 Ok(Deserialize::begin(&mut self.value))
665 }
666
667 fn finish(&mut self) -> Result<()> {
668 self.shift();
669 *self.out = Some(mem::take(&mut self.map));
670 Ok(())
671 }
672 }
673
674 Place::new(out)
675 }
676}