Struct StrLeaf

#[repr(transparent)]
pub struct StrLeaf<T: ?Sized>(pub T);

TryFrom<&str>/AsRef<str> leaf

This wraps TryFrom<&str> and AsRef<str> into a Tree* leaf. TreeAny is implemented but denied access at runtime. It is especially useful to support enum variant switching using strum. Inner enum variant field access can be implemented using defer.

use miniconf::{json, Leaf, StrLeaf, Tree};
#[derive(Tree, strum::AsRefStr, strum::EnumString)]
enum En {
    A(Leaf<i32>),
    B(Leaf<f32>),
}
#[derive(Tree)]
struct S {
    e: StrLeaf<En>,
    #[tree(typ="En", defer=*self.e)]
    t: (),
}
let mut s = S {
    e: StrLeaf(En::A(9.into())),
    t: (),
};
json::set(&mut s, "/e", b"\"B\"").unwrap();
json::set(&mut s, "/t/B", b"1.2").unwrap();
assert!(matches!(*s.e, En::B(Leaf(1.2))));

Tuple Fields

0: T

Implementations

impl<T> StrLeaf<T>

pub fn into_inner(self) -> T

Extract just the inner

Trait Implementations

impl<T: Clone + ?Sized> Clone for StrLeaf<T>

fn clone(&self) -> StrLeaf<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for StrLeaf<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + ?Sized> Default for StrLeaf<T>

fn default() -> StrLeaf<T>

Returns the “default value” for a type.

impl<T: ?Sized> Deref for StrLeaf<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: ?Sized> DerefMut for StrLeaf<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for StrLeaf<T>

where T: Deserialize<'de> + ?Sized,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for StrLeaf<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash + ?Sized> Hash for StrLeaf<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

impl<T: Ord + ?Sized> Ord for StrLeaf<T>

fn cmp(&self, other: &StrLeaf<T>) -> Ordering

This method returns an Ordering between self and other.

impl<T: PartialEq + ?Sized> PartialEq for StrLeaf<T>

fn eq(&self, other: &StrLeaf<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + ?Sized> PartialOrd for StrLeaf<T>

fn partial_cmp(&self, other: &StrLeaf<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for StrLeaf<T>

where T: Serialize + ?Sized,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TreeAny for StrLeaf<T>

fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>

where K: Keys,

Obtain a reference to a dyn Any trait object for a leaf node.

fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>

where K: Keys,

Obtain a mutable reference to a dyn Any trait object for a leaf node.

fn ref_by_key<T: Any, K: IntoKeys>(&self, keys: K) -> Result<&T, Traversal>

Obtain a reference to a leaf of known type by key.

fn mut_by_key<T: Any, K: IntoKeys>( &mut self, keys: K, ) -> Result<&mut T, Traversal>

Obtain a mutable reference to a leaf of known type by key.

impl<'de, T: TryFrom<&'de str>> TreeDeserialize<'de> for StrLeaf<T>

fn deserialize_by_key<K, D>( &mut self, keys: K, de: D, ) -> Result<usize, Error<D::Error>>

where K: Keys, D: Deserializer<'de>,

Deserialize a leaf node by its keys.

impl<T: ?Sized> TreeKey for StrLeaf<T>

fn traverse_all<W: Walk>() -> Result<W, W::Error>

Walk metadata about all paths.

fn traverse_by_key<K, F, E>(keys: K, _func: F) -> Result<usize, Error<E>>

where K: Keys, F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,

Traverse from the root to a leaf and call a function for each node.

fn transcode<N, K>(keys: K) -> Result<(N, Node), Traversal>

where K: IntoKeys, N: Transcode + Default,

Transcode keys to a new keys type representation

fn nodes<N, const D: usize>() -> NodeIter<Self, N, D>

where N: Transcode + Default,

Return an iterator over nodes of a given type

impl<T: AsRef<str> + ?Sized> TreeSerialize for StrLeaf<T>

fn serialize_by_key<K, S>( &self, keys: K, ser: S, ) -> Result<usize, Error<S::Error>>

where K: Keys, S: Serializer,

Serialize a node by keys.

impl<T: Copy + ?Sized> Copy for StrLeaf<T>

impl<T: Eq + ?Sized> Eq for StrLeaf<T>

impl<T: ?Sized> StructuralPartialEq for StrLeaf<T>