refactor: validate Fdt on construction

This makes the APIs more ergonomic, as most of the methods that used to
return `Result<T, E>`, return `T` now instead, making it much easier to
work with, especially in case of iterators.

This obviously causes the constructor to run in linear time, which
shouldn't be a huge problem considering that any sensible use of the
parser will require linear-time traversal time anyway. In case this
would be a problem, however, a separate constructor that skips the
validation (and causes the traverse methods to panic instead) is added.

This also allows us to unify some error handling between in-memory and
internal representation APIs, bringing us closer to unifying these two APIs
under a common trait, and supporting the "standard nodes & properties"
for the internal representation variant.

Author: m4tx

src/error.rs

@@ -8,16 +8,14 @@
 
 //! Error types for the `dtoolkit` crate.
 
-use core::fmt::{self, Display, Formatter};
-
 use thiserror::Error;
 
-/// An error that can occur when parsing or accessing a device tree.
-#[derive(Clone, Debug, Eq, Error, PartialEq)]
-pub enum FdtError {
-    /// There was an error parsing the device tree.
-    #[error("{0}")]
-    Parse(#[from] FdtParseError),
+/// An error that can occur when accessing a standard node or property.
+#[derive(Copy, Clone, Debug, Eq, Error, PartialEq)]
+pub enum StandardError {
+    /// There was an error when converting the property value.
+    #[error("error occurred when converting the property value: {0}")]
+    PropertyConversion(#[from] PropertyError),
     /// The `status` property of a node had an invalid value.
     #[error("Invalid status value")]
     InvalidStatus,
@@ -53,6 +51,7 @@ pub enum FdtError {
 /// An error that can occur when parsing a device tree.
 #[derive(Clone, Debug, Eq, Error, PartialEq)]
 #[non_exhaustive]
+#[error("{kind} at offset {offset}")]
 pub struct FdtParseError {
     offset: usize,
     /// The type of the error that has occurred.
@@ -65,11 +64,6 @@ impl FdtParseError {
     }
 }
 
-impl Display for FdtParseError {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{} at offset {}", self.kind, self.offset)
-    }
-}
 /// The kind of an error that can occur when parsing a device tree.
 #[derive(Clone, Debug, Eq, Error, PartialEq)]
 #[non_exhaustive]
@@ -103,3 +97,15 @@ pub enum FdtErrorKind {
     #[error("Memory reservation block has an entry that is unaligned or has invalid size")]
     MemReserveInvalid,
 }
+
+/// An error that can occur when parsing a property.
+#[derive(Debug, Clone, Copy, Error, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum PropertyError {
+    /// The property's value has an invalid length for the requested conversion.
+    #[error("property has an invalid length")]
+    InvalidLength,
+    /// The property's value is not a valid string.
+    #[error("property is not a valid string")]
+    InvalidString,
+}