refactor: 重构上下文管理，移除当前路径字段并添加路径计算方法

ZR233 · ZR233 · commit 616ae44c80c9 · 2025-12-07T10:08:43.000+08:00
diff --git a/fdt-edit/src/ctx.rs b/fdt-edit/src/ctx.rs
@@ -1,4 +1,8 @@
-use alloc::{collections::BTreeMap, string::String, vec::Vec};
+use alloc::{
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec::Vec,
+};
 use fdt_raw::{Phandle, Status};
 
 use crate::{Node, RangesEntry};
@@ -13,8 +17,7 @@ pub struct Context<'a> {
     /// 父节点引用栈（从根节点到当前节点的父节点）
     /// 栈底是根节点，栈顶是当前节点的直接父节点
     pub parents: Vec<&'a Node>,
-    /// 当前节点的完整路径
-    pub current_path: String,
+
     /// phandle 到节点引用的映射
     /// 用于通过 phandle 快速查找节点（如中断父节点）
     pub phandle_map: BTreeMap<Phandle, &'a Node>,
@@ -26,6 +29,14 @@ impl<'a> Context<'a> {
         Self::default()
     }
 
+    pub fn current_path(&self) -> String {
+        self.parents
+            .iter()
+            .map(|n| n.name())
+            .collect::<Vec<_>>()
+            .join("/")
+    }
+
     /// 创建用于根节点的上下文
     pub fn for_root() -> Self {
         Self::default()
@@ -112,22 +123,8 @@ impl<'a> Context<'a> {
         parent.ranges(grandparent_address_cells)
     }
 
-    /// 添加路径段
-    pub fn path_add(&mut self, segment: &str) {
-        if !self.current_path.ends_with('/') {
-            self.current_path.push('/');
-        }
-        self.current_path.push_str(segment);
-    }
-
     /// 压入父节点，进入子节点前调用
     pub fn push_parent(&mut self, parent: &'a Node) {
-        // 更新路径
-        if !self.current_path.ends_with('/') {
-            self.current_path.push('/');
-        }
-        self.current_path.push_str(parent.name());
-
         if let Some(ph) = parent.phandle() {
             self.phandle_map.insert(ph, parent);
         }
@@ -140,14 +137,6 @@ impl<'a> Context<'a> {
     pub fn pop_parent(&mut self) -> Option<&'a Node> {
         let node = self.parents.pop()?;
 
-        // 更新路径：移除最后一个路径段
-        if let Some(last_slash) = self.current_path.rfind('/') {
-            self.current_path.truncate(last_slash);
-            if self.current_path.is_empty() {
-                self.current_path.push('/');
-            }
-        }
-
         Some(node)
     }
 
@@ -156,7 +145,6 @@ impl<'a> Context<'a> {
     pub fn for_child(&self, current_node: &'a Node) -> Self {
         let mut child_ctx = Self {
             parents: self.parents.clone(),
-            current_path: self.current_path.clone(),
             phandle_map: self.phandle_map.clone(),
         };
         child_ctx.push_parent(current_node);
diff --git a/fdt-edit/src/fdt.rs b/fdt-edit/src/fdt.rs
@@ -138,27 +138,18 @@ impl Fdt {
             .unwrap_or_else(|| path.to_string());
 
         NodeIter::new(self.root()).filter_map(move |node_ref| {
-            let want = path.split("/");
-            let got = node_ref.ctx.current_path.split("/");
-            let last_idx = core::cmp::min(want.clone().count(), got.clone().count());
-            for (w, g) in want.zip(got).take(last_idx - 1) {
-                if w != g {
-                    return None;
-                }
-            }
-            let want_name = path.rsplit('/').next().unwrap_or("");
-            let got_name = node_ref.node.name();
-            if !got_name.starts_with(want_name) {
-                return None;
+            if node_ref.path_eq_fuzzy(&path) {
+                Some(node_ref)
+            } else {
+                None
             }
-            Some(node_ref)
         })
     }
 
     pub fn get_by_path<'a>(&'a self, path: &str) -> Option<NodeRef<'a>> {
         let path = self.normalize_path(path)?;
         NodeIter::new(self.root()).find_map(move |node_ref| {
-            if node_ref.ctx.current_path == path {
+            if node_ref.path_eq(&path) {
                 Some(node_ref)
             } else {
                 None
@@ -169,7 +160,7 @@ impl Fdt {
     pub fn get_by_path_mut<'a>(&'a mut self, path: &str) -> Option<NodeMut<'a>> {
         let path = self.normalize_path(path)?;
         NodeIterMut::new(self.root_mut()).find_map(move |node_mut| {
-            if node_mut.ctx.current_path == path {
+            if node_mut.path_eq(&path) {
                 Some(node_mut)
             } else {
                 None
@@ -309,7 +300,7 @@ impl Fdt {
 
             // 通过 phandle 找到节点，然后构建路径
             if let Some(node) = self.find_by_phandle(ph) {
-                return Ok(node.ctx.current_path.clone());
+                return Ok(node.path());
             }
         }
 
diff --git a/fdt-edit/src/node/iter.rs b/fdt-edit/src/node/iter.rs
@@ -1,11 +1,12 @@
 use core::{
     fmt::Debug,
-    ops::{Deref, DerefMut}, slice::IterMut,
+    ops::{Deref, DerefMut},
+    slice::IterMut,
 };
 
-use alloc::vec::Vec;
+use alloc::{string::String, vec::Vec};
 
-use crate::{Context, Node, Property};
+use crate::{Context, Node, Property, ctx};
 
 #[derive(Clone, Debug)]
 pub enum NodeRef<'a> {
@@ -16,6 +17,25 @@ impl<'a> NodeRef<'a> {
     pub fn new(node: &'a Node, ctx: Context<'a>) -> Self {
         Self::Gerneric(NodeRefGen { node, ctx })
     }
+
+    fn op(&'a self) -> RefOp<'a> {
+        RefOp {
+            ctx: &self.ctx,
+            node: self.node,
+        }
+    }
+
+    pub fn path(&self) -> String {
+        self.op().path()
+    }
+
+    pub fn path_eq(&self, path: &str) -> bool {
+        self.op().ref_path_eq(path)
+    }
+
+    pub fn path_eq_fuzzy(&self, path: &str) -> bool {
+        self.op().ref_path_eq_fuzzy(path)
+    }
 }
 
 #[derive(Clone)]
@@ -67,6 +87,25 @@ impl<'a> NodeMut<'a> {
     pub fn new(node: &'a mut Node, ctx: Context<'a>) -> Self {
         Self::Gerneric(NodeMutGen { node, ctx })
     }
+
+    fn op(&'a self) -> RefOp<'a> {
+        RefOp {
+            ctx: &self.ctx,
+            node: self.node,
+        }
+    }
+
+    pub fn path(&self) -> String {
+        self.op().path()
+    }
+
+    pub fn path_eq(&self, path: &str) -> bool {
+        self.op().ref_path_eq(path)
+    }
+
+    pub fn path_eq_fuzzy(&self, path: &str) -> bool {
+        self.op().ref_path_eq_fuzzy(path)
+    }
 }
 
 impl<'a> Deref for NodeMut<'a> {
@@ -143,3 +182,60 @@ impl Debug for NodeRefGen<'_> {
         write!(f, "NodeRefGen {{ name: {} }}", self.node.name())
     }
 }
+
+struct RefOp<'a> {
+    ctx: &'a Context<'a>,
+    node: &'a Node,
+}
+
+impl<'a> RefOp<'a> {
+    fn path(&self) -> String {
+        self.ctx.current_path() + "/" + self.node.name()
+    }
+
+    fn ref_path_eq(&self, path: &str) -> bool {
+        self.path() == path
+    }
+
+    fn ref_path_eq_fuzzy(&self, path: &str) -> bool {
+        let mut want = path.trim_matches('/').split("/");
+        let got_path = self.path();
+        let mut got = got_path.trim_matches('/').split("/");
+        let got_count = got.clone().count();
+        let mut current = 0;
+
+        loop {
+            let w = want.next();
+            let g = got.next();
+            let is_last = current + 1 == got_count;
+
+            match (w, g) {
+                (Some(w), Some(g)) => {
+                    if w != g && !is_last {
+                        return false;
+                    }
+
+                    let name = g.split('@').next().unwrap_or(g);
+                    let addr = g.split('@').nth(1);
+
+                    let want_name = w.split('@').next().unwrap_or(w);
+                    let want_addr = w.split('@').nth(1);
+
+                    let res = match (addr, want_addr) {
+                        (Some(a), Some(wa)) => name == want_name && a == wa,
+                        (Some(_), None) => name == want_name,
+                        (None, Some(_)) => false,
+                        (None, None) => name == want_name,
+                    };
+                    if !res {
+                        return false;
+                    }
+                }
+                (None, _) => break,
+                _ => return false,
+            }
+            current += 1;
+        }
+        true
+    }
+}
diff --git a/fdt-edit/tests/find2.rs b/fdt-edit/tests/find2.rs
@@ -25,6 +25,10 @@ mod tests {
         for n in node {
             println!("Found node {n:#?}");
         }
+
+        let count = fdt.find_by_path("/virtio_mmio").count();
+        println!("Total found nodes: {}", count);
+        assert_eq!(count, 32);
     }
 
     #[test]
@@ -35,6 +39,8 @@ mod tests {
 
         for node in fdt.all_nodes() {
             println!("Node: {:#?}", node);
+            println!("  {}", node.path());
+            println!("-------------------------");
         }
 
         let count = fdt.all_nodes().count();

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,10 @@ mod tests {`
`25`	`25`	`for n in node {`
`26`	`26`	`println!("Found node {n:#?}");`
`27`	`27`	`}`
	`28`	`+`
	`29`	`+ let count = fdt.find_by_path("/virtio_mmio").count();`
	`30`	`+ println!("Total found nodes: {}", count);`
	`31`	`+ assert_eq!(count, 32);`
`28`	`32`	`}`
`29`	`33`
`30`	`34`	`#[test]`
`@@ -35,6 +39,8 @@ mod tests {`
`35`	`39`
`36`	`40`	`for node in fdt.all_nodes() {`
`37`	`41`	`println!("Node: {:#?}", node);`
	`42`	`+ println!(" {}", node.path());`
	`43`	`+ println!("-------------------------");`
`38`	`44`	`}`
`39`	`45`
`40`	`46`	`let count = fdt.all_nodes().count();`