builder for interrupt

Author: burrbull

svd-parser/src/interrupt.rs

@@ -6,16 +6,17 @@ impl Parse for Interrupt {
     type Error = SVDErrorAt;
     type Config = Config;
 
-    fn parse(tree: &Node, _config: &Self::Config) -> Result<Self, Self::Error> {
+    fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
         if !tree.has_tag_name("interrupt") {
             return Err(SVDError::NotExpectedTag("interrupt".to_string()).at(tree.id()));
         }
         let name = tree.get_child_text("name")?;
 
-        Ok(Interrupt {
-            name,
-            description: tree.get_child_text_opt("description")?,
-            value: tree.get_child_u32("value")?,
-        })
+        Interrupt::builder()
+            .name(name)
+            .description(tree.get_child_text_opt("description")?)
+            .value(tree.get_child_u32("value")?)
+            .build(config.validate_level)
+            .map_err(|e| SVDError::from(e).at(tree.id()))
     }
 }

svd-rs/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - Don't clone when serialize
 - Add optional entries to `Cpu`
-- `AddressBlock` now uses builder
+- `AddressBlock` & `Interrupt` now use builders
 - Add `dim_name` and `dim_array_index` to `DimElement`
 - Add `alternate_peripheral`, `prepend_to_name`, `append_to_name`,
   `header_struct_name` to `PeripheralInfo`, `alternate_cluster` to `ClusterInfo`

svd-rs/src/interrupt.rs

@@ -1,6 +1,9 @@
+use super::{BuildError, SvdError, ValidateLevel};
+
 /// Describes an interrupt in the device
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
 pub struct Interrupt {
     /// The string represents the interrupt name
     pub name: String,
@@ -15,3 +18,91 @@ pub struct Interrupt {
     /// Represents the enumeration index value associated to the interrupt
     pub value: u32,
 }
+
+/// Builder for [`Interrupt`]
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct InterruptBuilder {
+    name: Option<String>,
+    description: Option<String>,
+    value: Option<u32>,
+}
+
+impl From<Interrupt> for InterruptBuilder {
+    fn from(d: Interrupt) -> Self {
+        Self {
+            name: Some(d.name),
+            description: d.description,
+            value: Some(d.value),
+        }
+    }
+}
+
+impl InterruptBuilder {
+    /// Set the name of the interrupt
+    pub fn name(mut self, value: String) -> Self {
+        self.name = Some(value);
+        self
+    }
+    /// Set the description of the interrupt
+    pub fn description(mut self, value: Option<String>) -> Self {
+        self.description = value;
+        self
+    }
+    /// Set the value of the interrupt
+    pub fn value(mut self, value: u32) -> Self {
+        self.value = Some(value);
+        self
+    }
+    /// Validate and build a [`Interrupt`].
+    pub fn build(self, lvl: ValidateLevel) -> Result<Interrupt, SvdError> {
+        let mut de = Interrupt {
+            name: self
+                .name
+                .ok_or_else(|| BuildError::Uninitialized("name".to_string()))?,
+            description: self.description,
+            value: self
+                .value
+                .ok_or_else(|| BuildError::Uninitialized("value".to_string()))?,
+        };
+        if !lvl.is_disabled() {
+            de.validate(lvl)?;
+        }
+        Ok(de)
+    }
+}
+
+impl Interrupt {
+    /// Make a builder for [`Interrupt`]
+    pub fn builder() -> InterruptBuilder {
+        InterruptBuilder::default()
+    }
+    /// Modify an existing [`Interrupt`] based on a [builder](InterruptBuilder).
+    pub fn modify_from(
+        &mut self,
+        builder: InterruptBuilder,
+        lvl: ValidateLevel,
+    ) -> Result<(), SvdError> {
+        if let Some(name) = builder.name {
+            self.name = name;
+        }
+        if builder.description.is_some() {
+            self.description = builder.description;
+        }
+        if let Some(value) = builder.value {
+            self.value = value;
+        }
+        if !lvl.is_disabled() {
+            self.validate(lvl)
+        } else {
+            Ok(())
+        }
+    }
+    /// Validate the [`Interrupt`].
+    ///
+    /// # Notes
+    ///
+    /// This doesn't do anything.
+    pub fn validate(&mut self, _lvl: ValidateLevel) -> Result<(), SvdError> {
+        Ok(())
+    }
+}

tests/src/interrupt.rs

@@ -1,14 +1,15 @@
 use super::run_test;
-use crate::svd::Interrupt;
+use crate::svd::{Interrupt, ValidateLevel};
 
 #[test]
 fn decode_encode() {
     let tests = vec![(
-        Interrupt {
-            name: String::from("test"),
-            description: Some(String::from("description")),
-            value: 14,
-        },
+        Interrupt::builder()
+            .name("test".to_string())
+            .description(Some("description".to_string()))
+            .value(14)
+            .build(ValidateLevel::Strict)
+            .unwrap(),
         "
             <interrupt>
                 <name>test</name>