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

miniconf/impls/
internal.rs
