feat: add StrSeq Reg Node serialize

woshiluo · woshiluo · commit 7d58543ae6cb · 2025-02-25T10:46:00.000+08:00
feat: add re_encode example

Signed-off-by: Woshiluo Luo &lt;woshiluo.luo@outlook.com&gt;
diff --git a/examples/re_encode.rs b/examples/re_encode.rs
@@ -0,0 +1,30 @@
+use serde_device_tree::{Dtb, DtbPtr, buildin::Node, error::Error, from_raw_mut};
+
+use std::io::prelude::*;
+
+const RAW_DEVICE_TREE: &[u8] = include_bytes!("qemu-virt.dtb");
+const BUFFER_SIZE: usize = RAW_DEVICE_TREE.len();
+
+#[repr(align(8))]
+struct AlignedBuffer {
+    pub data: [u8; RAW_DEVICE_TREE.len()],
+}
+
+fn main() -> Result<(), Error> {
+    let mut aligned_data: Box<AlignedBuffer> = Box::new(AlignedBuffer {
+        data: [0; BUFFER_SIZE],
+    });
+    aligned_data.data[..BUFFER_SIZE].clone_from_slice(RAW_DEVICE_TREE);
+    let mut buf = [0u8; RAW_DEVICE_TREE.len() * 2];
+    let mut slice = aligned_data.data.to_vec();
+    let ptr = DtbPtr::from_raw(slice.as_mut_ptr())?;
+    let dtb = Dtb::from(ptr).share();
+
+    let root: Node = from_raw_mut(&dtb).unwrap();
+    serde_device_tree::ser::to_dtb(&root, &[], &mut buf).unwrap();
+
+    let mut file = std::fs::File::create("gen.dtb").unwrap();
+    file.write_all(&buf).unwrap();
+
+    Ok(())
+}
diff --git a/src/de_mut/cursor.rs b/src/de_mut/cursor.rs
@@ -29,10 +29,10 @@ pub enum MoveResult {
 }
 
 #[derive(Clone, Copy, Debug)]
-pub(super) struct MultiNodeCursor {
+pub(crate) struct MultiNodeCursor {
     pub start_cursor: BodyCursor,
-    pub next_cursor: BodyCursor,
     pub skip_cursor: BodyCursor,
+    pub data_cursor: BodyCursor,
     #[allow(unused)]
     pub node_count: u32,
 }
@@ -51,6 +51,7 @@ impl<T: Type> AnyCursor<T> {
 
 impl BodyCursor {
     pub const ROOT: Self = Self(2, PhantomData);
+    pub const STARTER: Self = Self(0, PhantomData);
 
     /// 移动到下一个项目。
     pub fn move_on(&mut self, dtb: RefDtb) -> Cursor {
@@ -82,6 +83,7 @@ impl BodyCursor {
         }
         todo!()
     }
+
     /// 移动指针至下一块
     pub fn move_next(&mut self, dtb: RefDtb) -> MoveResult {
         use StructureBlock as B;
@@ -183,8 +185,8 @@ impl TitleCursor {
         }
         MultiNodeCursor {
             start_cursor: group,
-            next_cursor: body,
-            skip_cursor: title_body,
+            skip_cursor: body,
+            data_cursor: title_body,
             node_count: len,
         }
     }
@@ -201,8 +203,8 @@ impl TitleCursor {
         body.escape_from(dtb);
         MultiNodeCursor {
             start_cursor: origin,
-            next_cursor: body,
-            skip_cursor: node,
+            skip_cursor: body,
+            data_cursor: node,
             node_count: 1,
         }
     }
diff --git a/src/de_mut/data.rs b/src/de_mut/data.rs
@@ -10,6 +10,7 @@ pub(super) enum ValueCursor {
     Body(BodyCursor),
     Prop(BodyCursor, PropCursor),
     Node(MultiNodeCursor),
+    NodeIn(MultiNodeCursor),
 }
 
 #[derive(Clone, Copy)]
@@ -208,8 +209,9 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
                     visitor.visit_some(self)
                 }
             }
-            ValueCursor::Node(_) => visitor.visit_some(self),
+            ValueCursor::NodeIn(_) => visitor.visit_some(self),
             ValueCursor::Body(_) => visitor.visit_some(self),
+            ValueCursor::Node(_) => unreachable!("Node to option(NodeIn instead)"),
         }
     }
 
