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

miniconf/impls/
internal.rs
