feat: add ToPropertyValue trait (#70)

Author: m4tx

src/fdt_mut.rs

@@ -23,6 +23,7 @@ pub use node::FdtNodeMut;
 pub use property::FdtPropertyMut;
 use zerocopy::{FromBytes, big_endian};
 
+use crate::ToPropertyValue;
 use crate::error::{BufferError, FdtParseError};
 use crate::fdt::{FDT_NOP, FDT_TAGSIZE, Fdt, FdtHeader, FdtToken};
 
@@ -326,12 +327,16 @@ impl<B: FdtBuffer> FdtMut<B> {
         }
     }
 
-    fn copy_data_with_padding(&mut self, value: &[u8], padded_val_len: usize, val_offset: usize) {
+    fn write_property_value_with_padding<T: ToPropertyValue>(
+        &mut self,
+        value: &T,
+        padded_val_len: usize,
+        val_offset: usize,
+    ) {
+        let val_len = value.property_value_len();
         let data = self.data_mut();
-        data[val_offset..val_offset + value.len()].copy_from_slice(value);
-        for i in value.len()..padded_val_len {
-            data[val_offset + i] = 0;
-        }
+        value.write_property_value(&mut data[val_offset..val_offset + val_len]);
+        data[val_offset + val_len..val_offset + padded_val_len].fill(0);
     }
 }
 

src/fdt_mut/node.rs

@@ -17,7 +17,7 @@ use crate::fdt_mut::buffer::FdtBuffer;
 use crate::fdt_mut::property::FdtPropMutIter;
 use crate::fdt_mut::{FdtMut, FdtPropertyMut};
 use crate::standard::{AddressSpaceProperties, NodeStandard};
-use crate::{Node, Property};
+use crate::{Node, Property, ToPropertyValue};
 
 /// A mutable device tree node.
 #[derive(Debug)]
@@ -84,10 +84,10 @@ impl<B: FdtBuffer> FdtNodeMut<'_, B> {
     ///
     /// Panics if the node name or existing structure is invalid, or if lengths
     /// exceed `u32::MAX`.
