Merge pull request #309 from quartiq/shrink

ConstPath{,Iter}, add Seeded

Author: jordens

CHANGELOG.md

@@ -10,8 +10,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-* PathIter takes the separator as a const generic. That allows compile time specialization
-  of ascii separators.
+* Path takes thes separator as a member reducing monomorphization bloat.
+
+### Added
+
+* ConstPath and ConstPathIter taking the separator as a const generic. That allows compile time specialization of ascii separators.
+* Seeded trait to enable Transcode/Keys construction from runtime configuration.
 
 ## [0.20.1](https://github.com/quartiq/miniconf/compare/miniconf-v0.20.0...miniconf-v0.20.1) - 2026-02-12
 

miniconf/README.md

@@ -114,8 +114,8 @@ assert!(MAX_DEPTH <= 6);
 assert!(MAX_LENGTH <= 32);
 
 // Iterating over all leaf paths
-for path in Settings::SCHEMA.nodes::<Path<heapless::String<MAX_LENGTH>, '/'>, MAX_DEPTH>() {
-    let path = path.unwrap().0;
+for path in Settings::SCHEMA.nodes::<Path<heapless::String<MAX_LENGTH>>, MAX_DEPTH>() {
+    let path = path.unwrap().path;
     // Serialize each
     match json_core::get(&settings, &path, &mut buf) {
         // Full round-trip: deserialize and set again

miniconf/examples/cli.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use miniconf::{IntoKeys, Keys, Path, SerdeError, TreeSchema, ValueError, json_core};
+use miniconf::{ConstPath, IntoKeys, Keys, SerdeError, TreeSchema, ValueError, json_core};
 
 mod common;
 use common::Settings;
@@ -8,7 +8,6 @@ use common::Settings;
 ///
 /// This exposes the leaf nodes in `Settings` as long options, parses the command line,
 /// and then prints the settings struct as a list of option key-value pairs.
-
 fn main() -> anyhow::Result<()> {
     let mut settings = Settings::new();
     settings.enable();
@@ -17,14 +16,14 @@ fn main() -> anyhow::Result<()> {
     while let Some(key) = args.next() {
         let key = key.strip_prefix('-').context("stripping initial dash")?;
         let value = args.next().context("looking for value")?;
-        json_core::set_by_key(&mut settings, Path::<_, '-'>(key), value.as_bytes())
+        json_core::set_by_key(&mut settings, ConstPath::<_, '-'>(key), value.as_bytes())
             .context("lookup/deserialize")?;
     }
 
     // Dump settings
     let mut buf = vec![0; 1024];
     const MAX_DEPTH: usize = Settings::SCHEMA.shape().max_depth;
-    for item in Settings::SCHEMA.nodes::<Path<String, '-'>, MAX_DEPTH>() {
+    for item in Settings::SCHEMA.nodes::<ConstPath<String, '-'>, MAX_DEPTH>() {
         let key = item.unwrap();
         let mut k = key.into_keys().track();
         match json_core::get_by_key(&settings, &mut k, &mut buf[..]) {

miniconf/examples/scpi.rs

@@ -1,8 +1,8 @@
 use core::str;
 
 use miniconf::{
-    IntoKeys, Keys, Path, PathIter, SerdeError, TreeDeserializeOwned, TreeSchema, TreeSerialize,
-    ValueError, json_core,
+    ConstPath, ConstPathIter, IntoKeys, Keys, SerdeError, TreeDeserializeOwned, TreeSchema,
+    TreeSerialize, ValueError, json_core,
 };
 
 mod common;
@@ -32,7 +32,7 @@ impl<T: AsRef<str> + ?Sized> miniconf::Key for ScpiKey<T> {
                         || !name
                             .chars()
                             .zip(s.chars())
-                            .all(|(n, s)| n.to_ascii_lowercase() == s.to_ascii_lowercase())
+                            .all(|(n, s)| n.eq_ignore_ascii_case(&s))
                     {
                         continue;
                     }
@@ -57,7 +57,7 @@ impl<T: AsRef<str> + ?Sized> miniconf::Key for ScpiKey<T> {
 }
 
 #[derive(Clone)]
-struct ScpiPathIter<'a>(PathIter<'a, ':'>);
+struct ScpiPathIter<'a>(ConstPathIter<'a, ':'>);
 
 impl<'a> Iterator for ScpiPathIter<'a> {
     type Item = ScpiKey<&'a str>;
@@ -73,7 +73,7 @@ impl<'a> IntoIterator for ScpiPath<'a> {
     type IntoIter = ScpiPathIter<'a>;
     type Item = ScpiKey<&'a str>;
     fn into_iter(self) -> Self::IntoIter {
-        ScpiPathIter(PathIter::new(self.0))
+        ScpiPathIter(ConstPathIter::new(self.0))
     }
 }
 
@@ -134,7 +134,7 @@ fn main() -> anyhow::Result<()> {
 
     let mut buf = vec![0; 1024];
     const MAX_DEPTH: usize = Settings::SCHEMA.shape().max_depth;
-    for path in Settings::SCHEMA.nodes::<Path<String, ':'>, MAX_DEPTH>() {
+    for path in Settings::SCHEMA.nodes::<ConstPath<String, ':'>, MAX_DEPTH>() {
         let path = path?;
         match json_core::get_by_key(&settings, &path, &mut buf) {
             Ok(len) => println!(

miniconf/src/impls/internal.rs

@@ -98,44 +98,86 @@ impl<T: TreeSchema, const N: usize> TreeSchema for [T; N] {
     const SCHEMA: &'static Schema = &Schema::homogeneous(Homogeneous::new(N, T::SCHEMA));
 }
 
+fn serialize_by_key_slice<T: TreeSerialize, S: Serializer>(
+    values: &[T],
+    schema: &'static Schema,
+    mut keys: impl Keys,
+    ser: S,
+) -> Result<S::Ok, SerdeError<S::Error>> {
+    values[schema.next(&mut keys)?].serialize_by_key(keys, ser)
+}
+
+fn deserialize_by_key_slice<'de, T: TreeDeserialize<'de>, D: Deserializer<'de>>(
+    values: &mut [T],
+    schema: &'static Schema,
+    mut keys: impl Keys,
+    de: D,
+) -> Result<(), SerdeError<D::Error>> {
+    values[schema.next(&mut keys)?].deserialize_by_key(keys, de)
+}
+
+fn probe_by_key_slice<'de, T: TreeDeserialize<'de>, D: Deserializer<'de>>(
+    schema: &'static Schema,
+    mut keys: impl Keys,
+    de: D,
+) -> Result<(), SerdeError<D::Error>> {
+    schema.next(&mut keys)?;
+    T::probe_by_key(keys, de)
+}
+
+fn ref_any_by_key_slice<'a, T: TreeAny>(
+    values: &'a [T],
+    schema: &'static Schema,
+    mut keys: impl Keys,
+) -> Result<&'a dyn Any, ValueError> {
+    values[schema.next(&mut keys)?].ref_any_by_key(keys)
+}
+
+fn mut_any_by_key_slice<'a, T: TreeAny>(
+    values: &'a mut [T],
+    schema: &'static Schema,
+    mut keys: impl Keys,
+) -> Result<&'a mut dyn Any, ValueError> {
+    values[schema.next(&mut keys)?].mut_any_by_key(keys)
+}
+
 impl<T: TreeSerialize, const N: usize> TreeSerialize for [T; N]
 where
     Self: TreeSchema,
 {
     fn serialize_by_key<S: Serializer>(
         &self,
-        mut keys: impl Keys,
+        keys: impl Keys,
         ser: S,
     ) -> Result<S::Ok, SerdeError<S::Error>> {
-        self[Self::SCHEMA.next(&mut keys)?].serialize_by_key(keys, ser)
+        serialize_by_key_slice(self.as_slice(), Self::SCHEMA, keys, ser)
     }
 }
 
 impl<'de, T: TreeDeserialize<'de>, const N: usize> TreeDeserialize<'de> for [T; N] {
     fn deserialize_by_key<D: Deserializer<'de>>(
         &mut self,
-        mut keys: impl Keys,
+        keys: impl Keys,
         de: D,
     ) -> Result<(), SerdeError<D::Error>> {
-        self[Self::SCHEMA.next(&mut keys)?].deserialize_by_key(keys, de)
+        deserialize_by_key_slice(self.as_mut_slice(), Self::SCHEMA, keys, de)
     }
 
     fn probe_by_key<D: Deserializer<'de>>(
-        mut keys: impl Keys,
+        keys: impl Keys,
         de: D,
     ) -> Result<(), SerdeError<D::Error>> {
-        Self::SCHEMA.next(&mut keys)?;
-        T::probe_by_key(keys, de)
+        probe_by_key_slice::<T, _>(Self::SCHEMA, keys, de)
     }
 }
 
 impl<T: TreeAny, const N: usize> TreeAny for [T; N] {
-    fn ref_any_by_key(&self, mut keys: impl Keys) -> Result<&dyn Any, ValueError> {
-        self[Self::SCHEMA.next(&mut keys)?].ref_any_by_key(keys)
+    fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError> {
+        ref_any_by_key_slice(self.as_slice(), Self::SCHEMA, keys)
     }
 
-    fn mut_any_by_key(&mut self, mut keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
-        self[Self::SCHEMA.next(&mut keys)?].mut_any_by_key(keys)
+    fn mut_any_by_key(&mut self, keys: impl Keys) -> Result<&mut dyn Any, ValueError> {
+        mut_any_by_key_slice(self.as_mut_slice(), Self::SCHEMA, keys)
     }
 }