@@ -251,7 +253,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
     {
         use super::{StructAccess, StructAccessType, Temp};
         match self.cursor {
-            ValueCursor::Node(result) => {
+            ValueCursor::NodeIn(result) => {
                 let mut start_cursor = result.start_cursor;
                 match start_cursor.move_on(self.dtb) {
                     Cursor::Title(c) => {
@@ -302,7 +304,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
     {
         use super::{StructAccess, StructAccessType, Temp};
         match self.cursor {
-            ValueCursor::Node(_) => visitor.visit_map(StructAccess {
+            ValueCursor::NodeIn(_) => visitor.visit_map(StructAccess {
                 access_type: StructAccessType::Map(false),
                 temp: Temp::Uninit,
                 de: self,
@@ -313,6 +315,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
                 de: self,
             }),
             ValueCursor::Prop(_, _) => unreachable!("Prop -> map"),
+            ValueCursor::Node(_) => unreachable!("Node -> map (Use NodeIn instead)"),
         }
     }
 
@@ -327,7 +330,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
     {
         use super::{StructAccess, StructAccessType, Temp};
         match self.cursor {
-            ValueCursor::Node(_) => visitor.visit_map(StructAccess {
+            ValueCursor::NodeIn(_) => visitor.visit_map(StructAccess {
                 access_type: StructAccessType::Struct(fields),
                 temp: Temp::Uninit,
                 de: self,
@@ -338,6 +341,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
                 de: self,
             }),
             ValueCursor::Prop(_, _) => unreachable!("Prop -> struct {_name}"),
+            ValueCursor::Node(_) => unreachable!("Node -> struct {_name} (Use NodeIn instead)"),
         }
     }
 
diff --git a/src/de_mut/mod.rs b/src/de_mut/mod.rs
@@ -7,7 +7,7 @@ use serde::de;
 mod cursor;
 mod data;
 // mod group;
-mod node;
+pub(crate) mod node;
 mod node_seq;
 mod reg;
 mod str_seq;
@@ -16,13 +16,16 @@ mod struct_access;
 mod structs;
 
 const VALUE_DESERIALIZER_NAME: &str = "$serde_device_tree$de_mut$ValueDeserializer";
+pub(crate) const NODE_NAME: &str = "$serde_device_tree$de_mut$Node";
+pub(crate) const NODE_NODE_ITEM_NAME: &str = "$serde_device_tree$de_mut$Node$NodeItem";
+pub(crate) const NODE_PROP_ITEM_NAME: &str = "$serde_device_tree$de_mut$Node$PropItem";
 
 pub use structs::{Dtb, DtbPtr};
 pub mod buildin {
     pub use super::{node::Node, node_seq::NodeSeq, reg::Reg, str_seq::StrSeq};
 }
 
-use cursor::{BodyCursor, Cursor, PropCursor};
+use cursor::{BodyCursor, Cursor, MultiNodeCursor, PropCursor};
 use data::{ValueCursor, ValueDeserializer};
 use reg::RegConfig;
 use struct_access::{StructAccess, StructAccessType, Temp};
@@ -41,7 +44,12 @@ where
     let mut d = ValueDeserializer {
         dtb,
         reg: RegConfig::DEFAULT,
-        cursor: ValueCursor::Body(BodyCursor::ROOT),
+        cursor: ValueCursor::NodeIn(MultiNodeCursor {
+            start_cursor: BodyCursor::STARTER,
+            skip_cursor: BodyCursor::ROOT, // This item will never be used.
+            data_cursor: BodyCursor::ROOT,
+            node_count: 1,
+        }),
     };
     T::deserialize(&mut d).and_then(|t| {
         // 解析必须完成
diff --git a/src/de_mut/node.rs b/src/de_mut/node.rs
@@ -1,8 +1,11 @@
-use super::{BodyCursor, Cursor, PropCursor, RefDtb, RegConfig, ValueCursor, ValueDeserializer};
+use super::{
+    BodyCursor, Cursor, MultiNodeCursor, PropCursor, RefDtb, RegConfig, ValueCursor,
+    ValueDeserializer,
+};
 use core::fmt::Debug;
 use core::marker::PhantomData;
 use serde::de::MapAccess;
-use serde::{Deserialize, de};
+use serde::{Deserialize, Serialize, de};
 
 // TODO: Spec 2.3.5 said that we should not inherited from ancestors and the size-cell &
 // address-cells should only used for current node's children.
@@ -27,7 +30,7 @@ pub struct NodeIter<'de, 'b> {
 pub struct NodeItem<'de> {
     dtb: RefDtb<'de>,
     reg: RegConfig,
-    node: BodyCursor,
+    node: MultiNodeCursor,
     name: &'de str,
 }
 
@@ -81,6 +84,16 @@ impl<'de> Node<'de> {
     pub fn get_prop<'b>(&'b self, name: &str) -> Option<PropItem<'b>> {
         self.props().find(|prop| prop.get_name() == name)
     }
+
+    pub fn name(&self) -> &'de str {
+        let cursor = self.cursor.clone().move_on(self.dtb);
+        if let Cursor::Title(c) = cursor {
+            let (name, _) = c.split_on(self.dtb);
+            name
+        } else {
+            todo!();
+        }
+    }
 }
 
 impl Debug for Node<'_> {
@@ -128,10 +141,10 @@ impl<'de> Iterator for NodeIter<'de, '_> {
                 let res = Some(Self::Item {
                     dtb,
                     reg: self.node.reg,
-                    node: node_cursor.skip_cursor,
+                    node: node_cursor,
                     name,
                 });
-                *cursor = node_cursor.next_cursor;
+                *cursor = node_cursor.skip_cursor;
                 res
             } else {
                 None
@@ -200,10 +213,9 @@ impl<'de> Deserialize<'de> for Node<'_> {
                     reg = Some(value.reg);
                     if key == "/" {
                         self_cursor = match value.cursor {
-                            ValueCursor::Body(cursor) => Some(cursor),
-                            ValueCursor::Node(result) => Some(result.next_cursor),
+                            ValueCursor::NodeIn(result) => Some(result.start_cursor),
                             _ => {
-                                unreachable!("root of NodeSeq shouble be body cursor")
+                                unreachable!("root of NodeSeq shouble be NodeIn cursor")
                             }
                         };
                         continue;
@@ -214,7 +226,7 @@ impl<'de> Deserialize<'de> for Node<'_> {
                                 props_start = Some(cursor);
                             }
                         }
-                        ValueCursor::Node(cursor) => {
+                        ValueCursor::NodeIn(cursor) => {
                             if nodes_start.is_none() {
                                 nodes_start = Some(cursor.start_cursor);
                             }
@@ -249,7 +261,7 @@ impl<'de> NodeItem<'de> {
         T::deserialize(&mut ValueDeserializer {
             dtb: self.dtb,
             reg: self.reg,
-            cursor: ValueCursor::Body(self.node),
+            cursor: ValueCursor::NodeIn(self.node),
         })
         .unwrap()
     }
@@ -271,13 +283,13 @@ impl<'de> NodeItem<'de> {
         }
     }
 
-    pub fn get_full_name(&self) -> &str {
+    pub fn get_full_name(&self) -> &'de str {
         self.name
     }
 }
 
 impl<'de> PropItem<'de> {
-    pub fn get_name(&self) -> &str {
+    pub fn get_name(&self) -> &'de str {
         self.name
     }
     pub fn deserialize<T: Deserialize<'de>>(&self) -> T {
@@ -290,6 +302,32 @@ impl<'de> PropItem<'de> {
         .unwrap()
     }
 }
+impl<'se> Serialize for NodeItem<'se> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_newtype_struct(crate::de_mut::NODE_NODE_ITEM_NAME, self)
+    }
+}
+
+impl<'se> Serialize for PropItem<'se> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_bytes(self.prop.data_on(self.dtb))
+    }
+}
+
+impl<'se> Serialize for Node<'se> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_newtype_struct(crate::de_mut::NODE_NAME, self)
+    }
+}
 
 #[cfg(test)]
 mod tests {
diff --git a/src/de_mut/node_seq.rs b/src/de_mut/node_seq.rs
@@ -140,12 +140,12 @@ impl<'de> Iterator for NodeSeqIter<'de, '_> {
                         return None;
                     }
 
-                    self.de.cursor = ValueCursor::Body(node_reuslt.next_cursor);
+                    self.de.cursor = ValueCursor::Body(node_reuslt.skip_cursor);
 
                     Some(Self::Item {
                         dtb: self.de.dtb,
                         reg: self.de.reg,
-                        body: node_reuslt.skip_cursor,
+                        body: node_reuslt.data_cursor,
                         at: suf_name,
                     })
                 }
diff --git a/src/de_mut/reg.rs b/src/de_mut/reg.rs
@@ -1,6 +1,6 @@
 use super::{BLOCK_LEN, PropCursor, RefDtb, ValueCursor};
 use core::{fmt::Debug, ops::Range};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 /// 节点地址空间。
 pub struct Reg<'de>(Inner<'de>);
