miniconf/impls/
leaves.rs

1use core::{
2    any::Any,
3    fmt::Display,
4    ops::{Deref, DerefMut},
5};
6
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9use crate::{
10    Keys, Schema, SerdeError, TreeAny, TreeDeserialize, TreeSchema, TreeSerialize, ValueError,
11};
12
13/// Passthrough Tree*
14pub mod passthrough {
15    use super::*;
16
17    /// [`TreeSerialize::serialize_by_key()`]
18    pub fn serialize_by_key<T: TreeSerialize + ?Sized, S: Serializer>(
19        value: &T,
20        keys: impl Keys,
21        ser: S,
22    ) -> Result<S::Ok, SerdeError<S::Error>> {
23        value.serialize_by_key(keys, ser)
24    }
25
26    /// [`TreeDeserialize::deserialize_by_key()`]
27    pub fn deserialize_by_key<'de, T: TreeDeserialize<'de> + ?Sized, D: Deserializer<'de>>(
28        value: &mut T,
29        keys: impl Keys,
30        de: D,
31    ) -> Result<(), SerdeError<D::Error>> {
32        value.deserialize_by_key(keys, de)
33    }
34
35    /// [`TreeDeserialize::probe_by_key()`]
36    pub fn probe_by_key<'de, T: TreeDeserialize<'de> + ?Sized, D: Deserializer<'de>>(
37        keys: impl Keys,
38        de: D,
39    ) -> Result<(), SerdeError<D::Error>> {
40        T::probe_by_key(keys, de)
41    }
42
43    /// [`TreeAny::ref_any_by_key()`]
44    pub fn ref_any_by_key(
45        value: &(impl TreeAny + ?Sized),
46        keys: impl Keys,
47    ) -> Result<&dyn Any, ValueError> {
48        value.ref_any_by_key(keys)
49    }
50
51    /// [`TreeAny::mut_any_by_key()`]
52    pub fn mut_any_by_key(
53        value: &mut (impl TreeAny + ?Sized),
54        keys: impl Keys,
55    ) -> Result<&mut dyn Any, ValueError> {
56        value.mut_any_by_key(keys)
57    }
58}
59
60/// Leaf implementation using serde::{Serialize, Deserialize}
61///
62/// To be used as a derive macros attribute `#[tree(with=leaf)]`.
63pub mod leaf {
64    use super::*;
65
66    /// [`TreeSchema::SCHEMA`]
67    pub const SCHEMA: &Schema = &Schema::LEAF;
68
69    /// [`TreeSerialize::serialize_by_key()`]
70    pub fn serialize_by_key<T: Serialize + ?Sized, S: Serializer>(
71        value: &T,
72        mut keys: impl Keys,
73        ser: S,
74    ) -> Result<S::Ok, SerdeError<S::Error>> {
75        keys.finalize()?;
76        Serialize::serialize(value, ser).map_err(SerdeError::Inner)
77    }
78
79    /// [`TreeDeserialize::deserialize_by_key()`]
80    pub fn deserialize_by_key<'de, T: Deserialize<'de>, D: Deserializer<'de>>(
81        value: &mut T,
82        mut keys: impl Keys,
83        de: D,
84    ) -> Result<(), SerdeError<D::Error>> {
85        keys.finalize()?;
86        Deserialize::deserialize_in_place(de, value).map_err(SerdeError::Inner)?;
87        Ok(())
88    }
89
90    /// [`TreeDeserialize::probe_by_key()`]
91    pub fn probe_by_key<'de, T: Deserialize<'de>, D: Deserializer<'de>>(
92        mut keys: impl Keys,
93        de: D,
94    ) -> Result<(), SerdeError<D::Error>> {
95        keys.finalize()?;
96        T::deserialize(de).map_err(SerdeError::Inner)?;
97        Ok(())
98    }
99
100    /// [`TreeAny::ref_any_by_key()`]
101    pub fn ref_any_by_key(value: &impl Any, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
102        keys.finalize()?;
103        Ok(value)
104    }
105
106    /// [`TreeAny::mut_any_by_key()`]
107    pub fn mut_any_by_key(
108        value: &mut impl Any,
109        mut keys: impl Keys,
110    ) -> Result<&mut dyn Any, ValueError> {
111        keys.finalize()?;
112        Ok(value)
113    }
114}
115
116/// `Serialize`/`Deserialize`/`Any` leaf
117///
118/// This wraps [`Serialize`], [`Deserialize`], and [`Any`] into `Tree` a leaf node.
119///
120/// ```
121/// use miniconf::{json_core, Leaf, Tree};
122/// let mut s = Leaf(0);
123/// json_core::set(&mut s, "", b"7").unwrap();
124/// assert!(matches!(*s, 7));
125/// ```
126#[derive(
127    Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
128)]
129#[serde(transparent)]
130#[repr(transparent)]
131pub struct Leaf<T: ?Sized>(pub T);
132
133impl<T: ?Sized> Deref for Leaf<T> {
134    type Target = T;
135    fn deref(&self) -> &Self::Target {
136        &self.0
137    }
138}
139
140impl<T: ?Sized> DerefMut for Leaf<T> {
141    fn deref_mut(&mut self) -> &mut Self::Target {
142        &mut self.0
143    }
144}
145
146impl<T: Display> Display for Leaf<T> {
147    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
148        self.0.fmt(f)
149    }
150}
151
152impl<T: ?Sized> TreeSchema for Leaf<T> {
153    const SCHEMA: &'static Schema = leaf::SCHEMA;
154}
155
156impl<T: Serialize + ?Sized> TreeSerialize for Leaf<T> {
157    fn serialize_by_key<S: Serializer>(
158        &self,
159        keys: impl Keys,
160        ser: S,
161    ) -> Result<S::Ok, SerdeError<S::Error>> {
162        leaf::serialize_by_key(&self.0, keys, ser)
163    }
164}
165
166impl<'de, T: Deserialize<'de>> TreeDeserialize<'de> for Leaf<T> {
167    fn deserialize_by_key<D: Deserializer<'de>>(
168        &mut self,
169        keys: impl Keys,
170        de: D,
171    ) -> Result<(), SerdeError<D::Error>> {
172        leaf::deserialize_by_key(&mut self.0, keys, de)
173    }
174
175    fn probe_by_key<D: Deserializer<'de>>(
176        keys: impl Keys,
177        de: D,
178    ) -> Result<(), SerdeError<D::Error>> {
179        leaf::probe_by_key::<Self, _>(keys, de)
180    }
181}
182
183impl<T: Any> TreeAny for Leaf<T> {
184    fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
185        leaf::ref_any_by_key(&self.0, keys)
186    }
187
188    fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
189        leaf::mut_any_by_key(&mut self.0, keys)
190    }
191}
192
193/////////////////////////////////////////////////////////////////////////////////////////
194
195macro_rules! impl_leaf {
196    ($($ty:ty),*) => {$(
197        impl TreeSchema for $ty {
198            const SCHEMA: &'static Schema = leaf::SCHEMA;
199        }
200
201        impl TreeSerialize for $ty {
202            fn serialize_by_key<S: Serializer>(
203                &self,
204                keys: impl Keys,
205                ser: S,
206            ) -> Result<S::Ok, SerdeError<S::Error>> {
207                leaf::serialize_by_key(self, keys, ser)
208            }
209        }
210
211        impl<'de> TreeDeserialize<'de> for $ty {
212            fn deserialize_by_key<D: Deserializer<'de>>(
213                &mut self,
214                keys: impl Keys,
215                de: D,
216            ) -> Result<(), SerdeError<D::Error>> {
217                leaf::deserialize_by_key(self, keys, de)
218            }
219
220            fn probe_by_key<D: Deserializer<'de>>(
221                keys: impl Keys,
222                de: D,
223            ) -> Result<(), SerdeError<D::Error>> {
224                leaf::probe_by_key::<Self, _>(keys, de)
225            }
226        }
227
228        impl TreeAny for $ty {
229            fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
230                leaf::ref_any_by_key(self, keys)
231            }
232
233            fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
234                leaf::mut_any_by_key(self, keys)
235            }
236        }
237    )*};
238}
239
240impl_leaf! {
241    (), bool, char, f32, f64,
242    i8, i16, i32, i64, i128, isize,
243    u8, u16, u32, u64, u128, usize
244}
245impl_leaf! {core::net::SocketAddr, core::net::SocketAddrV4, core::net::SocketAddrV6}
246impl_leaf! {core::time::Duration}
247
248macro_rules! impl_unsized_leaf {
249    ($($ty:ty),*) => {$(
250        impl TreeSchema for $ty {
251            const SCHEMA: &'static Schema = leaf::SCHEMA;
252        }
253
254        impl TreeSerialize for $ty {
255            fn serialize_by_key<S: Serializer>(
256                &self,
257                keys: impl Keys,
258                ser: S,
259            ) -> Result<S::Ok, SerdeError<S::Error>> {
260                leaf::serialize_by_key(self, keys, ser)
261            }
262        }
263
264        impl<'a, 'de: 'a> TreeDeserialize<'de> for &'a $ty {
265            fn deserialize_by_key<D: Deserializer<'de>>(
266                &mut self,
267                keys: impl Keys,
268                de: D,
269            ) -> Result<(), SerdeError<D::Error>> {
270                leaf::deserialize_by_key(self, keys, de)
271            }
272
273            fn probe_by_key<D: Deserializer<'de>>(
274                keys: impl Keys,
275                de: D,
276            ) -> Result<(), SerdeError<D::Error>> {
277                leaf::probe_by_key::<Self, _>(keys, de)
278            }
279        }
280    )*};
281}
282
283impl_unsized_leaf! {str}
284
285impl<T> TreeSchema for [T] {
286    const SCHEMA: &'static Schema = leaf::SCHEMA;
287}
288
289impl<T: Serialize> TreeSerialize for [T] {
290    fn serialize_by_key<S: Serializer>(
291        &self,
292        keys: impl Keys,
293        ser: S,
294    ) -> Result<S::Ok, SerdeError<S::Error>> {
295        leaf::serialize_by_key(self, keys, ser)
296    }
297}
298
299impl<'a, 'de: 'a, T> TreeDeserialize<'de> for &'a [T]
300where
301    &'a [T]: Deserialize<'de>,
302{
303    fn deserialize_by_key<D: Deserializer<'de>>(
304        &mut self,
305        keys: impl Keys,
306        de: D,
307    ) -> Result<(), SerdeError<D::Error>> {
308        leaf::deserialize_by_key(self, keys, de)
309    }
310
311    fn probe_by_key<D: Deserializer<'de>>(
312        keys: impl Keys,
313        de: D,
314    ) -> Result<(), SerdeError<D::Error>> {
315        leaf::probe_by_key::<Self, _>(keys, de)
316    }
317}
318
319#[cfg(feature = "alloc")]
320mod alloc_impls {
321    use super::*;
322
323    use alloc::{string::String, vec::Vec};
324
325    impl_leaf! {String}
326
327    impl<T> TreeSchema for Vec<T> {
328        const SCHEMA: &'static Schema = leaf::SCHEMA;
329    }
330
331    impl<T: Serialize> TreeSerialize for Vec<T> {
332        fn serialize_by_key<S: Serializer>(
333            &self,
334            keys: impl Keys,
335            ser: S,
336        ) -> Result<S::Ok, SerdeError<S::Error>> {
337            leaf::serialize_by_key(self, keys, ser)
338        }
339    }
340
341    impl<'de, T: Deserialize<'de>> TreeDeserialize<'de> for Vec<T> {
342        fn deserialize_by_key<D: Deserializer<'de>>(
343            &mut self,
344            keys: impl Keys,
345            de: D,
346        ) -> Result<(), SerdeError<D::Error>> {
347            leaf::deserialize_by_key(self, keys, de)
348        }
349
350        fn probe_by_key<D: Deserializer<'de>>(
351            keys: impl Keys,
352            de: D,
353        ) -> Result<(), SerdeError<D::Error>> {
354            leaf::probe_by_key::<Self, _>(keys, de)
355        }
356    }
357
358    impl<T: 'static> TreeAny for Vec<T> {
359        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
360            leaf::ref_any_by_key(self, keys)
361        }
362
363        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
364            leaf::mut_any_by_key(self, keys)
365        }
366    }
367}
368
369#[cfg(feature = "std")]
370mod std_impls {
371    use super::*;
372
373    impl_leaf! {std::ffi::CString, std::ffi::OsString}
374    impl_leaf! {std::time::SystemTime}
375    impl_leaf! {std::path::PathBuf}
376    impl_unsized_leaf! {std::path::Path}
377
378    #[cfg(target_has_atomic = "8")]
379    impl_leaf! { core::sync::atomic::AtomicBool, core::sync::atomic::AtomicI8, core::sync::atomic::AtomicU8 }
380    #[cfg(target_has_atomic = "16")]
381    impl_leaf! { core::sync::atomic::AtomicI16, core::sync::atomic::AtomicU16 }
382    #[cfg(target_has_atomic = "32")]
383    impl_leaf! { core::sync::atomic::AtomicI32, core::sync::atomic::AtomicU32 }
384    #[cfg(target_has_atomic = "64")]
385    impl_leaf! { core::sync::atomic::AtomicI64, core::sync::atomic::AtomicU64 }
386}
387
388#[cfg(feature = "heapless")]
389mod heapless_impls {
390    use super::*;
391
392    use heapless::{String, Vec};
393
394    impl<const N: usize> TreeSchema for String<N> {
395        const SCHEMA: &'static Schema = leaf::SCHEMA;
396    }
397
398    impl<const N: usize> TreeSerialize for String<N> {
399        fn serialize_by_key<S: Serializer>(
400            &self,
401            keys: impl Keys,
402            ser: S,
403        ) -> Result<S::Ok, SerdeError<S::Error>> {
404            leaf::serialize_by_key(self, keys, ser)
405        }
406    }
407
408    impl<'de, const N: usize> TreeDeserialize<'de> for String<N> {
409        fn deserialize_by_key<D: Deserializer<'de>>(
410            &mut self,
411            keys: impl Keys,
412            de: D,
413        ) -> Result<(), SerdeError<D::Error>> {
414            leaf::deserialize_by_key(self, keys, de)
415        }
416
417        fn probe_by_key<D: Deserializer<'de>>(
418            keys: impl Keys,
419            de: D,
420        ) -> Result<(), SerdeError<D::Error>> {
421            leaf::probe_by_key::<Self, _>(keys, de)
422        }
423    }
424
425    impl<const N: usize> TreeAny for String<N> {
426        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
427            leaf::ref_any_by_key(self, keys)
428        }
429
430        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
431            leaf::mut_any_by_key(self, keys)
432        }
433    }
434
435    impl<T, const N: usize> TreeSchema for Vec<T, N> {
436        const SCHEMA: &'static Schema = leaf::SCHEMA;
437    }
438
439    impl<T: Serialize, const N: usize> TreeSerialize for Vec<T, N> {
440        fn serialize_by_key<S: Serializer>(
441            &self,
442            keys: impl Keys,
443            ser: S,
444        ) -> Result<S::Ok, SerdeError<S::Error>> {
445            leaf::serialize_by_key(self, keys, ser)
446        }
447    }
448
449    impl<'de, T: Deserialize<'de>, const N: usize> TreeDeserialize<'de> for Vec<T, N> {
450        fn deserialize_by_key<D: Deserializer<'de>>(
451            &mut self,
452            keys: impl Keys,
453            de: D,
454        ) -> Result<(), SerdeError<D::Error>> {
455            leaf::deserialize_by_key(self, keys, de)
456        }
457
458        fn probe_by_key<D: Deserializer<'de>>(
459            keys: impl Keys,
460            de: D,
461        ) -> Result<(), SerdeError<D::Error>> {
462            leaf::probe_by_key::<Self, _>(keys, de)
463        }
464    }
465
466    impl<T: 'static, const N: usize> TreeAny for Vec<T, N> {
467        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
468            leaf::ref_any_by_key(self, keys)
469        }
470
471        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
472            leaf::mut_any_by_key(self, keys)
473        }
474    }
475}
476
477#[cfg(feature = "heapless-09")]
478mod heapless_09_impls {
479    use super::*;
480
481    use heapless_09::{
482        LenType, String, Vec,
483        string::{StringInner, StringStorage},
484        vec::{VecInner, VecStorage},
485    };
486
487    impl<LenT: LenType, O: StringStorage + ?Sized> TreeSchema for StringInner<LenT, O> {
488        const SCHEMA: &'static Schema = leaf::SCHEMA;
489    }
490
491    impl<LenT: LenType, O: StringStorage + ?Sized> TreeSerialize for StringInner<LenT, O> {
492        fn serialize_by_key<S: Serializer>(
493            &self,
494            keys: impl Keys,
495            ser: S,
496        ) -> Result<S::Ok, SerdeError<S::Error>> {
497            leaf::serialize_by_key(self, keys, ser)
498        }
499    }
500
501    impl<'de, const N: usize, LenT: LenType> TreeDeserialize<'de> for String<N, LenT> {
502        fn deserialize_by_key<D: Deserializer<'de>>(
503            &mut self,
504            keys: impl Keys,
505            de: D,
506        ) -> Result<(), SerdeError<D::Error>> {
507            leaf::deserialize_by_key(self, keys, de)
508        }
509
510        fn probe_by_key<D: Deserializer<'de>>(
511            keys: impl Keys,
512            de: D,
513        ) -> Result<(), SerdeError<D::Error>> {
514            leaf::probe_by_key::<Self, _>(keys, de)
515        }
516    }
517
518    impl<const N: usize, LenT: LenType + 'static> TreeAny for String<N, LenT> {
519        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
520            leaf::ref_any_by_key(self, keys)
521        }
522
523        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
524            leaf::mut_any_by_key(self, keys)
525        }
526    }
527
528    impl<T, LenT: LenType, O: VecStorage<T> + ?Sized> TreeSchema for VecInner<T, LenT, O> {
529        const SCHEMA: &'static Schema = leaf::SCHEMA;
530    }
531
532    impl<T: Serialize, const N: usize, LenT: LenType> TreeSerialize for Vec<T, N, LenT> {
533        fn serialize_by_key<S: Serializer>(
534            &self,
535            keys: impl Keys,
536            ser: S,
537        ) -> Result<S::Ok, SerdeError<S::Error>> {
538            leaf::serialize_by_key(self, keys, ser)
539        }
540    }
541
542    impl<'de, T: Deserialize<'de>, const N: usize, LenT: LenType> TreeDeserialize<'de>
543        for Vec<T, N, LenT>
544    {
545        fn deserialize_by_key<D: Deserializer<'de>>(
546            &mut self,
547            keys: impl Keys,
548            de: D,
549        ) -> Result<(), SerdeError<D::Error>> {
550            leaf::deserialize_by_key(self, keys, de)
551        }
552
553        fn probe_by_key<D: Deserializer<'de>>(
554            keys: impl Keys,
555            de: D,
556        ) -> Result<(), SerdeError<D::Error>> {
557            leaf::probe_by_key::<Self, _>(keys, de)
558        }
559    }
560
561    impl<T: 'static, const N: usize, LenT: LenType + 'static> TreeAny for Vec<T, N, LenT> {
562        fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
563            leaf::ref_any_by_key(self, keys)
564        }
565
566        fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
567            leaf::mut_any_by_key(self, keys)
568        }
569    }
570}
571
572/// `TryFrom<&str>`/`AsRef<str>` leaf
573///
574/// This wraps [`TryFrom<&str>`] and [`AsRef<str>`] into a `Tree*` leaf.
575/// [`TreeAny`] is implemented but denied access at runtime.
576/// It is especially useful to support enum variant switching using `strum`.
577/// Inner enum variant field access can be implemented using `defer`.
578///
579/// ```
580/// use miniconf::{json_core::set, str_leaf, Tree};
581/// #[derive(Tree, strum::AsRefStr, strum::EnumString)]
582/// enum En {
583///     A(i32),
584///     B(f32),
585/// }
586/// #[derive(Tree)]
587/// struct S {
588///     #[tree(rename="t", with=str_leaf, defer=self.e, typ="En")]
589///     _t: (),
590///     e: En,
591/// }
592/// let mut s = S {
593///     _t: (),
594///     e: En::A(9),
595/// };
596/// set(&mut s, "/t", b"\"B\"").unwrap();
597/// set(&mut s, "/e/B", b"1.2").unwrap();
598/// assert!(matches!(s.e, En::B(1.2)));
599/// ```
600pub mod str_leaf {
601    use super::*;
602
603    pub use deny::{mut_any_by_key, ref_any_by_key};
604    pub use leaf::SCHEMA;
605
606    /// [`TreeSerialize::serialize_by_key()`]
607    pub fn serialize_by_key<S: Serializer>(
608        value: &(impl AsRef<str> + ?Sized),
609        mut keys: impl Keys,
610        ser: S,
611    ) -> Result<S::Ok, SerdeError<S::Error>> {
612        keys.finalize()?;
613        value.as_ref().serialize(ser).map_err(SerdeError::Inner)
614    }
615
616    /// [`TreeDeserialize::deserialize_by_key()`]
617    pub fn deserialize_by_key<'de, D: Deserializer<'de>>(
618        value: &mut impl TryFrom<&'de str>,
619        mut keys: impl Keys,
620        de: D,
621    ) -> Result<(), SerdeError<D::Error>> {
622        keys.finalize()?;
623        let name: &str = Deserialize::deserialize(de).map_err(SerdeError::Inner)?;
624        *value = name
625            .try_into()
626            .or(Err(ValueError::Access("Could not convert from str")))?;
627        Ok(())
628    }
629
630    /// [`TreeDeserialize::probe_by_key()`]
631    pub fn probe_by_key<'de, T: TryFrom<&'de str>, D: Deserializer<'de>>(
632        mut keys: impl Keys,
633        de: D,
634    ) -> Result<(), SerdeError<D::Error>> {
635        keys.finalize()?;
636        let name: &str = Deserialize::deserialize(de).map_err(SerdeError::Inner)?;
637        T::try_from(name).or(Err(ValueError::Access("Could not convert from str")))?;
638        Ok(())
639    }
640}
641
642/// Deny access tools.
643///
644/// These return early without consuming keys or finalizing them.
645pub mod deny {
646    use super::*;
647
648    pub use leaf::SCHEMA;
649
650    /// [`TreeSerialize::serialize_by_key()`]
651    pub fn serialize_by_key<S: Serializer>(
652        _value: &impl ?Sized,
653        _keys: impl Keys,
654        _ser: S,
655    ) -> Result<S::Ok, SerdeError<S::Error>> {
656        Err(ValueError::Access("Denied").into())
657    }
658
659    /// [`TreeDeserialize::deserialize_by_key()`]
660    pub fn deserialize_by_key<'de, D: Deserializer<'de>>(
661        _value: &mut impl ?Sized,
662        _keys: impl Keys,
663        _de: D,
664    ) -> Result<(), SerdeError<D::Error>> {
665        Err(ValueError::Access("Denied").into())
666    }
667
668    /// [`TreeDeserialize::probe_by_key()`]
669    pub fn probe_by_key<'de, T: ?Sized, D: Deserializer<'de>>(
670        _keys: impl Keys,
671        _de: D,
672    ) -> Result<(), SerdeError<D::Error>> {
673        Err(ValueError::Access("Denied").into())
674    }
675
676    /// [`TreeAny::ref_any_by_key()`]
677    pub fn ref_any_by_key(_value: &impl ?Sized, _keys: impl Keys) -> Result<&dyn Any, ValueError> {
678        Err(ValueError::Access("Denied"))
679    }
680
681    /// [`TreeAny::mut_any_by_key()`]
682    pub fn mut_any_by_key(
683        _value: &mut impl ?Sized,
684        _keys: impl Keys,
685    ) -> Result<&mut dyn Any, ValueError> {
686        Err(ValueError::Access("Denied"))
687    }
688}
miniconf/impls/leaves.rs

miniconf/impls/
leaves.rs
