refactor: 重构上下文管理，合并父节点压入和弹出逻辑，简化节点迭代器实现

Author: ZR233

fdt-edit/src/ctx.rs

@@ -123,32 +123,11 @@ impl<'a> Context<'a> {
         parent.ranges(grandparent_address_cells)
     }
 
-    /// 压入父节点，进入子节点前调用
-    pub fn push_parent(&mut self, parent: &'a Node) {
-        if let Some(ph) = parent.phandle() {
-            self.phandle_map.insert(ph, parent);
+    pub fn push(&mut self, node: &'a Node) {
+        if let Some(ph) = node.phandle() {
+            self.phandle_map.insert(ph, node);
         }
-
-        // 压入父节点栈
-        self.parents.push(parent);
-    }
-
-    /// 弹出父节点，离开子节点后调用
-    pub fn pop_parent(&mut self) -> Option<&'a Node> {
-        let node = self.parents.pop()?;
-
-        Some(node)
-    }
-
-    /// 为进入指定子节点创建新的上下文
-    /// 当前节点成为新上下文的父节点
-    pub fn for_child(&self, current_node: &'a Node) -> Self {
-        let mut child_ctx = Self {
-            parents: self.parents.clone(),
-            phandle_map: self.phandle_map.clone(),
-        };
-        child_ctx.push_parent(current_node);
-        child_ctx
+        self.parents.push(node);
     }
 
     /// 通过 phandle 查找节点

fdt-edit/src/node/iter.rs

@@ -1,12 +1,12 @@
 use core::{
     fmt::Debug,
     ops::{Deref, DerefMut},
-    slice::IterMut,
+    slice::{Iter, IterMut},
 };
 
 use alloc::{string::String, vec::Vec};
 
-use crate::{Context, Node, Property, ctx};
+use crate::{Context, Node, Property};
 
 #[derive(Clone, Debug)]
 pub enum NodeRef<'a> {
@@ -127,13 +127,19 @@ impl<'a> DerefMut for NodeMut<'a> {
 }
 
 pub struct NodeIter<'a> {
-    stack: Vec<(&'a Node, Context<'a>)>,
+    ctx: Context<'a>,
+    node: Option<&'a Node>,
+    stack: Vec<Iter<'a, Node>>,
 }
 
 impl<'a> NodeIter<'a> {
     pub fn new(root: &'a Node) -> Self {
+        let ctx = Context::new();
+
         Self {
-            stack: vec![(root, Context::new())],
+            ctx,
+            node: Some(root),
+            stack: vec![],
         }
     }
 }
@@ -142,16 +148,28 @@ impl<'a> Iterator for NodeIter<'a> {
     type Item = NodeRef<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let (node, ctx) = self.stack.pop()?;
+        if let Some(n) = self.node.take() {
+            // 返回当前节点，并将其子节点压入栈中
+            let ctx = self.ctx.clone();
+            self.ctx.push(n);
+            self.stack.push(n.children.iter());
+            return Some(NodeRef::new(n, ctx));
+        }
+
+        let iter = self.stack.last_mut()?;
 
-        // 使用栈实现前序深度优先，保持原始子节点顺序
-        for child in node.children.iter().rev() {
-            // 为子节点创建新的上下文，当前节点成为父节点
-            let child_ctx = ctx.for_child(node);
-            self.stack.push((child, child_ctx));
+        if let Some(child) = iter.next() {
+            // 返回子节点，并将其子节点压入栈中
+            let ctx = self.ctx.clone();
+            self.ctx.push(child);
+            self.stack.push(child.children.iter());
+            return Some(NodeRef::new(child, ctx));
         }
 
-        Some(NodeRef::new(node, ctx))
+        // 当前迭代器耗尽，弹出栈顶
+        self.stack.pop();
+        self.ctx.parents.pop();
+        self.next()
     }
 }