refactor: 重构 NodeClock、NodeInterruptController 和 NodePci 的构造函数，添加 try_from_raw 方法以增强错误处理

Author: ZR233

fdt-edit/src/node/clock.rs

@@ -49,7 +49,11 @@ impl NodeTrait for NodeClock {
 }
 
 impl NodeClock {
-    pub fn new(raw: RawNode) -> Self {
+    pub fn try_from_raw(raw: RawNode) -> Result<Self, RawNode> {
+        if !raw.properties.iter().any(|p| p.name() == "#clock-cells") {
+            return Err(raw);
+        }
+
         let clock_output_names = Self::get_string_list(&raw, "clock-output-names");
         let clock_names = Self::get_string_list(&raw, "clock-names");
         let clock_cells = Self::get_u32(&raw, "#clock-cells").unwrap_or(0);
@@ -68,13 +72,13 @@ impl NodeClock {
             ClockType::Normal
         };
 
-        NodeClock {
+        Ok(NodeClock {
             clock_output_names,
             clock_names,
             clock_cells,
             kind,
             raw,
-        }
+        })
     }
 
     /// 获取字符串列表属性

fdt-edit/src/node/interrupt_controller.rs

@@ -22,6 +22,13 @@ impl NodeTrait for NodeInterruptController {
 }
 
 impl NodeInterruptController {
+    pub fn try_from_raw(raw: RawNode) -> Result<Self, RawNode> {
+        if !is_interrupt_controller_node(&raw) {
+            return Err(raw);
+        }
+        Ok(NodeInterruptController(raw))
+    }
+
     pub fn new(raw: RawNode) -> Self {
         NodeInterruptController(raw)
     }

fdt-edit/src/node/mod.rs

@@ -54,51 +54,31 @@ impl Node {
         Self::Raw(RawNode::new(""))
     }
 
-    // fn new(raw: RawNode) -> Self {
-    //     let name = raw.name.as_str();
-
-    //     // 根据节点名称或属性判断类型
-    //     if name == "chosen" {
-    //         return Self::Chosen(NodeChosen(raw));
-    //     }
-
-    //     if name.starts_with("memory") {
-    //         return Self::Memory(NodeMemory(raw));
-    //     }
-
-    //     // 检查是否是中断控制器
-    //     if is_interrupt_controller_node(&raw) {
-    //         return Self::InterruptController(NodeInterruptController::new(raw));
-    //     }
-
-    //     // 检查是否是时钟提供者
-    //     if raw.properties.iter().any(|p| p.name() == "#clock-cells") {
-    //         return Self::Clock(NodeClock::new(raw));
-    //     }
-
-    //     // 检查 device_type 属性
-    //     let mut node = Self::Raw(raw);
-    //     if let Some(t) = node.find_property("device_type")
-    //         && let PropertyKind::Str(dt) = &t.kind
-    //         && dt.as_str() == "pci"
-    //     {
-    //         node = Self::Pci(NodePci(node.to_raw()));
-    //     }
-    //     node
-    // }
-
     pub fn new_raw(name: &str) -> Self {
         Self::Raw(RawNode::new(name))
     }
 
     pub fn from_raw<'a>(val: fdt_raw::Node<'a>) -> Self {
         match val {
             fdt_raw::Node::General(node_base) => {
+                let mut raw = RawNode::from(node_base);
+
+                raw = match NodePci::try_from_raw(raw) {
+                    Ok(v) => return Self::Pci(v),
+                    Err(r) => r,
+                };
+
+                raw = match NodeClock::try_from_raw(raw) {
+                    Ok(v) => return Self::Clock(v),
+                    Err(r) => r,
+                };
 
-                
+                raw = match NodeInterruptController::try_from_raw(raw) {
+                    Ok(v) => return Self::InterruptController(v),
+                    Err(r) => r,
+                };
 
-                let raw_node = RawNode::from(node_base);
-                Self::Raw(raw_node)
+                Self::Raw(raw)
             }
             fdt_raw::Node::Chosen(chosen) => {
                 let mut new_one = NodeChosen::new();

fdt-edit/src/node/pci.rs

@@ -58,6 +58,14 @@ impl NodeTrait for NodePci {
 }
 
 impl NodePci {
+    pub fn try_from_raw(raw: RawNode) -> Result<Self, RawNode> {
+        if raw.device_type() == Some("pci") {
+            Ok(NodePci(raw))
+        } else {
+            Err(raw)
+        }
+    }
+
     pub fn new(name: &str) -> Self {
         NodePci(RawNode::new(name))
     }