add FdtMut::reborrow()

Author: m4tx

src/fdt_mut.rs

@@ -136,7 +136,7 @@ impl<'a> FdtMut<'a> {
         FdtNodeMut {
             offset: root.offset,
             parent_address_space: root.parent_address_space,
-            data: self.data,
+            data: self.reborrow(),
         }
     }
 
@@ -163,9 +163,15 @@ impl<'a> FdtMut<'a> {
         Some(FdtNodeMut {
             offset: node.offset,
             parent_address_space: node.parent_address_space,
-            data: self.data,
+            data: self.reborrow(),
         })
     }
+
+    fn reborrow(&mut self) -> FdtMut<'_> {
+        FdtMut {
+            data: self.data,
+        }
+    }
 }
 
 impl Debug for FdtMut<'_> {

src/fdt_mut/node.rs

@@ -12,16 +12,16 @@ use core::fmt::{Display, Formatter};
 use crate::fdt::node::InnerChildIter;
 use crate::fdt::node::private::FdtChildIter;
 use crate::fdt::property::{FdtPropIter, InnerPropIter};
-use crate::fdt::{Fdt, FdtNode};
-use crate::fdt_mut::FdtPropertyMut;
+use crate::fdt::FdtNode;
+use crate::fdt_mut::{FdtMut, FdtPropertyMut};
 use crate::fdt_mut::property::FdtPropMutIter;
 use crate::standard::{AddressSpaceProperties, NodeStandard};
 use crate::{Node, Property};
 
 /// A mutable device tree node.
 #[derive(Debug)]
 pub struct FdtNodeMut<'a> {
-    pub(crate) data: &'a mut [u8],
+    pub(crate) data: FdtMut<'a>,
     pub(crate) offset: usize,
     pub(crate) parent_address_space: AddressSpaceProperties,
 }
@@ -37,7 +37,7 @@ impl FdtNodeMut<'_> {
                     value_offset: prop.value_offset,
                     len: prop.len,
                     nameoff: prop.nameoff,
-                    data: self.data,
+                    data: self.data.reborrow(),
                 });
             }
         }
@@ -48,7 +48,7 @@ impl FdtNodeMut<'_> {
     pub fn properties_mut(&mut self) -> FdtPropMutIter<'_> {
         FdtPropMutIter {
             inner: InnerPropIter::new(self.offset),
-            data: self.data,
+            data: self.data.reborrow(),
         }
     }
 
@@ -58,14 +58,14 @@ impl FdtNodeMut<'_> {
         private::FdtChildMutIter {
             inner: InnerChildIter::new(self.offset),
             parent_address_space: address_space,
-            data: self.data,
+            data: self.data.reborrow(),
         }
     }
 
     /// Returns a read only view of this node.
     #[must_use]
     pub fn as_read_only(&self) -> FdtNode<'_> {
-        let fdt = Fdt { data: &*self.data };
+        let fdt = self.data.as_read_only();
         FdtNode {
             fdt,
             offset: self.offset,
@@ -120,15 +120,14 @@ impl Node for FdtNodeMut<'_> {
 }
 
 mod private {
-    use crate::fdt::Fdt;
     use crate::fdt::node::InnerChildIter;
-    use crate::fdt_mut::FdtNodeMut;
+    use crate::fdt_mut::{FdtMut, FdtNodeMut};
     use crate::standard::AddressSpaceProperties;
 
     /// A mutable iterator over the children of a device tree node.
     #[derive(Debug)]
     pub struct FdtChildMutIter<'a> {
-        pub(crate) data: &'a mut [u8],
+        pub(crate) data: FdtMut<'a>,
         pub(crate) parent_address_space: AddressSpaceProperties,
         pub(crate) inner: InnerChildIter,
     }
@@ -140,12 +139,12 @@ mod private {
         ///
         /// Panics if the underlying device tree data is invalid.
         pub fn next(&mut self) -> Option<FdtNodeMut<'_>> {
-            let fdt = Fdt::new_unchecked(&*self.data);
+            let fdt = self.data.as_read_only();
             let node_offset = self.inner.next(fdt)?;
             Some(FdtNodeMut {
                 offset: node_offset,
                 parent_address_space: self.parent_address_space,
-                data: self.data,
+                data: self.data.reborrow(),
             })
         }
     }