-    pub fn add_property(
+    pub fn add_property<T: ToPropertyValue>(
         &mut self,
         name: &str,
-        value: &[u8],
+        value: T,
     ) -> Result<FdtPropertyMut<'_, B>, crate::error::FdtMutError> {
         let nameoff = self.data.add_string(name)? as usize;
         let fdt = self.as_read_only().fdt;
@@ -96,15 +96,16 @@ impl<B: FdtBuffer> FdtNodeMut<'_, B> {
         offset = Fdt::align_tag_offset(name_end);
         let insert_offset = fdt.skip_props(offset, false).expect("valid dt");
 
-        let padded_val_len = Fdt::align_tag_offset(value.len());
+        let val_len = value.property_value_len();
+        let padded_val_len = Fdt::align_tag_offset(val_len);
         let required_space = FDT_TAGSIZE * 3 + padded_val_len;
 
         self.data.shift_dt_struct(insert_offset, required_space)?;
 
         let data = self.data.data_mut();
         data[insert_offset..insert_offset + FDT_TAGSIZE].copy_from_slice(&FDT_PROP.to_be_bytes());
         data[insert_offset + FDT_TAGSIZE..insert_offset + 2 * FDT_TAGSIZE].copy_from_slice(
-            &u32::try_from(value.len())
+            &u32::try_from(val_len)
                 .expect("len fits in u32")
                 .to_be_bytes(),
         );
@@ -116,12 +117,12 @@ impl<B: FdtBuffer> FdtNodeMut<'_, B> {
 
         let val_offset = insert_offset + 3 * FDT_TAGSIZE;
         self.data
-            .copy_data_with_padding(value, padded_val_len, val_offset);
+            .write_property_value_with_padding(&value, padded_val_len, val_offset);
 
         Ok(FdtPropertyMut {
             prop_offset: insert_offset,
             value_offset: val_offset,
-            len: value.len(),
+            len: val_len,
             nameoff,
             data: self.data,
         })

src/fdt_mut/property.rs

@@ -11,12 +11,12 @@ use core::fmt::{Display, Formatter};
 
 use zerocopy::{FromBytes, big_endian};
 
-use crate::Property;
 use crate::error::FdtMutError;
 use crate::fdt::property::InnerPropIter;
 use crate::fdt::{FDT_TAGSIZE, Fdt, FdtProperty};
 use crate::fdt_mut::FdtMut;
 use crate::fdt_mut::buffer::FdtBuffer;
+use crate::{Property, ToPropertyValue};
 
 /// A mutable property of a device tree node.
 #[derive(Debug)]
@@ -63,9 +63,10 @@ impl<B: FdtBuffer> FdtPropertyMut<'_, B> {
     /// node.property_mut("prop").unwrap().set_value(b"foo\0");
     /// assert_eq!(node.property("prop").unwrap().value(), b"foo\0");
     /// ```
-    pub fn set_value(&mut self, new_value: &[u8]) -> Result<(), FdtMutError> {
+    pub fn set_value<T: ToPropertyValue>(&mut self, new_value: T) -> Result<(), FdtMutError> {
+        let new_len = new_value.property_value_len();
         let old_padded = Fdt::align_tag_offset(self.len);
-        let new_padded = Fdt::align_tag_offset(new_value.len());
+        let new_padded = Fdt::align_tag_offset(new_len);
 
         if new_padded > old_padded {
             let needed_bytes = new_padded - old_padded;
@@ -87,15 +88,10 @@ impl<B: FdtBuffer> FdtPropertyMut<'_, B> {
             &mut self.data.data_mut()[self.prop_offset + FDT_TAGSIZE..],
         )
         .expect("Fdt should be valid");
-        len_bytes.set(
-            new_value
-                .len()
-                .try_into()
-                .expect("length should fit in u32"),
-        );
+        len_bytes.set(new_len.try_into().expect("length should fit in u32"));
 
         self.data
-            .copy_data_with_padding(new_value, new_padded, self.value_offset);
+            .write_property_value_with_padding(&new_value, new_padded, self.value_offset);
 
         if new_padded < old_padded {
             self.data.replace_with_nops(
@@ -104,7 +100,7 @@ impl<B: FdtBuffer> FdtPropertyMut<'_, B> {
             );
         }
 
-        self.len = new_value.len();
+        self.len = new_len;
 
         Ok(())
     }

src/lib.rs

@@ -61,7 +61,7 @@
 //! // Add a child node to the root.
 //! let child = DeviceTreeNode::builder("child")
 //!     .unwrap()
-//!     .property(DeviceTreeProperty::new("my-property", "hello\0").unwrap())
+//!     .property(DeviceTreeProperty::new("my-property", "hello").unwrap())
 //!     .build();
 //! tree.root.add_child(child);
 //!
@@ -133,13 +133,13 @@ pub mod standard;
 mod util;
 mod validate;
 mod values;
-
 use core::fmt::{self, Display, Formatter};
 use core::ops::{BitOr, Shl};
 
 use zerocopy::big_endian;
 
 use crate::error::{PropertyError, StandardError};
+pub use crate::values::ToPropertyValue;
 
 macro_rules! impl_property_methods {
     (get_value = |$self:ident| $get_value:expr) => {

src/model/node.rs

@@ -150,7 +150,7 @@ impl<'a> Node for &'a DeviceTreeNode {
     /// use dtoolkit::{Node, Property};
     ///
     /// let mut node = DeviceTreeNode::new("my-node").unwrap();
-    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap());
+    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap());
     /// let prop = (&node).property("my-prop").unwrap();
     /// assert_eq!(prop.value(), &[1, 2, 3, 4]);
     /// ```
@@ -287,9 +287,9 @@ impl DeviceTreeNode {
     /// use dtoolkit::model::{DeviceTreeNode, DeviceTreeProperty};
     ///
     /// let mut node = DeviceTreeNode::new("my-node").unwrap();
-    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap());
+    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap());
     /// let prop = node.property_mut("my-prop").unwrap();
-    /// prop.set_value(vec![5, 6, 7, 8]);
+    /// prop.set_value(vec![5u8, 6, 7, 8]);
     /// assert_eq!((&*prop).value(), &[5, 6, 7, 8]);
     /// ```
     #[must_use]
@@ -310,7 +310,7 @@ impl DeviceTreeNode {
     /// use dtoolkit::{Node, Property};
     ///
     /// let mut node = DeviceTreeNode::new("my-node").unwrap();
-    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap());
+    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap());
     /// assert_eq!((&node).property("my-prop").unwrap().value(), &[1, 2, 3, 4]);
     /// ```
     pub fn add_property(&mut self, property: DeviceTreeProperty) {
@@ -332,7 +332,7 @@ impl DeviceTreeNode {
     /// use dtoolkit::{Node, Property};
     ///
     /// let mut node = DeviceTreeNode::new("my-node").unwrap();
-    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap());
+    /// node.add_property(DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap());
     /// let prop = node.remove_property("my-prop").unwrap();
     /// assert_eq!((&prop).value(), &[1, 2, 3, 4]);
     /// assert!(node.property("my-prop").is_none());
@@ -361,7 +361,7 @@ impl DeviceTreeNode {
     /// let mut node = DeviceTreeNode::new("my-node").unwrap();
     /// node.add_child(DeviceTreeNode::new("child").unwrap());
     /// let child = node.child_mut("child").unwrap();
-    /// child.add_property(DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap());
+    /// child.add_property(DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap());
     /// assert_eq!(
     ///     (&*child).property("my-prop").unwrap().value(),
     ///     &[1, 2, 3, 4]
@@ -414,7 +414,7 @@ impl DeviceTreeNode {
     ///         .property("test")
     ///         .unwrap()
     ///         .value(),
-    ///     b"value"
+    ///     b"value\0"
     /// );
     /// ```
     #[must_use]

src/model/overlay.rs

@@ -482,28 +482,28 @@ mod tests {
     fn merge_node_works() {
         let mut target = DeviceTreeNode::builder("target")
             .unwrap()
-            .property(DeviceTreeProperty::new("a", vec![1]).unwrap())
+            .property(DeviceTreeProperty::new("a", vec![1u8]).unwrap())
             .child(
                 DeviceTreeNode::builder("child")
                     .unwrap()
-                    .property(DeviceTreeProperty::new("c", vec![3]).unwrap())
+                    .property(DeviceTreeProperty::new("c", vec![3u8]).unwrap())
                     .build(),
             )
             .build();
 
         let overlay = DeviceTreeNode::builder("overlay")
             .unwrap()
-            .property(DeviceTreeProperty::new("b", vec![4]).unwrap())
+            .property(DeviceTreeProperty::new("b", vec![4u8]).unwrap())
             .child(
                 DeviceTreeNode::builder("child")
                     .unwrap()
-                    .property(DeviceTreeProperty::new("d", vec![5]).unwrap())
+                    .property(DeviceTreeProperty::new("d", vec![5u8]).unwrap())
                     .build(),
             )
             .child(
                 DeviceTreeNode::builder("new_child")
                     .unwrap()
-                    .property(DeviceTreeProperty::new("e", vec![6]).unwrap())
+                    .property(DeviceTreeProperty::new("e", vec![6u8]).unwrap())
                     .build(),
             )
             .build();
@@ -521,19 +521,19 @@ mod tests {
 
         let expected = DeviceTreeNode::builder("target")
             .unwrap()
-            .property(DeviceTreeProperty::new("a", vec![1]).unwrap())
-            .property(DeviceTreeProperty::new("b", vec![4]).unwrap())
+            .property(DeviceTreeProperty::new("a", vec![1u8]).unwrap())
+            .property(DeviceTreeProperty::new("b", vec![4u8]).unwrap())
             .child(
                 DeviceTreeNode::builder("child")
                     .unwrap()
-                    .property(DeviceTreeProperty::new("c", vec![3]).unwrap())
-                    .property(DeviceTreeProperty::new("d", vec![5]).unwrap())
+                    .property(DeviceTreeProperty::new("c", vec![3u8]).unwrap())
+                    .property(DeviceTreeProperty::new("d", vec![5u8]).unwrap())
                     .build(),
             )
             .child(
                 DeviceTreeNode::builder("new_child")
                     .unwrap()
-                    .property(DeviceTreeProperty::new("e", vec![6]).unwrap())
+                    .property(DeviceTreeProperty::new("e", vec![6u8]).unwrap())
                     .build(),
             )
             .build();

src/model/property.rs

@@ -14,7 +14,7 @@ use zerocopy::FromBytes;
 
 use crate::error::ModelError;
 use crate::values::{FdtStringListIterator, PropEncodedArrayIterator};
-use crate::{Cells, Property};
+use crate::{Cells, Property, ToPropertyValue};
 
 /// A mutable, in-memory representation of a device tree property.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -54,28 +54,27 @@ impl DeviceTreeProperty {
     /// use dtoolkit::Property;
     /// use dtoolkit::model::DeviceTreeProperty;
     ///
-    /// let prop = DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap();
+    /// let prop = DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap();
     /// assert_eq!((&prop).name(), "my-prop");
     /// assert_eq!((&prop).value(), &[1, 2, 3, 4]);
     /// ```
-    pub fn new(name: impl Into<String>, value: impl Into<Vec<u8>>) -> Result<Self, ModelError> {
+    pub fn new<T: ToPropertyValue>(name: impl Into<String>, value: T) -> Result<Self, ModelError> {
         let name = name.into();
         if !crate::validate::is_valid_property_name(&name) {
             return Err(ModelError::InvalidPropertyName(name));
         }
-        Ok(Self {
-            name,
-            value: value.into(),
-        })
+        Ok(Self::new_unchecked(name, value))
     }
 
     /// Creates a new `DeviceTreeProperty` with the given name and value without
     /// validation.
     #[must_use]
-    pub fn new_unchecked(name: impl Into<String>, value: impl Into<Vec<u8>>) -> Self {
+    pub fn new_unchecked<T: ToPropertyValue>(name: impl Into<String>, value: T) -> Self {
+        let mut vec = alloc::vec![0; value.property_value_len()];
+        value.write_property_value(&mut vec);
         Self {
             name: name.into(),
-            value: value.into(),
+            value: vec,
         }
     }
 
@@ -87,12 +86,13 @@ impl DeviceTreeProperty {
     /// use dtoolkit::Property;
     /// use dtoolkit::model::DeviceTreeProperty;
     ///
-    /// let mut prop = DeviceTreeProperty::new("my-prop", vec![1, 2, 3, 4]).unwrap();
-    /// prop.set_value(vec![5, 6, 7, 8]);
+    /// let mut prop = DeviceTreeProperty::new("my-prop", vec![1u8, 2, 3, 4]).unwrap();
+    /// prop.set_value(vec![5u8, 6, 7, 8]);
     /// assert_eq!((&prop).value(), &[5, 6, 7, 8]);
     /// ```
-    pub fn set_value(&mut self, value: impl Into<Vec<u8>>) {
-        self.value = value.into();
+    pub fn set_value<T: ToPropertyValue>(&mut self, value: T) {
+        self.value.resize(value.property_value_len(), 0);
+        value.write_property_value(&mut self.value);
     }
 }