miniconf 0.20.1

Serialize/deserialize/access reflection for trees
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

//! `TreeSerialize`/`TreeDeserialize` with `postcard`.
//!
//! ```
//! use ::postcard::{de_flavors::Slice, ser_flavors::AllocVec};
//! use miniconf::{postcard, Leaf, Packed, Tree, TreeSchema};
//!
//! #[derive(Tree, Default, PartialEq, Debug)]
//! struct S {
//!     foo: u32,
//!     bar: [u16; 2],
//! };
//!
//! let source = S {
//!     foo: 9,
//!     bar: [7, 11],
//! };
//! let kv: Vec<_> = S::SCHEMA.nodes::<Packed, 2>()
//!     .map(|p| {
//!         let p = p.unwrap();
//!         let v = postcard::get_by_key(&source, p, AllocVec::new()).unwrap();
//!         (p.into_lsb().get(), v)
//!     })
//!     .collect();
//! assert_eq!(kv, [(2, vec![9]), (6, vec![7]), (7, vec![11])]);
//!
//! let mut target = S::default();
//! for (k, v) in kv {
//!     let p = Packed::from_lsb(k.try_into().unwrap());
//!     postcard::set_by_key(&mut target, p, Slice::new(&v[..])).unwrap();
//! }
//! assert_eq!(source, target);
//! ```

use postcard::{Deserializer, Serializer, de_flavors, ser_flavors};

use crate::{IntoKeys, SerdeError, TreeDeserialize, TreeSerialize};

/// Deserialize and set a node value from a `postcard` flavor.
pub fn set_by_key<'de, F: de_flavors::Flavor<'de>>(
    tree: &mut (impl TreeDeserialize<'de> + ?Sized),
    keys: impl IntoKeys,
    flavor: F,
) -> Result<F::Remainder, SerdeError<postcard::Error>> {
    let mut de = Deserializer::from_flavor(flavor);
    tree.deserialize_by_key(keys.into_keys(), &mut de)?;
    de.finalize().map_err(SerdeError::Finalization)
}

/// Get and serialize a node value into a `postcard` flavor.
pub fn get_by_key<F: ser_flavors::Flavor>(
    tree: &(impl TreeSerialize + ?Sized),
    keys: impl IntoKeys,
    flavor: F,
) -> Result<F::Output, SerdeError<postcard::Error>> {
    let mut ser = Serializer { output: flavor };
    tree.serialize_by_key(keys.into_keys(), &mut ser)?;
    ser.output.finalize().map_err(SerdeError::Finalization)
}