Merge pull request #23 from DLR-FT/improve-ergonomics

allow cold and warm start for the same function & add set_mode & add tests

Cargo.toml

@@ -29,7 +29,7 @@ strum = ["dep:strum"]
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"], default-features = false, optional = true }
-strum = { version = "0.24", features = ["derive"], default-features = false, optional = true }
+strum = { version = "0.25", features = ["derive"], default-features = false, optional = true }
 a653rs_macros = { version = "0.3.1", path = "macros", optional = true }
 
 [dev-dependencies]

macros/Cargo.toml

@@ -15,12 +15,12 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0", features = [ "full" ] }
+syn = { version = "2.0", features = [ "full" ] }
 static_assertions = "1.1"
 bytesize = "1.2"
-strum = { version = "0.24", features = ["derive"] }
-darling = "0.14"
-itertools = "0.10"
+strum = { version = "0.25", features = ["derive"] }
+darling = "0.20"
+itertools = "0.11"
 convert_case = "0.6"
 humantime = "2.1"
 

macros/src/generate/apex/partition.rs

@@ -7,8 +7,12 @@ impl Context {
         let ctx = self.get_context_ident();
         parse_quote! {
             impl<'a, H> #ctx <'a, H> {
-                pub fn get_partition_status(&self) -> PartitionStatus {
-                    Partition::get_partition_status()
+                pub fn get_partition_status(&self) -> a653rs::prelude::PartitionStatus {
+                    Partition::get_status()
+                }
+
+                pub fn set_partition_mode(&self, mode: a653rs::prelude::OperatingMode) -> Result<(), Error> {
+                    Partition::set_mode(mode)
                 }
             }
         }

macros/src/parse/channel.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 use darling::{FromAttributes, FromMeta};
 use proc_macro2::Ident;
 use quote::format_ident;
-use strum::{Display, EnumDiscriminants, EnumIter, EnumString};
+use strum::{Display, EnumString};
 // use strum::{Display, EnumString, EnumVariantNames, VariantNames};
 use syn::{parse_quote, spanned::Spanned, Attribute, Item, Type};
 
@@ -106,8 +106,7 @@ impl MayFromAttributes for QueuingInProc {
     }
 }
 
-#[derive(Debug, Clone, Display, EnumDiscriminants)]
-#[strum_discriminants(derive(EnumIter))]
+#[derive(Debug, Clone, Display)]
 pub enum Channel {
     SamplingOut(Ident, SamplingOutProc),
     SamplingIn(Ident, SamplingInProc),

macros/src/parse/start.rs

@@ -9,17 +9,8 @@ use crate::parse::util::{no_return_type, remove_attributes, single_function_argu
 
 #[derive(Debug, Copy, Clone, AsRefStr)]
 enum StartType {
-    Warm(Span),
-    Cold(Span),
-}
-
-impl StartType {
-    fn span(&self) -> &Span {
-        match self {
-            StartType::Warm(s) => s,
-            StartType::Cold(s) => s,
-        }
-    }
+    Warm,
+    Cold,
 }
 
 #[derive(Debug, Clone, FromAttributes)]
@@ -29,32 +20,16 @@ struct StartFlags {
     cold: Flag,
 }
 
-impl TryFrom<StartFlags> for Option<StartType> {
-    type Error = syn::Error;
-
-    fn try_from(value: StartFlags) -> Result<Self, Self::Error> {
+impl From<StartFlags> for Vec<StartType> {
+    fn from(value: StartFlags) -> Self {
         let mut flags = vec![];
         if value.warm.is_present() {
-            flags.push(StartType::Warm(value.warm.span()))
+            flags.push(StartType::Warm)
         }
         if value.cold.is_present() {
-            flags.push(StartType::Cold(value.cold.span()))
-        }
-        match flags.len() {
-            0 => Ok(None),
-            1 => Ok(Some(flags[0])),
-            _ => {
-                let mut flags = flags.iter();
-                let mut err = syn::Error::new(
-                    *flags.next().unwrap().span(),
-                    "Multiple start flags attached to same function.",
-                );
-                for (i, flag) in flags.enumerate() {
-                    err.combine(syn::Error::new(*flag.span(), format!("{}th flag", i + 2)))
-                }
-                Err(err)
-            }
+            flags.push(StartType::Cold)
         }
+        flags
     }
 }
 
@@ -97,28 +72,23 @@ impl Start {
             _ => None,
         }) {
             let start = StartFlags::from_attributes(&item.attrs)?;
-            let start: Option<StartType> = start.try_into()?;
-            let start = if let Some(start) = start {
-                start
-            } else {
-                continue;
-            };
-
-            // Remove start attributes from item //
-            remove_attributes("start", &mut item.attrs)?;
-            // Remove start attributes from item //
-
-            let leftover = match start {
-                StartType::Warm(_) => warm.replace(item.clone()),
-                StartType::Cold(_) => cold.replace(item.clone()),
-            };
-            if let Some(leftover) = leftover {
-                let mut err = syn::Error::new(
-                    item.span(),
-                    format!("{}Start already defined", start.as_ref()),
-                );
-                err.combine(syn::Error::new(leftover.span(), "First definition here"));
-                return Err(err);
+            let starts: Vec<StartType> = start.into();
+            for start in starts {
+                // Remove start attributes from item
+                remove_attributes("start", &mut item.attrs)?;
+
+                let leftover = match start {
+                    StartType::Warm => warm.replace(item.clone()),
+                    StartType::Cold => cold.replace(item.clone()),
+                };
+                if let Some(leftover) = leftover {
+                    let mut err = syn::Error::new(
+                        item.span(),
+                        format!("{}Start already defined", start.as_ref()),
+                    );
+                    err.combine(syn::Error::new(leftover.span(), "First definition here"));
+                    return Err(err);
+                }
             }
         }
         Start {
@@ -130,3 +100,25 @@ impl Start {
         .verify_fn_form()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use syn::parse_quote;
+
+    use crate::parse::start::*;
+
+    #[test]
+    fn test_start_flags_from_attributes_both_present() {
+        use darling::FromAttributes;
+
+        // Mock attributes
+        let warm_attr = parse_quote!(#[start(warm)]);
+        let cold_attr = parse_quote!(#[start(cold)]);
+
+        // Test case: Both warm and cold attributes are present
+        let flags: StartFlags = StartFlags::from_attributes(&[warm_attr, cold_attr])
+            .expect("Failed to parse StartFlags");
+        assert!(flags.warm.is_present());
+        assert!(flags.cold.is_present());
+    }
+}

macros/src/parse/util.rs

@@ -8,7 +8,7 @@ use syn::{parse_quote, Attribute, FnArg, Ident, ReturnType, Signature};
 pub fn contains_attribute(attr: &str, attrs: &[Attribute]) -> bool {
     attrs
         .iter()
-        .flat_map(|a| a.parse_meta())
+        .map(|a| a.meta.clone())
         .flat_map(|m| m.path().get_ident().cloned())
         .any(|i| i.to_string().eq(attr))
 }
@@ -46,18 +46,18 @@ pub fn single_function_argument(ty: &syn::Type, sig: &Signature) -> syn::Result<
             return Err(syn::Error::new_spanned(t.ty.clone(), msg));
         }
     } else {
-        return Err(syn::Error::new(sig.paren_token.span, msg));
+        return Err(syn::Error::new(sig.paren_token.span.join(), msg));
     }
     if sig.inputs.len() > 1 {
-        return Err(syn::Error::new(sig.paren_token.span, msg));
+        return Err(syn::Error::new(sig.paren_token.span.join(), msg));
     }
     Ok(())
 }
 
 pub fn remove_attributes(attr: &str, attrs: &mut Vec<Attribute>) -> syn::Result<()> {
     let attr = syn::parse_str::<Ident>(attr)?;
     attrs.retain(|a| {
-        a.path
+        a.path()
             .segments
             .first()
             .map_or_else(|| true, |p| !p.ident.eq(&attr))
@@ -106,3 +106,54 @@ impl FromMeta for WrappedDuration {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::parse::util::*;
+
+    #[test]
+    fn test_contains_attribute() {
+        use syn::{parse_quote, Attribute};
+
+        let attr1: Attribute = parse_quote!(#[sample_attr]);
+        let attr2: Attribute = parse_quote!(#[another_attr]);
+
+        let attrs = vec![attr1, attr2];
+
+        assert!(contains_attribute("sample_attr", &attrs));
+        assert!(contains_attribute("another_attr", &attrs));
+        assert!(!contains_attribute("non_existent_attr", &attrs));
+    }
+
+    #[test]
+    fn test_no_return_type() {
+        use syn::{parse_quote, ReturnType};
+
+        let valid_return: ReturnType = parse_quote!(-> ());
+
+        // Function with valid return type
+        assert!(no_return_type("TestFn", &valid_return).is_ok());
+
+        // Function with invalid return type (usize)
+        let invalid_return: ReturnType = parse_quote!(-> usize);
+        assert!(no_return_type("TestFn", &invalid_return).is_err());
+    }
+
+    #[test]
+    fn test_remove_attributes() {
+        use syn::{parse_quote, Attribute};
+
+        let attr1: Attribute = parse_quote!(#[sample_attr]);
+        let attr2: Attribute = parse_quote!(#[another_attr]);
+
+        let mut attrs = vec![attr1, attr2.clone()];
+
+        // Removing an attribute that exists
+        remove_attributes("sample_attr", &mut attrs).unwrap();
+        assert_eq!(attrs, vec![attr2.clone()]);
+
+        // Removing an attribute that does not exist
+        remove_attributes("non_existent_attr", &mut attrs).unwrap();
+        assert_eq!(attrs, vec![attr2]);
+    }
+}

src/apex/blackboard.rs

@@ -117,7 +117,7 @@ pub mod abstraction {
     use core::sync::atomic::AtomicPtr;
 
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexBlackboardP1, BlackboardId, BlackboardStatus};
+    pub use super::basic::{BlackboardId, BlackboardStatus};
     use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;

src/apex/buffer.rs

@@ -103,7 +103,7 @@ pub mod abstraction {
     use core::sync::atomic::AtomicPtr;
 
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexBufferP1, BufferId, BufferStatus};
+    pub use super::basic::{BufferId, BufferStatus};
     use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;

src/apex/error.rs

@@ -118,8 +118,7 @@ pub mod basic {
 pub mod abstraction {
     // Reexport important basic-types for downstream-user
     pub use super::basic::{
-        ApexErrorP1, ApexErrorP4, ErrorCode, ErrorHandlerConcurrencyControl, ErrorStatus,
-        MAX_ERROR_MESSAGE_SIZE,
+        ErrorCode, ErrorHandlerConcurrencyControl, ErrorStatus, MAX_ERROR_MESSAGE_SIZE,
     };
     use crate::bindings::*;
     use crate::hidden::Key;

src/apex/event.rs

@@ -96,7 +96,8 @@ pub mod abstraction {
     use core::sync::atomic::AtomicPtr;
 
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexEventP1, EventId, EventState, EventStatus};
+    pub use super::basic::{EventId, EventState, EventStatus};
+    use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;
 

src/apex/memory_block.rs

@@ -45,9 +45,9 @@ pub mod abstraction {
     use core::marker::PhantomData;
     use core::slice::from_raw_parts_mut;
 
-    use super::basic::ApexMemoryBlockStatus;
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexMemoryBlockP2, MemoryBlockMode, MemoryBlockName, MemoryBlockSize};
+    pub use super::basic::{MemoryBlockMode, MemoryBlockName, MemoryBlockSize};
+    use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;
 

src/apex/mutex.rs

@@ -104,7 +104,7 @@ pub mod abstraction {
     use core::sync::atomic::AtomicPtr;
 
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexMutexP1, LockCount, MutexId, MutexName, MutexStatus};
+    pub use super::basic::{LockCount, MutexId, MutexName, MutexStatus};
     use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;

src/apex/partition.rs

@@ -92,7 +92,7 @@ pub mod abstraction {
     use core::sync::atomic::AtomicPtr;
 
     // Reexport important basic-types for downstream-user
-    pub use super::basic::{ApexPartitionP4, NumCores, OperatingMode, PartitionId, StartCondition};
+    pub use super::basic::{NumCores, OperatingMode, PartitionId, StartCondition};
     use crate::bindings::*;
     use crate::hidden::Key;
     use crate::prelude::*;
@@ -132,7 +132,15 @@ pub mod abstraction {
     where
         A: ApexPartitionP4,
     {
-        fn get_partition_status() -> PartitionStatus;
+        fn get_status() -> PartitionStatus;
+
+        /// change partition mode  
+        /// DO NOT CALL THIS WITH [OperatingMode::Normal] FROM THE START FUNCTION.
+        ///
+        /// # Errors
+        /// - [Error::NoAction]: `mode` is [OperatingMode::Normal] and partition mode is [OperatingMode::Normal]
+        /// - [Error::InvalidMode]: `mode` is [OperatingMode::WarmStart] and partition mode is [OperatingMode::ColdStart]
+        fn set_mode(mode: OperatingMode) -> Result<(), Error>;
 
         fn run(self) -> !;
     }
@@ -142,15 +150,19 @@ pub mod abstraction {
         P: Partition<A>,
         A: ApexPartitionP4,
     {
-        fn get_partition_status() -> PartitionStatus {
+        fn get_status() -> PartitionStatus {
             A::get_partition_status::<Key>().into()
         }
 
+        fn set_mode(mode: OperatingMode) -> Result<(), Error> {
+            Ok(A::set_partition_mode::<Key>(mode)?)
+        }
+
         fn run(self) -> ! {
             let mut ctx = StartContext {
                 _a: Default::default(),
             };
-            let status = Self::get_partition_status();
+            let status = Self::get_status();
 
             match status.operating_mode {
                 OperatingMode::ColdStart => self.cold_start(&mut ctx),

src/apex/process.rs

@@ -170,8 +170,7 @@ pub mod abstraction {
 
     // Reexport important basic-types for downstream-user
     pub use super::basic::{
-        ApexProcessP1, ApexProcessP4, Deadline, LockLevel, Priority, ProcessId, ProcessIndex,
-        ProcessName, StackSize,
+        Deadline, LockLevel, Priority, ProcessId, ProcessIndex, ProcessName, StackSize,
     };
     use crate::bindings::*;
     use crate::hidden::Key;