Allow mapping interrupt in ActiveVector.

Author: reitermarkus

src/peripheral/scb.rs

@@ -374,18 +374,18 @@ impl TryFrom<i8> for Exception {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "std", derive(PartialOrd, Hash))]
-pub enum ActiveVector {
+pub enum ActiveVector<INT = u16> {
     /// Thread mode
     ThreadMode,
 
     /// Processor core exception (internal interrupts)
     Exception(Exception),
 
     /// Device specific exception (external interrupts)
-    Interrupt {
+    Interrupt(
         /// Interrupt number. This number is always in range `[0, 495]` (9-bit integer - 16)
-        irqn: u16,
-    },
+        INT,
+    ),
 }
 
 impl ActiveVector {
@@ -398,10 +398,35 @@ impl ActiveVector {
         match isrn {
             0 => Self::ThreadMode,
             2..=15 => Self::Exception(Exception::new_unchecked(isrn as i8 - 16)),
-            16..=511 => Self::Interrupt { irqn: isrn - 16 },
+            16..=511 => Self::Interrupt(isrn - 16),
             _ => core::hint::unreachable_unchecked(),
         }
     }
+
+    /// Map the interrupt number to a different type.
+    ///
+    /// ### Example
+    ///
+    /// ```
+    /// #[exception]
+    /// unsafe fn DefaultHandler(vect_active: ActiveVector) -> ! {
+    ///   let interrupt = vect_active.map_interrupt(|i| {
+    ///     core::mem::transmute::<_, stm32l4xx_hal::pac::interrupt>(i)
+    ///   });
+    ///
+    ///   log::error!("Unexpected interrupt: ({:?})", interrupt);
+    ///
+    ///   loop {}
+    /// }
+    /// ```
+    #[inline]
+    pub fn map_interrupt<INT>(&self, f: impl FnOnce(u16) -> INT) -> ActiveVector<INT> {
+        match self {
+            Self::ThreadMode => ActiveVector::ThreadMode,
+            Self::Exception(ex) => ActiveVector::Exception(*ex),
+            Self::Interrupt(irqn) => ActiveVector::Interrupt(f(*irqn)),
+        }
+    }
 }
 
 impl TryFrom<u16> for ActiveVector {
@@ -413,7 +438,7 @@ impl TryFrom<u16> for ActiveVector {
         Ok(match isrn {
             0 => Self::ThreadMode,
             2..=15 => Self::Exception(Exception::try_from(isrn as i8 - 16).or(Err(isrn))?),
-            16..=511 => Self::Interrupt { irqn: isrn - 16 },
+            16..=511 => Self::Interrupt(isrn - 16),
             _ => return Err(isrn),
         })
     }