miniconf/impls/
internal.rs

1use core::any::Any;
2use core::cell::{Cell, RefCell};
3use core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
4
5use serde::{Deserializer, Serializer};
6
7use crate::{
8    Homogeneous, Keys, Named, Numbered, Schema, SerdeError, TreeAny, TreeDeserialize, TreeSchema,
9    TreeSerialize, ValueError,
10};
11
12/////////////////////////////////////////////////////////////////////////////////////////
13
14macro_rules! impl_tuple {
15    ($($i:tt $t:ident)+) => {
16        impl<$($t: TreeSchema),+> TreeSchema for ($($t,)+) {
17            const SCHEMA: &'static Schema = &Schema::numbered(&[$(
18                Numbered::new($t::SCHEMA),
19            )+]);
20        }
21
22        impl<$($t: TreeSerialize),+> TreeSerialize for ($($t,)+) {
23            fn serialize_by_key<S: Serializer>(
24                &self,
25                mut keys: impl Keys,
26                ser: S
27            ) -> Result<S::Ok, SerdeError<S::Error>>
28            {
29                match Self::SCHEMA.next(&mut keys)? {
30                    $($i => self.$i.serialize_by_key(keys, ser),)+
31                    _ => unreachable!()
32                }
33            }
34        }
35
36        impl<'de, $($t: TreeDeserialize<'de>),+> TreeDeserialize<'de> for ($($t,)+) {
37            fn deserialize_by_key<D: Deserializer<'de>>(
38                &mut self,
39                mut keys: impl Keys,
40                de: D
41            ) -> Result<(), SerdeError<D::Error>>
42            {
43                match Self::SCHEMA.next(&mut keys)? {
44                    $($i => self.$i.deserialize_by_key(keys, de),)+
45                    _ => unreachable!()
46                }
47            }
48
49            fn probe_by_key<D: Deserializer<'de>>(
50                mut keys: impl Keys,
51                de: D
52            ) -> Result<(), SerdeError<D::Error>>
53            {
54                match Self::SCHEMA.next(&mut keys)? {
55                    $($i => $t::probe_by_key(keys, de),)+
56                    _ => unreachable!()
57                }
58            }
59        }
60
61        impl<$($t: TreeAny),+> TreeAny for ($($t,)+) {
62            fn ref_any_by_key(
63                &self,
64                mut keys: impl Keys
65            ) -> Result<&dyn Any, ValueError>
66            {
67                match Self::SCHEMA.next(&mut keys)? {
68                    $($i => self.$i.ref_any_by_key(keys),)+
69                    _ => unreachable!()
70                }
71            }
72
73            fn mut_any_by_key(
74                &mut self,
75                mut keys: impl Keys
76            ) -> Result<&mut dyn Any, ValueError>
77            {
78                match Self::SCHEMA.next(&mut keys)? {
79                    $($i => self.$i.mut_any_by_key(keys),)+
80                    _ => unreachable!()
81                }
82            }
83        }
84    }
85}
86impl_tuple!(0 T0);
87impl_tuple!(0 T0 1 T1);
88impl_tuple!(0 T0 1 T1 2 T2);
89impl_tuple!(0 T0 1 T1 2 T2 3 T3);
90impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4);
91impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5);
92impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6);
93impl_tuple!(0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7);
94
95/////////////////////////////////////////////////////////////////////////////////////////
96
97impl<T: TreeSchema, const N: usize> TreeSchema for [T; N] {
98    const SCHEMA: &'static Schema = &Schema::homogeneous(Homogeneous::new(N, T::SCHEMA));
99}
100
101impl<T: TreeSerialize, const N: usize> TreeSerialize for [T; N]
102where
103    Self: TreeSchema,
104{
105    fn serialize_by_key<S: Serializer>(
106        &self,
107        mut keys: impl Keys,
108        ser: S,
109    ) -> Result<S::Ok, SerdeError<S::Error>> {
110        self[Self::SCHEMA.next(&mut keys)?].serialize_by_key(keys, ser)
111    }
112}
113
114impl<'de, T: TreeDeserialize<'de>, const N: usize> TreeDeserialize<'de> for [T; N] {
115    fn deserialize_by_key<D: Deserializer<'de>>(
116        &mut self,
117        mut keys: impl Keys,
118        de: D,
119    ) -> Result<(), SerdeError<D::Error>> {
120        self[Self::SCHEMA.next(&mut keys)?].deserialize_by_key(keys, de)
121    }
122
123    fn probe_by_key<D: Deserializer<'de>>(
124        mut keys: impl Keys,
125        de: D,
126    ) -> Result<(), SerdeError<D::Error>> {
127        Self::SCHEMA.next(&mut keys)?;
128        T::probe_by_key(keys, de)
129    }
130}
131
132impl<T: TreeAny, const N: usize> TreeAny for [T; N] {
133    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
134        self[Self::SCHEMA.next(&mut keys)?].ref_any_by_key(keys)
135    }
136
137    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
138        self[Self::SCHEMA.next(&mut keys)?].mut_any_by_key(keys)
139    }
140}
141
142/////////////////////////////////////////////////////////////////////////////////////////
143
144impl<T: TreeSchema> TreeSchema for Option<T> {
145    const SCHEMA: &'static Schema = T::SCHEMA;
146}
147
148impl<T: TreeSerialize> TreeSerialize for Option<T> {
149    fn serialize_by_key<S: Serializer>(
150        &self,
151        keys: impl Keys,
152        ser: S,
153    ) -> Result<S::Ok, SerdeError<S::Error>> {
154        self.as_ref()
155            .ok_or(ValueError::Absent)?
156            .serialize_by_key(keys, ser)
157    }
158}
159
160impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Option<T> {
161    fn deserialize_by_key<D: Deserializer<'de>>(
162        &mut self,
163        keys: impl Keys,
164        de: D,
165    ) -> Result<(), SerdeError<D::Error>> {
166        self.as_mut()
167            .ok_or(ValueError::Absent)?
168            .deserialize_by_key(keys, de)
169    }
170
171    fn probe_by_key<D: Deserializer<'de>>(
172        keys: impl Keys,
173        de: D,
174    ) -> Result<(), SerdeError<D::Error>> {
175        T::probe_by_key(keys, de)
176    }
177}
178
179impl<T: TreeAny> TreeAny for Option<T> {
180    fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
181        self.as_ref()
182            .ok_or(ValueError::Absent)?
183            .ref_any_by_key(keys)
184    }
185
186    fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
187        self.as_mut()
188            .ok_or(ValueError::Absent)?
189            .mut_any_by_key(keys)
190    }
191}
192
193/////////////////////////////////////////////////////////////////////////////////////////
194
195impl<T: TreeSchema, E: TreeSchema> TreeSchema for Result<T, E> {
196    const SCHEMA: &'static Schema =
197        &Schema::named(&[Named::new("Ok", T::SCHEMA), Named::new("Err", E::SCHEMA)]);
198}
199
200impl<T: TreeSerialize, E: TreeSerialize> TreeSerialize for Result<T, E> {
201    fn serialize_by_key<S: Serializer>(
202        &self,
203        mut keys: impl Keys,
204        ser: S,
205    ) -> Result<S::Ok, SerdeError<S::Error>> {
206        match (self, Self::SCHEMA.next(&mut keys)?) {
207            (Ok(value), 0) => value.serialize_by_key(keys, ser),
208            (Err(value), 1) => value.serialize_by_key(keys, ser),
209            _ => Err(ValueError::Absent.into()),
210        }
211    }
212}
213
214impl<'de, T: TreeDeserialize<'de>, E: TreeDeserialize<'de>> TreeDeserialize<'de> for Result<T, E> {
215    fn deserialize_by_key<D: Deserializer<'de>>(
216        &mut self,
217        mut keys: impl Keys,
218        de: D,
219    ) -> Result<(), SerdeError<D::Error>> {
220        match (self, Self::SCHEMA.next(&mut keys)?) {
221            (Ok(value), 0) => value.deserialize_by_key(keys, de),
222            (Err(value), 1) => value.deserialize_by_key(keys, de),
223            _ => Err(ValueError::Absent.into()),
224        }
225    }
226
227    fn probe_by_key<D: Deserializer<'de>>(
228        mut keys: impl Keys,
229        de: D,
230    ) -> Result<(), SerdeError<D::Error>> {
231        match Self::SCHEMA.next(&mut keys)? {
232            0 => T::probe_by_key(keys, de),
233            1 => E::probe_by_key(keys, de),
234            _ => unreachable!(),
235        }
236    }
237}
238
239impl<T: TreeAny, E: TreeAny> TreeAny for Result<T, E> {
240    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
241        match (self, Self::SCHEMA.next(&mut keys)?) {
242            (Ok(value), 0) => value.ref_any_by_key(keys),
243            (Err(value), 1) => value.ref_any_by_key(keys),
244            _ => Err(ValueError::Absent),
245        }
246    }
247
248    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
249        match (self, Self::SCHEMA.next(&mut keys)?) {
250            (Ok(value), 0) => value.mut_any_by_key(keys),
251            (Err(value), 1) => value.mut_any_by_key(keys),
252            _ => Err(ValueError::Absent),
253        }
254    }
255}
256
257/////////////////////////////////////////////////////////////////////////////////////////
258
259impl<T: TreeSchema> TreeSchema for Bound<T> {
260    const SCHEMA: &'static Schema = &Schema::named(&[
261        Named::new("Included", T::SCHEMA),
262        Named::new("Excluded", T::SCHEMA),
263    ]);
264}
265
266impl<T: TreeSerialize> TreeSerialize for Bound<T> {
267    fn serialize_by_key<S: Serializer>(
268        &self,
269        mut keys: impl Keys,
270        ser: S,
271    ) -> Result<S::Ok, SerdeError<S::Error>> {
272        match (self, Self::SCHEMA.next(&mut keys)?) {
273            (Self::Included(value), 0) | (Self::Excluded(value), 1) => {
274                value.serialize_by_key(keys, ser)
275            }
276            _ => Err(ValueError::Absent.into()),
277        }
278    }
279}
280
281impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Bound<T> {
282    fn deserialize_by_key<D: Deserializer<'de>>(
283        &mut self,
284        mut keys: impl Keys,
285        de: D,
286    ) -> Result<(), SerdeError<D::Error>> {
287        match (self, Self::SCHEMA.next(&mut keys)?) {
288            (Self::Included(value), 0) | (Self::Excluded(value), 1) => {
289                value.deserialize_by_key(keys, de)
290            }
291            _ => Err(ValueError::Absent.into()),
292        }
293    }
294
295    fn probe_by_key<D: Deserializer<'de>>(
296        mut keys: impl Keys,
297        de: D,
298    ) -> Result<(), SerdeError<D::Error>> {
299        match Self::SCHEMA.next(&mut keys)? {
300            0..=1 => T::probe_by_key(keys, de),
301            _ => unreachable!(),
302        }
303    }
304}
305
306impl<T: TreeAny> TreeAny for Bound<T> {
307    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
308        match (self, Self::SCHEMA.next(&mut keys)?) {
309            (Self::Included(value), 0) | (Self::Excluded(value), 1) => value.ref_any_by_key(keys),
310            _ => Err(ValueError::Absent),
311        }
312    }
313
314    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
315        match (self, Self::SCHEMA.next(&mut keys)?) {
316            (Self::Included(value), 0) | (Self::Excluded(value), 1) => value.mut_any_by_key(keys),
317            _ => Err(ValueError::Absent),
318        }
319    }
320}
321
322/////////////////////////////////////////////////////////////////////////////////////////
323
324impl<T: TreeSchema> TreeSchema for Range<T> {
325    const SCHEMA: &'static Schema =
326        &Schema::named(&[Named::new("start", T::SCHEMA), Named::new("end", T::SCHEMA)]);
327}
328
329impl<T: TreeSerialize> TreeSerialize for Range<T> {
330    fn serialize_by_key<S: Serializer>(
331        &self,
332        mut keys: impl Keys,
333        ser: S,
334    ) -> Result<S::Ok, SerdeError<S::Error>> {
335        match Self::SCHEMA.next(&mut keys)? {
336            0 => &self.start,
337            1 => &self.end,
338            _ => unreachable!(),
339        }
340        .serialize_by_key(keys, ser)
341    }
342}
343
344impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Range<T> {
345    fn deserialize_by_key<D: Deserializer<'de>>(
346        &mut self,
347        mut keys: impl Keys,
348        de: D,
349    ) -> Result<(), SerdeError<D::Error>> {
350        match Self::SCHEMA.next(&mut keys)? {
351            0 => &mut self.start,
352            1 => &mut self.end,
353            _ => unreachable!(),
354        }
355        .deserialize_by_key(keys, de)
356    }
357
358    fn probe_by_key<D: Deserializer<'de>>(
359        mut keys: impl Keys,
360        de: D,
361    ) -> Result<(), SerdeError<D::Error>> {
362        match Self::SCHEMA.next(&mut keys)? {
363            0..=1 => T::probe_by_key(keys, de),
364            _ => unreachable!(),
365        }
366    }
367}
368
369impl<T: TreeAny> TreeAny for Range<T> {
370    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
371        match Self::SCHEMA.next(&mut keys)? {
372            0 => &self.start,
373            1 => &self.end,
374            _ => unreachable!(),
375        }
376        .ref_any_by_key(keys)
377    }
378
379    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
380        match Self::SCHEMA.next(&mut keys)? {
381            0 => &mut self.start,
382            1 => &mut self.end,
383            _ => unreachable!(),
384        }
385        .mut_any_by_key(keys)
386    }
387}
388
389/////////////////////////////////////////////////////////////////////////////////////////
390
391impl<T: TreeSchema> TreeSchema for RangeInclusive<T> {
392    const SCHEMA: &'static Schema = Range::<T>::SCHEMA;
393}
394
395impl<T: TreeSerialize> TreeSerialize for RangeInclusive<T> {
396    fn serialize_by_key<S: Serializer>(
397        &self,
398        mut keys: impl Keys,
399        ser: S,
400    ) -> Result<S::Ok, SerdeError<S::Error>> {
401        match Self::SCHEMA.next(&mut keys)? {
402            0 => self.start(),
403            1 => self.end(),
404            _ => unreachable!(),
405        }
406        .serialize_by_key(keys, ser)
407    }
408}
409
410/////////////////////////////////////////////////////////////////////////////////////////
411
412impl<T: TreeSchema> TreeSchema for RangeFrom<T> {
413    const SCHEMA: &'static Schema = &Schema::named(&[Named::new("start", T::SCHEMA)]);
414}
415
416impl<T: TreeSerialize> TreeSerialize for RangeFrom<T> {
417    fn serialize_by_key<S: Serializer>(
418        &self,
419        mut keys: impl Keys,
420        ser: S,
421    ) -> Result<S::Ok, SerdeError<S::Error>> {
422        match Self::SCHEMA.next(&mut keys)? {
423            0 => self.start.serialize_by_key(keys, ser),
424            _ => unreachable!(),
425        }
426    }
427}
428
429impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RangeFrom<T> {
430    fn deserialize_by_key<D: Deserializer<'de>>(
431        &mut self,
432        mut keys: impl Keys,
433        de: D,
434    ) -> Result<(), SerdeError<D::Error>> {
435        match Self::SCHEMA.next(&mut keys)? {
436            0 => self.start.deserialize_by_key(keys, de),
437            _ => unreachable!(),
438        }
439    }
440
441    fn probe_by_key<D: Deserializer<'de>>(
442        mut keys: impl Keys,
443        de: D,
444    ) -> Result<(), SerdeError<D::Error>> {
445        match Self::SCHEMA.next(&mut keys)? {
446            0 => T::probe_by_key(keys, de),
447            _ => unreachable!(),
448        }
449    }
450}
451
452impl<T: TreeAny> TreeAny for RangeFrom<T> {
453    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
454        match Self::SCHEMA.next(&mut keys)? {
455            0 => self.start.ref_any_by_key(keys),
456            _ => unreachable!(),
457        }
458    }
459
460    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
461        match Self::SCHEMA.next(&mut keys)? {
462            0 => self.start.mut_any_by_key(keys),
463            _ => unreachable!(),
464        }
465    }
466}
467
468/////////////////////////////////////////////////////////////////////////////////////////
469
470impl<T: TreeSchema> TreeSchema for RangeTo<T> {
471    const SCHEMA: &'static Schema = &Schema::named(&[Named::new("end", T::SCHEMA)]);
472}
473
474impl<T: TreeSerialize> TreeSerialize for RangeTo<T> {
475    fn serialize_by_key<S: Serializer>(
476        &self,
477        mut keys: impl Keys,
478        ser: S,
479    ) -> Result<S::Ok, SerdeError<S::Error>> {
480        match Self::SCHEMA.next(&mut keys)? {
481            0 => self.end.serialize_by_key(keys, ser),
482            _ => unreachable!(),
483        }
484    }
485}
486
487impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RangeTo<T> {
488    fn deserialize_by_key<D: Deserializer<'de>>(
489        &mut self,
490        mut keys: impl Keys,
491        de: D,
492    ) -> Result<(), SerdeError<D::Error>> {
493        match Self::SCHEMA.next(&mut keys)? {
494            0 => self.end.deserialize_by_key(keys, de),
495            _ => unreachable!(),
496        }
497    }
498
499    fn probe_by_key<D: Deserializer<'de>>(
500        mut keys: impl Keys,
501        de: D,
502    ) -> Result<(), SerdeError<D::Error>> {
503        match Self::SCHEMA.next(&mut keys)? {
504            0 => T::probe_by_key(keys, de),
505            _ => unreachable!(),
506        }
507    }
508}
509
510impl<T: TreeAny> TreeAny for RangeTo<T> {
511    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
512        match Self::SCHEMA.next(&mut keys)? {
513            0 => self.end.ref_any_by_key(keys),
514            _ => unreachable!(),
515        }
516    }
517
518    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
519        match Self::SCHEMA.next(&mut keys)? {
520            0 => self.end.mut_any_by_key(keys),
521            _ => unreachable!(),
522        }
523    }
524}
525
526/////////////////////////////////////////////////////////////////////////////////////////
527
528impl<T: TreeSchema> TreeSchema for Cell<T> {
529    const SCHEMA: &'static Schema = T::SCHEMA;
530}
531
532impl<T: TreeSerialize + Copy> TreeSerialize for Cell<T> {
533    fn serialize_by_key<S: Serializer>(
534        &self,
535        keys: impl Keys,
536        ser: S,
537    ) -> Result<S::Ok, SerdeError<S::Error>> {
538        self.get().serialize_by_key(keys, ser)
539    }
540}
541
542impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Cell<T> {
543    fn deserialize_by_key<D: Deserializer<'de>>(
544        &mut self,
545        keys: impl Keys,
546        de: D,
547    ) -> Result<(), SerdeError<D::Error>> {
548        self.get_mut().deserialize_by_key(keys, de)
549    }
550
551    fn probe_by_key<D: Deserializer<'de>>(
552        keys: impl Keys,
553        de: D,
554    ) -> Result<(), SerdeError<D::Error>> {
555        T::probe_by_key(keys, de)
556    }
557}
558
559impl<T: TreeAny> TreeAny for Cell<T> {
560    fn ref_any_by_key(&self, _keys: impl Keys) -> Result<&dyn Any, ValueError> {
561        Err(ValueError::Access("Can't leak out of Cell"))
562    }
563
564    fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
565        self.get_mut().mut_any_by_key(keys)
566    }
567}
568
569/////////////////////////////////////////////////////////////////////////////////////////
570
571impl<T: TreeSchema> TreeSchema for RefCell<T> {
572    const SCHEMA: &'static Schema = T::SCHEMA;
573}
574
575impl<T: TreeSerialize> TreeSerialize for RefCell<T> {
576    fn serialize_by_key<S: Serializer>(
577        &self,
578        keys: impl Keys,
579        ser: S,
580    ) -> Result<S::Ok, SerdeError<S::Error>> {
581        self.try_borrow()
582            .or(Err(ValueError::Access("Borrowed")))?
583            .serialize_by_key(keys, ser)
584    }
585}
586
587impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RefCell<T> {
588    fn deserialize_by_key<D: Deserializer<'de>>(
589        &mut self,
590        keys: impl Keys,
591        de: D,
592    ) -> Result<(), SerdeError<D::Error>> {
593        self.get_mut().deserialize_by_key(keys, de)
594    }
595
596    fn probe_by_key<D: Deserializer<'de>>(
597        keys: impl Keys,
598        de: D,
599    ) -> Result<(), SerdeError<D::Error>> {
600        T::probe_by_key(keys, de)
601    }
602}
603
604impl<'a, 'de: 'a, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &'a RefCell<T> {
605    fn deserialize_by_key<D: Deserializer<'de>>(
606        &mut self,
607        keys: impl Keys,
608        de: D,
609    ) -> Result<(), SerdeError<D::Error>> {
610        self.try_borrow_mut()
611            .or(Err(ValueError::Access("Borrowed")))?
612            .deserialize_by_key(keys, de)
613    }
614
615    fn probe_by_key<D: Deserializer<'de>>(
616        keys: impl Keys,
617        de: D,
618    ) -> Result<(), SerdeError<D::Error>> {
619        T::probe_by_key(keys, de)
620    }
621}
622
623impl<T: TreeAny> TreeAny for RefCell<T> {
624    fn ref_any_by_key(&self, _keys: impl Keys) -> Result<&dyn Any, ValueError> {
625        Err(ValueError::Access("Can't leak out of RefCell"))
626    }
627
628    fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
629        self.get_mut().mut_any_by_key(keys)
630    }
631}
632
633/////////////////////////////////////////////////////////////////////////////////////////
634
635#[cfg(feature = "alloc")]
636mod _alloc {
637    use super::*;
638    extern crate alloc;
639    use alloc::{
640        borrow::Cow,
641        boxed::Box,
642        rc::{Rc, Weak as RcWeak},
643        sync::{Arc, Weak as SyncWeak},
644    };
645
646    impl<T: TreeSchema> TreeSchema for Box<T> {
647        const SCHEMA: &'static Schema = T::SCHEMA;
648    }
649
650    impl<T: TreeSerialize> TreeSerialize for Box<T> {
651        fn serialize_by_key<S: Serializer>(
652            &self,
653            keys: impl Keys,
654            ser: S,
655        ) -> Result<S::Ok, SerdeError<S::Error>> {
656            (**self).serialize_by_key(keys, ser)
657        }
658    }
659
660    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Box<T> {
661        fn deserialize_by_key<D: Deserializer<'de>>(
662            &mut self,
663            keys: impl Keys,
664            de: D,
665        ) -> Result<(), SerdeError<D::Error>> {
666            (**self).deserialize_by_key(keys, de)
667        }
668
669        fn probe_by_key<D: Deserializer<'de>>(
670            keys: impl Keys,
671            de: D,
672        ) -> Result<(), SerdeError<D::Error>> {
673            T::probe_by_key(keys, de)
674        }
675    }
676
677    impl<T: TreeAny> TreeAny for Box<T> {
678        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
679            (**self).ref_any_by_key(keys)
680        }
681
682        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
683            (**self).mut_any_by_key(keys)
684        }
685    }
686
687    /////////////////////////////////////////////////////////////////////////////////////////
688
689    impl<T: TreeSchema + Clone> TreeSchema for Cow<'_, T> {
690        const SCHEMA: &'static Schema = T::SCHEMA;
691    }
692
693    impl<T: TreeSerialize + Clone> TreeSerialize for Cow<'_, T> {
694        fn serialize_by_key<S: Serializer>(
695            &self,
696            keys: impl Keys,
697            ser: S,
698        ) -> Result<S::Ok, SerdeError<S::Error>> {
699            (**self).serialize_by_key(keys, ser)
700        }
701    }
702
703    impl<'de, T: TreeDeserialize<'de> + Clone> TreeDeserialize<'de> for Cow<'_, T> {
704        fn deserialize_by_key<D: Deserializer<'de>>(
705            &mut self,
706            keys: impl Keys,
707            de: D,
708        ) -> Result<(), SerdeError<D::Error>> {
709            self.to_mut().deserialize_by_key(keys, de)
710        }
711
712        fn probe_by_key<D: Deserializer<'de>>(
713            keys: impl Keys,
714            de: D,
715        ) -> Result<(), SerdeError<D::Error>> {
716            T::probe_by_key(keys, de)
717        }
718    }
719
720    impl<T: TreeAny + Clone> TreeAny for Cow<'_, T> {
721        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
722            (**self).ref_any_by_key(keys)
723        }
724
725        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
726            self.to_mut().mut_any_by_key(keys)
727        }
728    }
729
730    /////////////////////////////////////////////////////////////////////////////////////////
731
732    impl<T: TreeSchema> TreeSchema for Rc<T> {
733        const SCHEMA: &'static Schema = T::SCHEMA;
734    }
735
736    impl<T: TreeSerialize> TreeSerialize for Rc<T> {
737        fn serialize_by_key<S: Serializer>(
738            &self,
739            keys: impl Keys,
740            ser: S,
741        ) -> Result<S::Ok, SerdeError<S::Error>> {
742            (**self).serialize_by_key(keys, ser)
743        }
744    }
745
746    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Rc<T> {
747        fn deserialize_by_key<D: Deserializer<'de>>(
748            &mut self,
749            keys: impl Keys,
750            de: D,
751        ) -> Result<(), SerdeError<D::Error>> {
752            Rc::get_mut(self)
753                .ok_or(ValueError::Access("Reference is taken"))?
754                .deserialize_by_key(keys, de)
755        }
756
757        fn probe_by_key<D: Deserializer<'de>>(
758            keys: impl Keys,
759            de: D,
760        ) -> Result<(), SerdeError<D::Error>> {
761            T::probe_by_key(keys, de)
762        }
763    }
764
765    impl<T: TreeAny> TreeAny for Rc<T> {
766        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
767            (**self).ref_any_by_key(keys)
768        }
769
770        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
771            Rc::get_mut(self)
772                .ok_or(ValueError::Access("Reference is taken"))?
773                .mut_any_by_key(keys)
774        }
775    }
776
777    /////////////////////////////////////////////////////////////////////////////////////////
778
779    impl<T: TreeSchema> TreeSchema for RcWeak<T> {
780        const SCHEMA: &'static Schema = T::SCHEMA;
781    }
782
783    impl<T: TreeSerialize> TreeSerialize for RcWeak<T> {
784        fn serialize_by_key<S: Serializer>(
785            &self,
786            keys: impl Keys,
787            ser: S,
788        ) -> Result<S::Ok, SerdeError<S::Error>> {
789            self.upgrade()
790                .ok_or(ValueError::Absent)?
791                .serialize_by_key(keys, ser)
792        }
793    }
794
795    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RcWeak<T> {
796        fn deserialize_by_key<D: Deserializer<'de>>(
797            &mut self,
798            keys: impl Keys,
799            de: D,
800        ) -> Result<(), SerdeError<D::Error>> {
801            self.upgrade()
802                .ok_or(ValueError::Absent)?
803                .deserialize_by_key(keys, de)
804        }
805
806        fn probe_by_key<D: Deserializer<'de>>(
807            keys: impl Keys,
808            de: D,
809        ) -> Result<(), SerdeError<D::Error>> {
810            T::probe_by_key(keys, de)
811        }
812    }
813
814    /////////////////////////////////////////////////////////////////////////////////////////
815
816    impl<T: TreeSchema> TreeSchema for Arc<T> {
817        const SCHEMA: &'static Schema = T::SCHEMA;
818    }
819
820    impl<T: TreeSerialize> TreeSerialize for Arc<T> {
821        fn serialize_by_key<S: Serializer>(
822            &self,
823            keys: impl Keys,
824            ser: S,
825        ) -> Result<S::Ok, SerdeError<S::Error>> {
826            (**self).serialize_by_key(keys, ser)
827        }
828    }
829
830    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Arc<T> {
831        fn deserialize_by_key<D: Deserializer<'de>>(
832            &mut self,
833            keys: impl Keys,
834            de: D,
835        ) -> Result<(), SerdeError<D::Error>> {
836            Arc::get_mut(self)
837                .ok_or(ValueError::Access("Reference is taken"))?
838                .deserialize_by_key(keys, de)
839        }
840
841        fn probe_by_key<D: Deserializer<'de>>(
842            keys: impl Keys,
843            de: D,
844        ) -> Result<(), SerdeError<D::Error>> {
845            T::probe_by_key(keys, de)
846        }
847    }
848
849    impl<T: TreeAny> TreeAny for Arc<T> {
850        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
851            (**self).ref_any_by_key(keys)
852        }
853
854        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
855            Arc::get_mut(self)
856                .ok_or(ValueError::Access("Reference is taken"))?
857                .mut_any_by_key(keys)
858        }
859    }
860
861    /////////////////////////////////////////////////////////////////////////////////////////
862
863    impl<T: TreeSchema> TreeSchema for SyncWeak<T> {
864        const SCHEMA: &'static Schema = T::SCHEMA;
865    }
866
867    impl<T: TreeSerialize> TreeSerialize for SyncWeak<T> {
868        fn serialize_by_key<S: Serializer>(
869            &self,
870            keys: impl Keys,
871            ser: S,
872        ) -> Result<S::Ok, SerdeError<S::Error>> {
873            self.upgrade()
874                .ok_or(ValueError::Absent)?
875                .serialize_by_key(keys, ser)
876        }
877    }
878
879    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for SyncWeak<T> {
880        fn deserialize_by_key<D: Deserializer<'de>>(
881            &mut self,
882            keys: impl Keys,
883            de: D,
884        ) -> Result<(), SerdeError<D::Error>> {
885            self.upgrade()
886                .ok_or(ValueError::Absent)?
887                .deserialize_by_key(keys, de)
888        }
889
890        fn probe_by_key<D: Deserializer<'de>>(
891            keys: impl Keys,
892            de: D,
893        ) -> Result<(), SerdeError<D::Error>> {
894            T::probe_by_key(keys, de)
895        }
896    }
897}
898
899/////////////////////////////////////////////////////////////////////////////////////////
900
901#[cfg(feature = "std")]
902mod _std {
903    use super::*;
904    use std::sync::{Mutex, RwLock};
905
906    impl<T: TreeSchema> TreeSchema for Mutex<T> {
907        const SCHEMA: &'static Schema = T::SCHEMA;
908    }
909
910    impl<T: TreeSerialize> TreeSerialize for Mutex<T> {
911        fn serialize_by_key<S: Serializer>(
912            &self,
913            keys: impl Keys,
914            ser: S,
915        ) -> Result<S::Ok, SerdeError<S::Error>> {
916            self.lock()
917                .or(Err(ValueError::Access("Poisoned")))?
918                .serialize_by_key(keys, ser)
919        }
920    }
921
922    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Mutex<T> {
923        fn deserialize_by_key<D: Deserializer<'de>>(
924            &mut self,
925            keys: impl Keys,
926            de: D,
927        ) -> Result<(), SerdeError<D::Error>> {
928            self.get_mut()
929                .or(Err(ValueError::Access("Poisoned")))?
930                .deserialize_by_key(keys, de)
931        }
932
933        fn probe_by_key<D: Deserializer<'de>>(
934            keys: impl Keys,
935            de: D,
936        ) -> Result<(), SerdeError<D::Error>> {
937            T::probe_by_key(keys, de)
938        }
939    }
940
941    impl<'a, 'de: 'a, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &'a Mutex<T> {
942        fn deserialize_by_key<D: Deserializer<'de>>(
943            &mut self,
944            keys: impl Keys,
945            de: D,
946        ) -> Result<(), SerdeError<D::Error>> {
947            (*self)
948                .lock()
949                .or(Err(ValueError::Access("Poisoned")))?
950                .deserialize_by_key(keys, de)
951        }
952
953        fn probe_by_key<D: Deserializer<'de>>(
954            keys: impl Keys,
955            de: D,
956        ) -> Result<(), SerdeError<D::Error>> {
957            T::probe_by_key(keys, de)
958        }
959    }
960
961    impl<T: TreeAny> TreeAny for Mutex<T> {
962        fn ref_any_by_key(&self, _keys: impl Keys) -> Result<&dyn Any, ValueError> {
963            Err(ValueError::Access("Can't leak out of Mutex"))
964        }
965
966        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
967            self.get_mut()
968                .or(Err(ValueError::Access("Poisoned")))?
969                .mut_any_by_key(keys)
970        }
971    }
972
973    /////////////////////////////////////////////////////////////////////////////////////////
974
975    impl<T: TreeSchema> TreeSchema for RwLock<T> {
976        const SCHEMA: &'static Schema = T::SCHEMA;
977    }
978
979    impl<T: TreeSerialize> TreeSerialize for RwLock<T> {
980        fn serialize_by_key<S: Serializer>(
981            &self,
982            keys: impl Keys,
983            ser: S,
984        ) -> Result<S::Ok, SerdeError<S::Error>> {
985            self.read()
986                .or(Err(ValueError::Access("Poisoned")))?
987                .serialize_by_key(keys, ser)
988        }
989    }
990
991    impl<'a, 'de: 'a, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &'a RwLock<T> {
992        fn deserialize_by_key<D: Deserializer<'de>>(
993            &mut self,
994            keys: impl Keys,
995            de: D,
996        ) -> Result<(), SerdeError<D::Error>> {
997            self.write()
998                .or(Err(ValueError::Access("Poisoned")))?
999                .deserialize_by_key(keys, de)
1000        }
1001
1002        fn probe_by_key<D: Deserializer<'de>>(
1003            keys: impl Keys,
1004            de: D,
1005        ) -> Result<(), SerdeError<D::Error>> {
1006            T::probe_by_key(keys, de)
1007        }
1008    }
1009
1010    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RwLock<T> {
1011        fn deserialize_by_key<D: Deserializer<'de>>(
1012            &mut self,
1013            keys: impl Keys,
1014            de: D,
1015        ) -> Result<(), SerdeError<D::Error>> {
1016            self.get_mut()
1017                .or(Err(ValueError::Access("Poisoned")))?
1018                .deserialize_by_key(keys, de)
1019        }
1020
1021        fn probe_by_key<D: Deserializer<'de>>(
1022            keys: impl Keys,
1023            de: D,
1024        ) -> Result<(), SerdeError<D::Error>> {
1025            T::probe_by_key(keys, de)
1026        }
1027    }
1028
1029    impl<T: TreeAny> TreeAny for RwLock<T> {
1030        fn ref_any_by_key(&self, _keys: impl Keys) -> Result<&dyn Any, ValueError> {
1031            Err(ValueError::Access("Can't leak out of RwLock"))
1032        }
1033
1034        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
1035            self.get_mut()
1036                .or(Err(ValueError::Access("Poisoned")))?
1037                .mut_any_by_key(keys)
1038        }
1039    }
1040}
1041
1042/////////////////////////////////////////////////////////////////////////////////////////
1043// Transparent newtypes
1044
1045macro_rules! impl_newtype {
1046    (($gen:ident), $ty:ty) => {
1047        impl<$gen: TreeSchema> TreeSchema for $ty {
1048            const SCHEMA: &'static Schema = $gen::SCHEMA;
1049        }
1050
1051        impl<$gen: TreeSerialize> TreeSerialize for $ty {
1052            fn serialize_by_key<S: Serializer>(
1053                &self,
1054                keys: impl Keys,
1055                ser: S,
1056            ) -> Result<S::Ok, SerdeError<S::Error>> {
1057                self.0.serialize_by_key(keys, ser)
1058            }
1059        }
1060
1061        impl<'de, $gen: TreeDeserialize<'de>> TreeDeserialize<'de> for $ty {
1062            fn deserialize_by_key<D: Deserializer<'de>>(
1063                &mut self,
1064                keys: impl Keys,
1065                de: D,
1066            ) -> Result<(), SerdeError<D::Error>> {
1067                self.0.deserialize_by_key(keys, de)
1068            }
1069
1070            fn probe_by_key<D: Deserializer<'de>>(
1071                keys: impl Keys,
1072                de: D,
1073            ) -> Result<(), SerdeError<D::Error>> {
1074                $gen::probe_by_key(keys, de)
1075            }
1076        }
1077
1078        impl<$gen: TreeAny> TreeAny for $ty {
1079            fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
1080                self.0.ref_any_by_key(keys)
1081            }
1082
1083            fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
1084                self.0.mut_any_by_key(keys)
1085            }
1086        }
1087    };
1088}
1089
1090impl_newtype! {(T), core::num::Wrapping<T>}
miniconf/impls/internal.rs

miniconf/impls/
internal.rs