@@ -116,3 +116,13 @@ impl Iterator for RegIter<'_> {
         }
     }
 }
+
+impl<'se> Serialize for Reg<'se> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        // Pass bytes directly for Reg.
+        serializer.serialize_bytes(self.0.cursor.data_on(self.0.dtb))
+    }
+}
diff --git a/src/de_mut/str_seq.rs b/src/de_mut/str_seq.rs
@@ -1,6 +1,6 @@
 ﻿use super::{PropCursor, RefDtb, ValueCursor};
 use core::fmt::Debug;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 /// 一组 '\0' 分隔字符串的映射。
 ///
@@ -90,3 +90,13 @@ impl<'de> Iterator for StrSeqIter<'de> {
         }
     }
 }
+
+impl<'se> Serialize for StrSeq<'se> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        // Pass bytes directly for StrSeq.
+        serializer.serialize_bytes(self.0.cursor.data_on(self.0.dtb))
+    }
+}
diff --git a/src/de_mut/struct_access.rs b/src/de_mut/struct_access.rs
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
diff --git a/src/ser/serializer.rs b/src/ser/serializer.rs

Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,10 @@ pub enum MoveResult {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`#[derive(Clone, Copy, Debug)]`
`32`		`-pub(super) struct MultiNodeCursor {`
	`32`	`+pub(crate) struct MultiNodeCursor {`
`33`	`33`	`pub start_cursor: BodyCursor,`
`34`		`- pub next_cursor: BodyCursor,`
`35`	`34`	`pub skip_cursor: BodyCursor,`
	`35`	`+ pub data_cursor: BodyCursor,`
`36`	`36`	`#[allow(unused)]`
`37`	`37`	`pub node_count: u32,`
`38`	`38`	`}`
`@@ -51,6 +51,7 @@ impl<T: Type> AnyCursor<T> {`
`51`	`51`
`52`	`52`	`impl BodyCursor {`
`53`	`53`	`pub const ROOT: Self = Self(2, PhantomData);`
	`54`	`+ pub const STARTER: Self = Self(0, PhantomData);`
`54`	`55`
`55`	`56`	`/// 移动到下一个项目。`
`56`	`57`	`pub fn move_on(&mut self, dtb: RefDtb) -> Cursor {`
`@@ -82,6 +83,7 @@ impl BodyCursor {`
`82`	`83`	`}`
`83`	`84`	`todo!()`
`84`	`85`	`}`
	`86`	`+`
`85`	`87`	`/// 移动指针至下一块`
`86`	`88`	`pub fn move_next(&mut self, dtb: RefDtb) -> MoveResult {`
`87`	`89`	`use StructureBlock as B;`
`@@ -183,8 +185,8 @@ impl TitleCursor {`
`183`	`185`	`}`
`184`	`186`	`MultiNodeCursor {`
`185`	`187`	`start_cursor: group,`
`186`		`- next_cursor: body,`
`187`		`- skip_cursor: title_body,`
	`188`	`+ skip_cursor: body,`
	`189`	`+ data_cursor: title_body,`
`188`	`190`	`node_count: len,`
`189`	`191`	`}`
`190`	`192`	`}`
`@@ -201,8 +203,8 @@ impl TitleCursor {`
`201`	`203`	`body.escape_from(dtb);`
`202`	`204`	`MultiNodeCursor {`
`203`	`205`	`start_cursor: origin,`
`204`		`- next_cursor: body,`
`205`		`- skip_cursor: node,`
	`206`	`+ skip_cursor: body,`
	`207`	`+ data_cursor: node,`
`206`	`208`	`node_count: 1,`
`207`	`209`	`}`
`208`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ pub(super) enum ValueCursor {`
`10`	`10`	`Body(BodyCursor),`
`11`	`11`	`Prop(BodyCursor, PropCursor),`
`12`	`12`	`Node(MultiNodeCursor),`
	`13`	`+ NodeIn(MultiNodeCursor),`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`#[derive(Clone, Copy)]`
`@@ -208,8 +209,9 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`208`	`209`	`visitor.visit_some(self)`
`209`	`210`	`}`
`210`	`211`	`}`
`211`		`- ValueCursor::Node(_) => visitor.visit_some(self),`
	`212`	`+ ValueCursor::NodeIn(_) => visitor.visit_some(self),`
`212`	`213`	`ValueCursor::Body(_) => visitor.visit_some(self),`
	`214`	`+ ValueCursor::Node(_) => unreachable!("Node to option(NodeIn instead)"),`
`213`	`215`	`}`
`214`	`216`	`}`
`215`	`217`
`@@ -251,7 +253,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`251`	`253`	`{`
`252`	`254`	`use super::{StructAccess, StructAccessType, Temp};`
`253`	`255`	`match self.cursor {`
`254`		`- ValueCursor::Node(result) => {`
	`256`	`+ ValueCursor::NodeIn(result) => {`
