miniconf/
impls.rs

1use core::cell::{Cell, RefCell};
2use core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
3use core::{any::Any, num::NonZero};
4
5use serde::{Deserializer, Serializer};
6
7use crate::{
8    Error, KeyLookup, Keys, Traversal, TreeAny, TreeDeserialize, TreeKey, TreeSerialize, Walk,
9};
10
11/////////////////////////////////////////////////////////////////////////////////////////
12
13macro_rules! impl_tuple {
14    ($n:literal $($i:tt $t:ident)+) => {
15        #[allow(unreachable_code, unused_mut, unused)]
16        impl<$($t: TreeKey),+> TreeKey for ($($t,)+) {
17            fn traverse_all<W: Walk>() -> W {
18                W::internal(&[$($t::traverse_all(), )+], &KeyLookup::numbered($n))
19            }
20
21            fn traverse_by_key<K, F, E>(mut keys: K, mut func: F) -> Result<usize, Error<E>>
22            where
23                K: Keys,
24                F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
25            {
26                let k = KeyLookup::numbered($n);
27                let index = keys.next(&k)?;
28                func(index, None, k.len()).map_err(|err| Error::Inner(1, err))?;
29                match index {
30                    $($i => $t::traverse_by_key(keys, func),)+
31                    _ => unreachable!()
32                }
33                .map_err(Error::increment)
34                .map(|depth| depth + 1)
35            }
36        }
37
38        #[allow(unreachable_code, unused_mut, unused)]
39        impl<$($t: TreeSerialize),+> TreeSerialize for ($($t,)+) {
40            fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
41            where
42                K: Keys,
43                S: Serializer,
44            {
45                let index = keys.next(&KeyLookup::numbered($n))?;
46                match index {
47                    $($i => self.$i.serialize_by_key(keys, ser),)+
48                    _ => unreachable!()
49                }.map_err(Error::increment)
50            }
51        }
52
53        #[allow(unreachable_code, unused_mut, unused)]
54        impl<'de, $($t: TreeDeserialize<'de>),+> TreeDeserialize<'de> for ($($t,)+) {
55            fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
56            where
57                K: Keys,
58                D: Deserializer<'de>,
59            {
60                let index = keys.next(&KeyLookup::numbered($n))?;
61                match index {
62                    $($i => self.$i.deserialize_by_key(keys, de),)+
63                    _ => unreachable!()
64                }.map_err(Error::increment)
65            }
66
67            fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
68            where
69                K: Keys,
70                D: Deserializer<'de>,
71            {
72                let index = keys.next(&KeyLookup::numbered($n))?;
73                match index {
74                    $($i => $t::probe_by_key(keys, de),)+
75                    _ => unreachable!()
76                }.map_err(Error::increment)
77            }
78        }
79
80        #[allow(unreachable_code, unused_mut, unused)]
81        impl<$($t: TreeAny),+> TreeAny for ($($t,)+) {
82            fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
83            where
84                K: Keys,
85            {
86                let index = keys.next(&KeyLookup::numbered($n))?;
87                match index {
88                    $($i => self.$i.ref_any_by_key(keys),)+
89                    _ => unreachable!()
90                }.map_err(Traversal::increment)
91            }
92
93            fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
94            where
95                K: Keys,
96            {
97                let index = keys.next(&KeyLookup::numbered($n))?;
98                match index {
99                    $($i => self.$i.mut_any_by_key(keys),)+
100                    _ => unreachable!()
101                }.map_err(Traversal::increment)
102            }
103        }
104    }
105}
106// Note: internal nodes must have at least one leaf
107impl_tuple!(1 0 T0);
108impl_tuple!(2 0 T0 1 T1);
109impl_tuple!(3 0 T0 1 T1 2 T2);
110impl_tuple!(4 0 T0 1 T1 2 T2 3 T3);
111impl_tuple!(5 0 T0 1 T1 2 T2 3 T3 4 T4);
112impl_tuple!(6 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5);
113impl_tuple!(7 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6);
114impl_tuple!(8 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7);
115
116/////////////////////////////////////////////////////////////////////////////////////////
117
118struct Assert<const L: usize, const R: usize>;
119impl<const L: usize, const R: usize> Assert<L, R> {
120    const GREATER: () = assert!(L > R);
121}
122
123impl<T: TreeKey, const N: usize> TreeKey for [T; N] {
124    fn traverse_all<W: Walk>() -> W {
125        let () = Assert::<N, 0>::GREATER; // internal nodes must have at least one leaf
126        W::internal(&[T::traverse_all()], &KeyLookup::homogeneous(N))
127    }
128
129    fn traverse_by_key<K, F, E>(mut keys: K, mut func: F) -> Result<usize, Error<E>>
130    where
131        K: Keys,
132        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
133    {
134        let () = Assert::<N, 0>::GREATER; // internal nodes must have at least one leaf
135        let k = KeyLookup::homogeneous(N);
136        let index = keys.next(&k)?;
137        func(index, None, k.len()).map_err(|err| Error::Inner(1, err))?;
138        T::traverse_by_key(keys, func)
139            .map_err(Error::increment)
140            .map(|depth| depth + 1)
141    }
142}
143
144impl<T: TreeSerialize, const N: usize> TreeSerialize for [T; N] {
145    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
146    where
147        K: Keys,
148        S: Serializer,
149    {
150        let index = keys.next(&KeyLookup::homogeneous(N))?;
151        self[index]
152            .serialize_by_key(keys, ser)
153            .map_err(Error::increment)
154    }
155}
156
157impl<'de, T: TreeDeserialize<'de>, const N: usize> TreeDeserialize<'de> for [T; N] {
158    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
159    where
160        K: Keys,
161        D: Deserializer<'de>,
162    {
163        let index = keys.next(&KeyLookup::homogeneous(N))?;
164        self[index]
165            .deserialize_by_key(keys, de)
166            .map_err(Error::increment)
167    }
168
169    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
170    where
171        K: Keys,
172        D: Deserializer<'de>,
173    {
174        keys.next(&KeyLookup::homogeneous(N))?;
175        T::probe_by_key(keys, de).map_err(Error::increment)
176    }
177}
178
179impl<T: TreeAny, const N: usize> TreeAny for [T; N] {
180    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
181    where
182        K: Keys,
183    {
184        let index = keys.next(&KeyLookup::homogeneous(N))?;
185        self[index]
186            .ref_any_by_key(keys)
187            .map_err(Traversal::increment)
188    }
189
190    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
191    where
192        K: Keys,
193    {
194        let index = keys.next(&KeyLookup::homogeneous(N))?;
195        self[index]
196            .mut_any_by_key(keys)
197            .map_err(Traversal::increment)
198    }
199}
200
201/////////////////////////////////////////////////////////////////////////////////////////
202
203impl<T: TreeKey> TreeKey for Option<T> {
204    #[inline]
205    fn traverse_all<W: Walk>() -> W {
206        T::traverse_all()
207    }
208
209    #[inline]
210    fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
211    where
212        K: Keys,
213        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
214    {
215        T::traverse_by_key(keys, func)
216    }
217}
218
219impl<T: TreeSerialize> TreeSerialize for Option<T> {
220    #[inline]
221    fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
222    where
223        K: Keys,
224        S: Serializer,
225    {
226        self.as_ref()
227            .ok_or(Traversal::Absent(0))?
228            .serialize_by_key(keys, ser)
229    }
230}
231
232impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Option<T> {
233    #[inline]
234    fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
235    where
236        K: Keys,
237        D: Deserializer<'de>,
238    {
239        self.as_mut()
240            .ok_or(Traversal::Absent(0))?
241            .deserialize_by_key(keys, de)
242    }
243
244    #[inline]
245    fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
246    where
247        K: Keys,
248        D: Deserializer<'de>,
249    {
250        T::probe_by_key(keys, de)
251    }
252}
253
254impl<T: TreeAny> TreeAny for Option<T> {
255    #[inline]
256    fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>
257    where
258        K: Keys,
259    {
260        self.as_ref()
261            .ok_or(Traversal::Absent(0))?
262            .ref_any_by_key(keys)
263    }
264
265    #[inline]
266    fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
267    where
268        K: Keys,
269    {
270        self.as_mut()
271            .ok_or(Traversal::Absent(0))?
272            .mut_any_by_key(keys)
273    }
274}
275
276/////////////////////////////////////////////////////////////////////////////////////////
277
278const RESULT_LOOKUP: KeyLookup = KeyLookup::named(&["Ok", "Err"]);
279
280impl<T: TreeKey, E: TreeKey> TreeKey for Result<T, E> {
281    #[inline]
282    fn traverse_all<W: Walk>() -> W {
283        W::internal(&[T::traverse_all(), E::traverse_all()], &RESULT_LOOKUP)
284    }
285
286    #[inline]
287    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
288    where
289        K: Keys,
290        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
291    {
292        match keys.next(&RESULT_LOOKUP)? {
293            0 => T::traverse_by_key(keys, func),
294            1 => E::traverse_by_key(keys, func),
295            _ => unreachable!(),
296        }
297        .map_err(Error::increment)
298        .map(|depth| depth + 1)
299    }
300}
301
302impl<T: TreeSerialize, E: TreeSerialize> TreeSerialize for Result<T, E> {
303    #[inline]
304    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
305    where
306        K: Keys,
307        S: Serializer,
308    {
309        match (self, keys.next(&RESULT_LOOKUP)?) {
310            (Ok(value), 0) => value.serialize_by_key(keys, ser),
311            (Err(value), 1) => value.serialize_by_key(keys, ser),
312            _ => Err(Traversal::Absent(0).into()),
313        }
314        .map_err(Error::increment)
315    }
316}
317
318impl<'de, T: TreeDeserialize<'de>, E: TreeDeserialize<'de>> TreeDeserialize<'de> for Result<T, E> {
319    #[inline]
320    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
321    where
322        K: Keys,
323        D: Deserializer<'de>,
324    {
325        match (self, keys.next(&RESULT_LOOKUP)?) {
326            (Ok(value), 0) => value.deserialize_by_key(keys, de),
327            (Err(value), 1) => value.deserialize_by_key(keys, de),
328            _ => Err(Traversal::Absent(0).into()),
329        }
330        .map_err(Error::increment)
331    }
332
333    #[inline]
334    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
335    where
336        K: Keys,
337        D: Deserializer<'de>,
338    {
339        match keys.next(&RESULT_LOOKUP)? {
340            0 => T::probe_by_key(keys, de),
341            1 => E::probe_by_key(keys, de),
342            _ => unreachable!(),
343        }
344        .map_err(Error::increment)
345    }
346}
347
348impl<T: TreeAny, E: TreeAny> TreeAny for Result<T, E> {
349    #[inline]
350    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
351    where
352        K: Keys,
353    {
354        match (self, keys.next(&RESULT_LOOKUP)?) {
355            (Ok(value), 0) => value.ref_any_by_key(keys),
356            (Err(value), 1) => value.ref_any_by_key(keys),
357            _ => Err(Traversal::Absent(0)),
358        }
359        .map_err(Traversal::increment)
360    }
361
362    #[inline]
363    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
364    where
365        K: Keys,
366    {
367        match (self, keys.next(&RESULT_LOOKUP)?) {
368            (Ok(value), 0) => value.mut_any_by_key(keys),
369            (Err(value), 1) => value.mut_any_by_key(keys),
370            _ => Err(Traversal::Absent(0)),
371        }
372        .map_err(Traversal::increment)
373    }
374}
375
376/////////////////////////////////////////////////////////////////////////////////////////
377
378const BOUND_LOOKUP: KeyLookup = KeyLookup::named(&["Included", "Excluded"]);
379
380impl<T: TreeKey> TreeKey for Bound<T> {
381    #[inline]
382    fn traverse_all<W: Walk>() -> W {
383        W::internal(&[T::traverse_all(), T::traverse_all()], &BOUND_LOOKUP)
384    }
385
386    #[inline]
387    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
388    where
389        K: Keys,
390        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
391    {
392        match keys.next(&BOUND_LOOKUP)? {
393            0..=1 => T::traverse_by_key(keys, func),
394            _ => unreachable!(),
395        }
396        .map_err(Error::increment)
397        .map(|depth| depth + 1)
398    }
399}
400
401impl<T: TreeSerialize> TreeSerialize for Bound<T> {
402    #[inline]
403    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
404    where
405        K: Keys,
406        S: Serializer,
407    {
408        match (self, keys.next(&BOUND_LOOKUP)?) {
409            (Self::Included(value), 0) | (Self::Excluded(value), 1) => {
410                value.serialize_by_key(keys, ser)
411            }
412            _ => Err(Traversal::Absent(0).into()),
413        }
414        .map_err(Error::increment)
415    }
416}
417
418impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Bound<T> {
419    #[inline]
420    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
421    where
422        K: Keys,
423        D: Deserializer<'de>,
424    {
425        match (self, keys.next(&BOUND_LOOKUP)?) {
426            (Self::Included(value), 0) | (Self::Excluded(value), 1) => {
427                value.deserialize_by_key(keys, de)
428            }
429            _ => Err(Traversal::Absent(0).into()),
430        }
431        .map_err(Error::increment)
432    }
433
434    #[inline]
435    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
436    where
437        K: Keys,
438        D: Deserializer<'de>,
439    {
440        match keys.next(&RESULT_LOOKUP)? {
441            0..=1 => T::probe_by_key(keys, de),
442            _ => unreachable!(),
443        }
444        .map_err(Error::increment)
445    }
446}
447
448impl<T: TreeAny> TreeAny for Bound<T> {
449    #[inline]
450    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
451    where
452        K: Keys,
453    {
454        match (self, keys.next(&BOUND_LOOKUP)?) {
455            (Self::Included(value), 0) | (Self::Excluded(value), 1) => value.ref_any_by_key(keys),
456            _ => Err(Traversal::Absent(0)),
457        }
458        .map_err(Traversal::increment)
459    }
460
461    #[inline]
462    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
463    where
464        K: Keys,
465    {
466        match (self, keys.next(&BOUND_LOOKUP)?) {
467            (Self::Included(value), 0) | (Self::Excluded(value), 1) => value.mut_any_by_key(keys),
468            _ => Err(Traversal::Absent(0)),
469        }
470        .map_err(Traversal::increment)
471    }
472}
473
474/////////////////////////////////////////////////////////////////////////////////////////
475
476const RANGE_LOOKUP: KeyLookup = KeyLookup::named(&["start", "end"]);
477
478impl<T: TreeKey> TreeKey for Range<T> {
479    #[inline]
480    fn traverse_all<W: Walk>() -> W {
481        W::internal(&[T::traverse_all(), T::traverse_all()], &RANGE_LOOKUP)
482    }
483
484    #[inline]
485    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
486    where
487        K: Keys,
488        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
489    {
490        match keys.next(&RANGE_LOOKUP)? {
491            0..=1 => T::traverse_by_key(keys, func),
492            _ => unreachable!(),
493        }
494        .map_err(Error::increment)
495        .map(|depth| depth + 1)
496    }
497}
498
499impl<T: TreeSerialize> TreeSerialize for Range<T> {
500    #[inline]
501    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
502    where
503        K: Keys,
504        S: Serializer,
505    {
506        match keys.next(&RANGE_LOOKUP)? {
507            0 => self.start.serialize_by_key(keys, ser),
508            1 => self.end.serialize_by_key(keys, ser),
509            _ => unreachable!(),
510        }
511        .map_err(Error::increment)
512    }
513}
514
515impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Range<T> {
516    #[inline]
517    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
518    where
519        K: Keys,
520        D: Deserializer<'de>,
521    {
522        match keys.next(&RANGE_LOOKUP)? {
523            0 => self.start.deserialize_by_key(keys, de),
524            1 => self.end.deserialize_by_key(keys, de),
525            _ => unreachable!(),
526        }
527        .map_err(Error::increment)
528    }
529
530    #[inline]
531    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
532    where
533        K: Keys,
534        D: Deserializer<'de>,
535    {
536        match keys.next(&RESULT_LOOKUP)? {
537            0..=1 => T::probe_by_key(keys, de),
538            _ => unreachable!(),
539        }
540        .map_err(Error::increment)
541    }
542}
543
544impl<T: TreeAny> TreeAny for Range<T> {
545    #[inline]
546    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
547    where
548        K: Keys,
549    {
550        match keys.next(&RANGE_LOOKUP)? {
551            0 => self.start.ref_any_by_key(keys),
552            1 => self.end.ref_any_by_key(keys),
553            _ => unreachable!(),
554        }
555        .map_err(Traversal::increment)
556    }
557
558    #[inline]
559    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
560    where
561        K: Keys,
562    {
563        match keys.next(&RANGE_LOOKUP)? {
564            0 => self.start.mut_any_by_key(keys),
565            1 => self.end.mut_any_by_key(keys),
566            _ => unreachable!(),
567        }
568        .map_err(Traversal::increment)
569    }
570}
571
572/////////////////////////////////////////////////////////////////////////////////////////
573
574impl<T: TreeKey> TreeKey for RangeInclusive<T> {
575    #[inline]
576    fn traverse_all<W: Walk>() -> W {
577        W::internal(&[T::traverse_all(), T::traverse_all()], &RANGE_LOOKUP)
578    }
579
580    #[inline]
581    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
582    where
583        K: Keys,
584        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
585    {
586        match keys.next(&RANGE_LOOKUP)? {
587            0..=1 => T::traverse_by_key(keys, func),
588            _ => unreachable!(),
589        }
590        .map_err(Error::increment)
591        .map(|depth| depth + 1)
592    }
593}
594
595impl<T: TreeSerialize> TreeSerialize for RangeInclusive<T> {
596    #[inline]
597    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
598    where
599        K: Keys,
600        S: Serializer,
601    {
602        match keys.next(&RANGE_LOOKUP)? {
603            0 => self.start().serialize_by_key(keys, ser),
604            1 => self.end().serialize_by_key(keys, ser),
605            _ => unreachable!(),
606        }
607        .map_err(Error::increment)
608    }
609}
610
611/////////////////////////////////////////////////////////////////////////////////////////
612
613const RANGE_FROM_LOOKUP: KeyLookup = KeyLookup::named(&["start"]);
614
615impl<T: TreeKey> TreeKey for RangeFrom<T> {
616    #[inline]
617    fn traverse_all<W: Walk>() -> W {
618        W::internal(&[T::traverse_all()], &RANGE_FROM_LOOKUP)
619    }
620
621    #[inline]
622    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
623    where
624        K: Keys,
625        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
626    {
627        match keys.next(&RANGE_FROM_LOOKUP)? {
628            0 => T::traverse_by_key(keys, func),
629            _ => unreachable!(),
630        }
631        .map_err(Error::increment)
632        .map(|depth| depth + 1)
633    }
634}
635
636impl<T: TreeSerialize> TreeSerialize for RangeFrom<T> {
637    #[inline]
638    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
639    where
640        K: Keys,
641        S: Serializer,
642    {
643        match keys.next(&RANGE_FROM_LOOKUP)? {
644            0 => self.start.serialize_by_key(keys, ser),
645            _ => unreachable!(),
646        }
647        .map_err(Error::increment)
648    }
649}
650
651impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RangeFrom<T> {
652    #[inline]
653    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
654    where
655        K: Keys,
656        D: Deserializer<'de>,
657    {
658        match keys.next(&RANGE_FROM_LOOKUP)? {
659            0 => self.start.deserialize_by_key(keys, de),
660            _ => unreachable!(),
661        }
662        .map_err(Error::increment)
663    }
664
665    #[inline]
666    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
667    where
668        K: Keys,
669        D: Deserializer<'de>,
670    {
671        match keys.next(&RESULT_LOOKUP)? {
672            0 => T::probe_by_key(keys, de),
673            _ => unreachable!(),
674        }
675        .map_err(Error::increment)
676    }
677}
678
679impl<T: TreeAny> TreeAny for RangeFrom<T> {
680    #[inline]
681    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
682    where
683        K: Keys,
684    {
685        match keys.next(&RANGE_FROM_LOOKUP)? {
686            0 => self.start.ref_any_by_key(keys),
687            _ => unreachable!(),
688        }
689        .map_err(Traversal::increment)
690    }
691
692    #[inline]
693    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
694    where
695        K: Keys,
696    {
697        match keys.next(&RANGE_FROM_LOOKUP)? {
698            0 => self.start.mut_any_by_key(keys),
699            _ => unreachable!(),
700        }
701        .map_err(Traversal::increment)
702    }
703}
704
705/////////////////////////////////////////////////////////////////////////////////////////
706
707const RANGE_TO_LOOKUP: KeyLookup = KeyLookup::named(&["end"]);
708
709impl<T: TreeKey> TreeKey for RangeTo<T> {
710    #[inline]
711    fn traverse_all<W: Walk>() -> W {
712        W::internal(&[T::traverse_all()], &RANGE_TO_LOOKUP)
713    }
714
715    #[inline]
716    fn traverse_by_key<K, F, G>(mut keys: K, func: F) -> Result<usize, Error<G>>
717    where
718        K: Keys,
719        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), G>,
720    {
721        match keys.next(&RANGE_TO_LOOKUP)? {
722            0 => T::traverse_by_key(keys, func),
723            _ => unreachable!(),
724        }
725        .map_err(Error::increment)
726        .map(|depth| depth + 1)
727    }
728}
729
730impl<T: TreeSerialize> TreeSerialize for RangeTo<T> {
731    #[inline]
732    fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
733    where
734        K: Keys,
735        S: Serializer,
736    {
737        match keys.next(&RANGE_TO_LOOKUP)? {
738            0 => self.end.serialize_by_key(keys, ser),
739            _ => unreachable!(),
740        }
741        .map_err(Error::increment)
742    }
743}
744
745impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RangeTo<T> {
746    #[inline]
747    fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
748    where
749        K: Keys,
750        D: Deserializer<'de>,
751    {
752        match keys.next(&RANGE_TO_LOOKUP)? {
753            0 => self.end.deserialize_by_key(keys, de),
754            _ => unreachable!(),
755        }
756        .map_err(Error::increment)
757    }
758
759    #[inline]
760    fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
761    where
762        K: Keys,
763        D: Deserializer<'de>,
764    {
765        match keys.next(&RESULT_LOOKUP)? {
766            0 => T::probe_by_key(keys, de),
767            _ => unreachable!(),
768        }
769        .map_err(Error::increment)
770    }
771}
772
773impl<T: TreeAny> TreeAny for RangeTo<T> {
774    #[inline]
775    fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
776    where
777        K: Keys,
778    {
779        match keys.next(&RANGE_TO_LOOKUP)? {
780            0 => self.end.ref_any_by_key(keys),
781            _ => unreachable!(),
782        }
783        .map_err(Traversal::increment)
784    }
785
786    #[inline]
787    fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
788    where
789        K: Keys,
790    {
791        match keys.next(&RANGE_TO_LOOKUP)? {
792            0 => self.end.mut_any_by_key(keys),
793            _ => unreachable!(),
794        }
795        .map_err(Traversal::increment)
796    }
797}
798
799/////////////////////////////////////////////////////////////////////////////////////////
800
801impl<T: TreeKey> TreeKey for Cell<T> {
802    #[inline]
803    fn traverse_all<W: Walk>() -> W {
804        T::traverse_all()
805    }
806
807    #[inline]
808    fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
809    where
810        K: Keys,
811        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
812    {
813        T::traverse_by_key(keys, func)
814    }
815}
816
817impl<T: TreeSerialize + Copy> TreeSerialize for Cell<T> {
818    #[inline]
819    fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
820    where
821        K: Keys,
822        S: Serializer,
823    {
824        self.get().serialize_by_key(keys, ser)
825    }
826}
827
828impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Cell<T> {
829    #[inline]
830    fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
831    where
832        K: Keys,
833        D: Deserializer<'de>,
834    {
835        self.get_mut().deserialize_by_key(keys, de)
836    }
837
838    #[inline]
839    fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
840    where
841        K: Keys,
842        D: Deserializer<'de>,
843    {
844        T::probe_by_key(keys, de)
845    }
846}
847
848impl<T: TreeAny> TreeAny for Cell<T> {
849    #[inline]
850    fn ref_any_by_key<K>(&self, _keys: K) -> Result<&dyn Any, Traversal>
851    where
852        K: Keys,
853    {
854        Err(Traversal::Access(0, "Can't leak out of Cell"))
855    }
856
857    #[inline]
858    fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
859    where
860        K: Keys,
861    {
862        self.get_mut().mut_any_by_key(keys)
863    }
864}
865
866/////////////////////////////////////////////////////////////////////////////////////////
867
868impl<T: TreeKey> TreeKey for RefCell<T> {
869    #[inline]
870    fn traverse_all<W: Walk>() -> W {
871        T::traverse_all()
872    }
873
874    #[inline]
875    fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
876    where
877        K: Keys,
878        F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
879    {
880        T::traverse_by_key(keys, func)
881    }
882}
883
884impl<T: TreeSerialize> TreeSerialize for RefCell<T> {
885    #[inline]
886    fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
887    where
888        K: Keys,
889        S: Serializer,
890    {
891        self.try_borrow()
892            .or(Err(Traversal::Access(0, "Borrowed")))?
893            .serialize_by_key(keys, ser)
894    }
895}
896
897impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RefCell<T> {
898    #[inline]
899    fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
900    where
901        K: Keys,
902        D: Deserializer<'de>,
903    {
904        self.get_mut().deserialize_by_key(keys, de)
905    }
906
907    #[inline]
908    fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
909    where
910        K: Keys,
911        D: Deserializer<'de>,
912    {
913        T::probe_by_key(keys, de)
914    }
915}
916
917impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &RefCell<T> {
918    #[inline]
919    fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
920    where
921        K: Keys,
922        D: Deserializer<'de>,
923    {
924        self.try_borrow_mut()
925            .or(Err(Traversal::Access(0, "Borrowed")))?
926            .deserialize_by_key(keys, de)
927    }
928
929    #[inline]
930    fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
931    where
932        K: Keys,
933        D: Deserializer<'de>,
934    {
935        T::probe_by_key(keys, de)
936    }
937}
938
939impl<T: TreeAny> TreeAny for RefCell<T> {
940    #[inline]
941    fn ref_any_by_key<K>(&self, _keys: K) -> Result<&dyn Any, Traversal>
942    where
943        K: Keys,
944    {
945        Err(Traversal::Access(0, "Can't leak out of RefCell"))
946    }
947
948    #[inline]
949    fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
950    where
951        K: Keys,
952    {
953        self.get_mut().mut_any_by_key(keys)
954    }
955}
956
957/////////////////////////////////////////////////////////////////////////////////////////
958
959#[cfg(feature = "alloc")]
960mod _alloc {
961    use super::*;
962    extern crate alloc;
963    use alloc::{borrow::Cow, boxed::Box, rc, rc::Rc, sync, sync::Arc};
964
965    impl<T: TreeKey> TreeKey for Box<T> {
966        #[inline]
967        fn traverse_all<W: Walk>() -> W {
968            T::traverse_all()
969        }
970
971        #[inline]
972        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
973        where
974            K: Keys,
975            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
976        {
977            T::traverse_by_key(keys, func)
978        }
979    }
980
981    impl<T: TreeSerialize> TreeSerialize for Box<T> {
982        #[inline]
983        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
984        where
985            K: Keys,
986            S: Serializer,
987        {
988            (**self).serialize_by_key(keys, ser)
989        }
990    }
991
992    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Box<T> {
993        #[inline]
994        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
995        where
996            K: Keys,
997            D: Deserializer<'de>,
998        {
999            (**self).deserialize_by_key(keys, de)
1000        }
1001
1002        #[inline]
1003        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1004        where
1005            K: Keys,
1006            D: Deserializer<'de>,
1007        {
1008            T::probe_by_key(keys, de)
1009        }
1010    }
1011
1012    impl<T: TreeAny> TreeAny for Box<T> {
1013        #[inline]
1014        fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>
1015        where
1016            K: Keys,
1017        {
1018            (**self).ref_any_by_key(keys)
1019        }
1020
1021        #[inline]
1022        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1023        where
1024            K: Keys,
1025        {
1026            (**self).mut_any_by_key(keys)
1027        }
1028    }
1029
1030    /////////////////////////////////////////////////////////////////////////////////////////
1031
1032    impl<T: TreeKey + Clone> TreeKey for Cow<'_, T> {
1033        #[inline]
1034        fn traverse_all<W: Walk>() -> W {
1035            T::traverse_all()
1036        }
1037
1038        #[inline]
1039        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1040        where
1041            K: Keys,
1042            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1043        {
1044            T::traverse_by_key(keys, func)
1045        }
1046    }
1047
1048    impl<T: TreeSerialize + Clone> TreeSerialize for Cow<'_, T> {
1049        #[inline]
1050        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1051        where
1052            K: Keys,
1053            S: Serializer,
1054        {
1055            (**self).serialize_by_key(keys, ser)
1056        }
1057    }
1058
1059    impl<'de, T: TreeDeserialize<'de> + Clone> TreeDeserialize<'de> for Cow<'_, T> {
1060        #[inline]
1061        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1062        where
1063            K: Keys,
1064            D: Deserializer<'de>,
1065        {
1066            self.to_mut().deserialize_by_key(keys, de)
1067        }
1068
1069        #[inline]
1070        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1071        where
1072            K: Keys,
1073            D: Deserializer<'de>,
1074        {
1075            T::probe_by_key(keys, de)
1076        }
1077    }
1078
1079    impl<T: TreeAny + Clone> TreeAny for Cow<'_, T> {
1080        #[inline]
1081        fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>
1082        where
1083            K: Keys,
1084        {
1085            (**self).ref_any_by_key(keys)
1086        }
1087
1088        #[inline]
1089        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1090        where
1091            K: Keys,
1092        {
1093            self.to_mut().mut_any_by_key(keys)
1094        }
1095    }
1096
1097    /////////////////////////////////////////////////////////////////////////////////////////
1098
1099    impl<T: TreeKey> TreeKey for Rc<T> {
1100        #[inline]
1101        fn traverse_all<W: Walk>() -> W {
1102            T::traverse_all()
1103        }
1104
1105        #[inline]
1106        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1107        where
1108            K: Keys,
1109            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1110        {
1111            T::traverse_by_key(keys, func)
1112        }
1113    }
1114
1115    impl<T: TreeSerialize> TreeSerialize for Rc<T> {
1116        #[inline]
1117        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1118        where
1119            K: Keys,
1120            S: Serializer,
1121        {
1122            (**self).serialize_by_key(keys, ser)
1123        }
1124    }
1125
1126    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Rc<T> {
1127        #[inline]
1128        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1129        where
1130            K: Keys,
1131            D: Deserializer<'de>,
1132        {
1133            Rc::get_mut(self)
1134                .ok_or(Traversal::Access(0, "Reference is taken"))?
1135                .deserialize_by_key(keys, de)
1136        }
1137
1138        #[inline]
1139        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1140        where
1141            K: Keys,
1142            D: Deserializer<'de>,
1143        {
1144            T::probe_by_key(keys, de)
1145        }
1146    }
1147
1148    impl<T: TreeAny> TreeAny for Rc<T> {
1149        #[inline]
1150        fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>
1151        where
1152            K: Keys,
1153        {
1154            (**self).ref_any_by_key(keys)
1155        }
1156
1157        #[inline]
1158        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1159        where
1160            K: Keys,
1161        {
1162            Rc::get_mut(self)
1163                .ok_or(Traversal::Access(0, "Reference is taken"))?
1164                .mut_any_by_key(keys)
1165        }
1166    }
1167
1168    /////////////////////////////////////////////////////////////////////////////////////////
1169
1170    impl<T: TreeKey> TreeKey for rc::Weak<T> {
1171        #[inline]
1172        fn traverse_all<W: Walk>() -> W {
1173            T::traverse_all()
1174        }
1175
1176        #[inline]
1177        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1178        where
1179            K: Keys,
1180            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1181        {
1182            T::traverse_by_key(keys, func)
1183        }
1184    }
1185
1186    impl<T: TreeSerialize> TreeSerialize for rc::Weak<T> {
1187        #[inline]
1188        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1189        where
1190            K: Keys,
1191            S: Serializer,
1192        {
1193            self.upgrade()
1194                .ok_or(Traversal::Absent(0))?
1195                .serialize_by_key(keys, ser)
1196        }
1197    }
1198
1199    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for rc::Weak<T> {
1200        #[inline]
1201        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1202        where
1203            K: Keys,
1204            D: Deserializer<'de>,
1205        {
1206            self.upgrade()
1207                .ok_or(Traversal::Absent(0))?
1208                .deserialize_by_key(keys, de)
1209        }
1210
1211        #[inline]
1212        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1213        where
1214            K: Keys,
1215            D: Deserializer<'de>,
1216        {
1217            T::probe_by_key(keys, de)
1218        }
1219    }
1220
1221    /////////////////////////////////////////////////////////////////////////////////////////
1222
1223    impl<T: TreeKey> TreeKey for Arc<T> {
1224        #[inline]
1225        fn traverse_all<W: Walk>() -> W {
1226            T::traverse_all()
1227        }
1228
1229        #[inline]
1230        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1231        where
1232            K: Keys,
1233            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1234        {
1235            T::traverse_by_key(keys, func)
1236        }
1237    }
1238
1239    impl<T: TreeSerialize> TreeSerialize for Arc<T> {
1240        #[inline]
1241        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1242        where
1243            K: Keys,
1244            S: Serializer,
1245        {
1246            (**self).serialize_by_key(keys, ser)
1247        }
1248    }
1249
1250    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Arc<T> {
1251        #[inline]
1252        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1253        where
1254            K: Keys,
1255            D: Deserializer<'de>,
1256        {
1257            Arc::get_mut(self)
1258                .ok_or(Traversal::Access(0, "Reference is taken"))?
1259                .deserialize_by_key(keys, de)
1260        }
1261
1262        #[inline]
1263        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1264        where
1265            K: Keys,
1266            D: Deserializer<'de>,
1267        {
1268            T::probe_by_key(keys, de)
1269        }
1270    }
1271
1272    impl<T: TreeAny> TreeAny for Arc<T> {
1273        #[inline]
1274        fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>
1275        where
1276            K: Keys,
1277        {
1278            (**self).ref_any_by_key(keys)
1279        }
1280
1281        #[inline]
1282        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1283        where
1284            K: Keys,
1285        {
1286            Arc::get_mut(self)
1287                .ok_or(Traversal::Access(0, "Reference is taken"))?
1288                .mut_any_by_key(keys)
1289        }
1290    }
1291
1292    /////////////////////////////////////////////////////////////////////////////////////////
1293
1294    impl<T: TreeKey> TreeKey for sync::Weak<T> {
1295        #[inline]
1296        fn traverse_all<W: Walk>() -> W {
1297            T::traverse_all()
1298        }
1299
1300        #[inline]
1301        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1302        where
1303            K: Keys,
1304            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1305        {
1306            T::traverse_by_key(keys, func)
1307        }
1308    }
1309
1310    impl<T: TreeSerialize> TreeSerialize for sync::Weak<T> {
1311        #[inline]
1312        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1313        where
1314            K: Keys,
1315            S: Serializer,
1316        {
1317            self.upgrade()
1318                .ok_or(Traversal::Absent(0))?
1319                .serialize_by_key(keys, ser)
1320        }
1321    }
1322
1323    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for sync::Weak<T> {
1324        #[inline]
1325        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1326        where
1327            K: Keys,
1328            D: Deserializer<'de>,
1329        {
1330            self.upgrade()
1331                .ok_or(Traversal::Absent(0))?
1332                .deserialize_by_key(keys, de)
1333        }
1334
1335        #[inline]
1336        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1337        where
1338            K: Keys,
1339            D: Deserializer<'de>,
1340        {
1341            T::probe_by_key(keys, de)
1342        }
1343    }
1344}
1345
1346/////////////////////////////////////////////////////////////////////////////////////////
1347
1348#[cfg(feature = "std")]
1349mod _std {
1350    use super::*;
1351    use std::sync::{Mutex, RwLock};
1352
1353    impl<T: TreeKey> TreeKey for Mutex<T> {
1354        #[inline]
1355        fn traverse_all<W: Walk>() -> W {
1356            T::traverse_all()
1357        }
1358
1359        #[inline]
1360        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1361        where
1362            K: Keys,
1363            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1364        {
1365            T::traverse_by_key(keys, func)
1366        }
1367    }
1368
1369    impl<T: TreeSerialize> TreeSerialize for Mutex<T> {
1370        #[inline]
1371        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1372        where
1373            K: Keys,
1374            S: Serializer,
1375        {
1376            self.lock()
1377                .or(Err(Traversal::Access(0, "Poisoned")))?
1378                .serialize_by_key(keys, ser)
1379        }
1380    }
1381
1382    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for Mutex<T> {
1383        #[inline]
1384        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1385        where
1386            K: Keys,
1387            D: Deserializer<'de>,
1388        {
1389            self.get_mut()
1390                .or(Err(Traversal::Access(0, "Poisoned")))?
1391                .deserialize_by_key(keys, de)
1392        }
1393
1394        #[inline]
1395        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1396        where
1397            K: Keys,
1398            D: Deserializer<'de>,
1399        {
1400            T::probe_by_key(keys, de)
1401        }
1402    }
1403
1404    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &Mutex<T> {
1405        #[inline]
1406        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1407        where
1408            K: Keys,
1409            D: Deserializer<'de>,
1410        {
1411            (*self)
1412                .lock()
1413                .or(Err(Traversal::Access(0, "Poisoned")))?
1414                .deserialize_by_key(keys, de)
1415        }
1416
1417        #[inline]
1418        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1419        where
1420            K: Keys,
1421            D: Deserializer<'de>,
1422        {
1423            T::probe_by_key(keys, de)
1424        }
1425    }
1426
1427    impl<T: TreeAny> TreeAny for Mutex<T> {
1428        #[inline]
1429        fn ref_any_by_key<K>(&self, _keys: K) -> Result<&dyn Any, Traversal>
1430        where
1431            K: Keys,
1432        {
1433            Err(Traversal::Access(0, "Can't leak out of Mutex"))
1434        }
1435
1436        #[inline]
1437        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1438        where
1439            K: Keys,
1440        {
1441            self.get_mut()
1442                .or(Err(Traversal::Access(0, "Poisoned")))?
1443                .mut_any_by_key(keys)
1444        }
1445    }
1446
1447    /////////////////////////////////////////////////////////////////////////////////////////
1448
1449    impl<T: TreeKey> TreeKey for RwLock<T> {
1450        #[inline]
1451        fn traverse_all<W: Walk>() -> W {
1452            T::traverse_all()
1453        }
1454
1455        #[inline]
1456        fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>
1457        where
1458            K: Keys,
1459            F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
1460        {
1461            T::traverse_by_key(keys, func)
1462        }
1463    }
1464
1465    impl<T: TreeSerialize> TreeSerialize for RwLock<T> {
1466        #[inline]
1467        fn serialize_by_key<K, S>(&self, keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
1468        where
1469            K: Keys,
1470            S: Serializer,
1471        {
1472            self.read()
1473                .or(Err(Traversal::Access(0, "Poisoned")))?
1474                .serialize_by_key(keys, ser)
1475        }
1476    }
1477
1478    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for &RwLock<T> {
1479        #[inline]
1480        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1481        where
1482            K: Keys,
1483            D: Deserializer<'de>,
1484        {
1485            self.write()
1486                .or(Err(Traversal::Access(0, "Poisoned")))?
1487                .deserialize_by_key(keys, de)
1488        }
1489
1490        #[inline]
1491        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1492        where
1493            K: Keys,
1494            D: Deserializer<'de>,
1495        {
1496            T::probe_by_key(keys, de)
1497        }
1498    }
1499
1500    impl<'de, T: TreeDeserialize<'de>> TreeDeserialize<'de> for RwLock<T> {
1501        #[inline]
1502        fn deserialize_by_key<K, D>(&mut self, keys: K, de: D) -> Result<(), Error<D::Error>>
1503        where
1504            K: Keys,
1505            D: Deserializer<'de>,
1506        {
1507            self.get_mut()
1508                .or(Err(Traversal::Access(0, "Poisoned")))?
1509                .deserialize_by_key(keys, de)
1510        }
1511
1512        #[inline]
1513        fn probe_by_key<K, D>(keys: K, de: D) -> Result<(), Error<D::Error>>
1514        where
1515            K: Keys,
1516            D: Deserializer<'de>,
1517        {
1518            T::probe_by_key(keys, de)
1519        }
1520    }
1521
1522    impl<T: TreeAny> TreeAny for RwLock<T> {
1523        #[inline]
1524        fn ref_any_by_key<K>(&self, _keys: K) -> Result<&dyn Any, Traversal>
1525        where
1526            K: Keys,
1527        {
1528            Err(Traversal::Access(0, "Can't leak out of RwLock"))
1529        }
1530
1531        #[inline]
1532        fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>
1533        where
1534            K: Keys,
1535        {
1536            self.get_mut()
1537                .or(Err(Traversal::Access(0, "Poisoned")))?
1538                .mut_any_by_key(keys)
1539        }
1540    }
1541}
miniconf/impls.rs

miniconf/
impls.rs
