feat: avoid option of Node::props and Node::nodes

Signed-off-by: Woshiluo Luo <woshiluo.luo@outlook.com>

Author: woshiluo

examples/qemu-virt.rs

@@ -133,7 +133,7 @@ fn main() -> Result<(), Error> {
         }
 
         println!("{:?}", t.soc);
-        for current_node in t.soc.nodes().unwrap() {
+        for current_node in t.soc.nodes() {
             if current_node.get_parsed_name().0 == "virtio_mmio" {
                 let mmio = current_node.deserialize::<VirtIoMmio>();
                 println!("{:?} {:?}", current_node.get_parsed_name(), mmio.reg);

src/de_mut/node.rs

@@ -18,7 +18,7 @@ pub struct Node<'de> {
 /// 节点迭代器。
 pub struct NodeIter<'de, 'b> {
     node: &'b Node<'de>,
-    cursor: BodyCursor,
+    cursor: Option<BodyCursor>,
     i: usize,
 }
 
@@ -33,7 +33,7 @@ pub struct NodeItem<'de> {
 /// 属性迭代器。
 pub struct PropIter<'de, 'b> {
     node: &'b Node<'de>,
-    cursor: BodyCursor,
+    cursor: Option<BodyCursor>,
     i: usize,
 }
 
@@ -50,52 +50,48 @@ pub struct PropItem<'de> {
 impl<'de> Node<'de> {
     // TODO: Maybe use BTreeMap when have alloc
     /// 获得节点迭代器。
-    pub fn nodes<'b>(&'b self) -> Option<NodeIter<'de, 'b>> {
-        self.nodes_start.map(|node_cursor| NodeIter {
+    pub fn nodes<'b>(&'b self) -> NodeIter<'de, 'b> {
+        NodeIter {
             node: self,
-            cursor: node_cursor,
+            cursor: self.nodes_start,
             i: 0,
-        })
+        }
     }
 
     /// 获得属性迭代器。
-    pub fn props<'b>(&'b self) -> Option<PropIter<'de, 'b>> {
-        self.props_start.map(|node_cursor| PropIter {
+    pub fn props<'b>(&'b self) -> PropIter<'de, 'b> {
+        PropIter {
             node: self,
-            cursor: node_cursor,
+            cursor: self.props_start,
             i: 0,
-        })
+        }
     }
 }
 
 impl Debug for Node<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let props = self.props();
         write!(f, "Props: [")?;
-        if let Some(s) = props {
-            let mut first_written = true;
-            for prop in s {
-                if first_written {
-                    write!(f, "\"{}\"", prop.get_name())?;
-                    first_written = false;
-                } else {
-                    write!(f, ",\"{}\"", prop.get_name())?;
-                }
+        let mut first_written = true;
+        for prop in props {
+            if first_written {
+                write!(f, "\"{}\"", prop.get_name())?;
+                first_written = false;
+            } else {
+                write!(f, ",\"{}\"", prop.get_name())?;
             }
         }
         writeln!(f, "]")?;
 
         let children = self.nodes();
         write!(f, "Children: [")?;
-        if let Some(s) = children {
-            let mut first_written = true;
-            for child in s {
-                if first_written {
-                    write!(f, "\"{}\"", child.get_full_name())?;
-                    first_written = false;
-                } else {
-                    write!(f, ",\"{}\"", child.get_full_name())?;
-                }
+        let mut first_written = true;
+        for child in children {
+            if first_written {
+                write!(f, "\"{}\"", child.get_full_name())?;
+                first_written = false;
+            } else {
+                write!(f, ",\"{}\"", child.get_full_name())?;
             }
         }
         writeln!(f, "]")?;
@@ -108,19 +104,23 @@ impl<'de> Iterator for NodeIter<'de, '_> {
     type Item = NodeItem<'de>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.i += 1;
-        let dtb = self.node.dtb;
-        if let Cursor::Title(c) = self.cursor.move_on(dtb) {
-            let (name, _) = c.split_on(dtb);
-            let (node_cursor, next) = c.take_node_on(dtb, name);
-            let res = Some(Self::Item {
-                dtb,
-                reg: self.node.reg,
-                node: node_cursor,
-                name,
-            });
-            self.cursor = next;
-            res
+        if let Some(ref mut cursor) = self.cursor {
+            self.i += 1;
+            let dtb = self.node.dtb;
+            if let Cursor::Title(c) = cursor.move_on(dtb) {
+                let (name, _) = c.split_on(dtb);
+                let (node_cursor, next) = c.take_node_on(dtb, name);
+                let res = Some(Self::Item {
+                    dtb,
+                    reg: self.node.reg,
+                    node: node_cursor,
+                    name,
+                });
+                *cursor = next;
+                res
+            } else {
+                None
+            }
         } else {
             None
         }
@@ -131,19 +131,23 @@ impl<'de> Iterator for PropIter<'de, '_> {
     type Item = PropItem<'de>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.i += 1;
-        let dtb = self.node.dtb;
-        if let Cursor::Prop(c) = self.cursor.move_on(dtb) {
-            let (name, next) = c.name_on(dtb);
-            let res = Some(Self::Item {
-                dtb,
-                body: self.cursor,
-                reg: self.node.reg,
-                prop: c,
-                name,
-            });
-            self.cursor = next;
-            res
+        if let Some(ref mut cursor) = self.cursor {
+            self.i += 1;
+            let dtb = self.node.dtb;
+            if let Cursor::Prop(c) = cursor.move_on(dtb) {
+                let (name, next) = c.name_on(dtb);
+                let res = Some(Self::Item {
+                    dtb,
+                    body: *cursor,
+                    reg: self.node.reg,
+                    prop: c,
+                    name,
+                });
+                *cursor = next;
+                res
+            } else {
+                None
+            }
         } else {
             None
         }

src/utils/mod.rs

@@ -18,14 +18,7 @@ impl Node<'_> {
                 Some(node) => node,
                 None => break,
             };
-            let mut nodes = match node.nodes() {
-                Some(nodes) => nodes,
-                None => {
-                    current_node = None;
-                    break;
-                }
-            };
-            let next_node_iter = nodes.find(|x| x.get_full_name() == current_name);
+            let next_node_iter = node.nodes().find(|x| x.get_full_name() == current_name);
             match next_node_iter {
                 None => current_node = None,
                 Some(iter) => {
@@ -43,11 +36,9 @@ impl Node<'_> {
         F: FnMut(&Node),
     {
         func(self);
-        if let Some(nodes) = self.nodes() {
-            for node in nodes {
-                let node = node.deserialize::<Node>();
-                node.search(func);
-            }
+        for node in self.nodes() {
+            let node = node.deserialize::<Node>();
+            node.search(func);
         }
     }
 }
@@ -92,10 +83,7 @@ mod tests {
 
         let node: Node = from_raw_mut(&dtb).unwrap();
         let node = node.find("/chosen").unwrap();
-        let result = node
-            .props()
-            .unwrap()
-            .find(|prop| prop.get_name() == "stdout-path");
+        let result = node.props().find(|prop| prop.get_name() == "stdout-path");
         match result {
             Some(iter) => {
                 if iter.deserialize::<StrSeq>().iter().next().unwrap() != "serial0" {