miniserde/de/
impls.rs

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            // May borrow from self.value, so must drop first.
237            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            // May borrow from self.value, so must drop first.
266            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                // First drop any array that is already in the Place. This way
518                // we can atomically move self.array into it and reset self.len
519                // to 0, without the possibility of a panic between those two
520                // steps.
521                *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}