`255`	`257`	`let mut start_cursor = result.start_cursor;`
`256`	`258`	`match start_cursor.move_on(self.dtb) {`
`257`	`259`	`Cursor::Title(c) => {`
`@@ -302,7 +304,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`302`	`304`	`{`
`303`	`305`	`use super::{StructAccess, StructAccessType, Temp};`
`304`	`306`	`match self.cursor {`
`305`		`- ValueCursor::Node(_) => visitor.visit_map(StructAccess {`
	`307`	`+ ValueCursor::NodeIn(_) => visitor.visit_map(StructAccess {`
`306`	`308`	`access_type: StructAccessType::Map(false),`
`307`	`309`	`temp: Temp::Uninit,`
`308`	`310`	`de: self,`
`@@ -313,6 +315,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`313`	`315`	`de: self,`
`314`	`316`	`}),`
`315`	`317`	`ValueCursor::Prop(_, _) => unreachable!("Prop -> map"),`
	`318`	`+ ValueCursor::Node(_) => unreachable!("Node -> map (Use NodeIn instead)"),`
`316`	`319`	`}`
`317`	`320`	`}`
`318`	`321`
`@@ -327,7 +330,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`327`	`330`	`{`
`328`	`331`	`use super::{StructAccess, StructAccessType, Temp};`
`329`	`332`	`match self.cursor {`
`330`		`- ValueCursor::Node(_) => visitor.visit_map(StructAccess {`
	`333`	`+ ValueCursor::NodeIn(_) => visitor.visit_map(StructAccess {`
`331`	`334`	`access_type: StructAccessType::Struct(fields),`
`332`	`335`	`temp: Temp::Uninit,`
`333`	`336`	`de: self,`
`@@ -338,6 +341,7 @@ impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {`
`338`	`341`	`de: self,`
`339`	`342`	`}),`
`340`	`343`	`ValueCursor::Prop(_, _) => unreachable!("Prop -> struct {_name}"),`
	`344`	`+ ValueCursor::Node(_) => unreachable!("Node -> struct {_name} (Use NodeIn instead)"),`
`341`	`345`	`}`
`342`	`346`	`}`
`343`	`347`
Original file line number	Diff line number	Diff line change
`@@ -140,12 +140,12 @@ impl<'de> Iterator for NodeSeqIter<'de, '_> {`
`140`	`140`	`return None;`
`141`	`141`	`}`
`142`	`142`
`143`		`- self.de.cursor = ValueCursor::Body(node_reuslt.next_cursor);`
	`143`	`+ self.de.cursor = ValueCursor::Body(node_reuslt.skip_cursor);`
`144`	`144`
`145`	`145`	`Some(Self::Item {`
`146`	`146`	`dtb: self.de.dtb,`
`147`	`147`	`reg: self.de.reg,`
`148`		`- body: node_reuslt.skip_cursor,`
	`148`	`+ body: node_reuslt.data_cursor,`
`149`	`149`	`at: suf_name,`
`150`	`150`	`})`
`151`	`151`	`}`