src/fdt_mut/property.rs

@@ -15,11 +15,12 @@ use crate::Property;
 use crate::error::FdtMutError;
 use crate::fdt::property::InnerPropIter;
 use crate::fdt::{FDT_TAGSIZE, Fdt, FdtProperty};
+use crate::fdt_mut::FdtMut;
 
 /// A mutable property of a device tree node.
 #[derive(Debug)]
 pub struct FdtPropertyMut<'a> {
-    pub(crate) data: &'a mut [u8],
+    pub(crate) data: FdtMut<'a>,
     pub(crate) nameoff: usize,
     pub(crate) prop_offset: usize,
     pub(crate) value_offset: usize,
@@ -64,7 +65,7 @@ impl FdtPropertyMut<'_> {
 
         // Update the length in the FDT property header
         let (len_bytes, _) =
-            <big_endian::U32>::mut_from_prefix(&mut self.data[self.prop_offset + FDT_TAGSIZE..])
+            <big_endian::U32>::mut_from_prefix(&mut self.data.data[self.prop_offset + FDT_TAGSIZE..])
                 .expect("Fdt should be valid");
         len_bytes.set(
             new_value
@@ -74,12 +75,12 @@ impl FdtPropertyMut<'_> {
         );
 
         // Copy the new value
-        self.data[self.value_offset..self.value_offset + new_value.len()]
+        self.data.data[self.value_offset..self.value_offset + new_value.len()]
             .copy_from_slice(new_value);
 
         // Zero out any padding bytes
         for i in new_value.len()..new_padded {
-            self.data[self.value_offset + i] = 0;
+            self.data.data[self.value_offset + i] = 0;
         }
 
         self.len = new_value.len();
@@ -90,7 +91,7 @@ impl FdtPropertyMut<'_> {
     /// Returns the value of this property.
     #[must_use]
     pub fn value(&self) -> &[u8] {
-        &self.data[self.value_offset..self.value_offset + self.len]
+        &self.data.data[self.value_offset..self.value_offset + self.len]
     }
 
     /// Returns a read only view of this property.
@@ -100,7 +101,7 @@ impl FdtPropertyMut<'_> {
     /// Panics if the underlying device tree data is invalid.
     #[must_use]
     pub fn as_read_only(&self) -> FdtProperty<'_> {
-        let fdt = Fdt { data: &*self.data };
+        let fdt = self.data.as_read_only();
         let name = fdt.string(self.nameoff).expect("Fdt should be valid");
         let value = fdt
             .data
@@ -123,12 +124,12 @@ impl<'a> Property for &'a FdtPropertyMut<'_> {
     type CellsItem = crate::Cells<'a>;
 
     fn name(&self) -> &str {
-        let fdt = Fdt { data: &*self.data };
+        let fdt = self.data.as_read_only();
         fdt.string(self.nameoff).expect("Fdt should be valid")
     }
 
     fn value(&self) -> &[u8] {
-        let fdt = Fdt { data: &*self.data };
+        let fdt = self.data.as_read_only();
         fdt.data
             .get(self.value_offset..self.value_offset + self.len)
             .expect("Fdt should be valid")
@@ -157,7 +158,7 @@ impl<'a> Property for &'a FdtPropertyMut<'_> {
 /// A mutable iterator over the properties of a device tree node.
 #[derive(Debug)]
 pub struct FdtPropMutIter<'a> {
-    pub(crate) data: &'a mut [u8],
+    pub(crate) data: FdtMut<'a>,
     pub(crate) inner: InnerPropIter,
 }
 
@@ -168,14 +169,14 @@ impl FdtPropMutIter<'_> {
     ///
     /// Panics if the underlying device tree data is invalid.
     pub fn next(&mut self) -> Option<FdtPropertyMut<'_>> {
-        let fdt = Fdt::new_unchecked(&*self.data);
+        let fdt = self.data.as_read_only();
         let parsed = self.inner.next(fdt)?;
         Some(FdtPropertyMut {
             prop_offset: parsed.prop_offset,
             value_offset: parsed.value_offset,
             len: parsed.len,
             nameoff: parsed.nameoff,
-            data: self.data,
+            data: self.data.reborrow(),
         })
     }
 }