now it compiles for no_std

satrs-core/src/params.rs

@@ -43,21 +43,23 @@
 //! This includes the [ParamsHeapless] enumeration for contained values which do not require heap
 //! allocation, and the [Params] which enumerates [ParamsHeapless] and some additional types which
 //! require [alloc] support but allow for more flexbility.
+#[cfg(feature = "alloc")]
 use crate::pool::StoreAddr;
 #[cfg(feature = "alloc")]
-use alloc::string::String;
-#[cfg(feature = "alloc")]
-use alloc::string::ToString;
+use alloc::string::{String, ToString};
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
-pub use spacepackets::ecss::ToBeBytes;
 use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8, EcssEnumeration};
 use spacepackets::ByteConversionError;
 use spacepackets::SizeMissmatch;
 
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+pub use spacepackets::ecss::ToBeBytes;
+
 /// Generic trait which is used for objects which can be converted into a raw network (big) endian
 /// byte format.
 pub trait WritableToBeBytes {
@@ -481,13 +483,6 @@ impl WritableToBeBytes for EcssEnumParams {
 pub enum ParamsHeapless {
     Raw(ParamsRaw),
     EcssEnum(EcssEnumParams),
-    Store(StoreAddr),
-}
-
-impl From<StoreAddr> for ParamsHeapless {
-    fn from(x: StoreAddr) -> Self {
-        Self::Store(x)
-    }
 }
 
 macro_rules! from_conversions_for_raw {
@@ -534,46 +529,56 @@ from_conversions_for_raw!(
     (f64, Self::F64),
 );
 
-/// Generic enumeration for additional parameters, including parameters which rely on heap
-/// allocations.
 #[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-#[derive(Debug, Clone)]
-pub enum Params {
-    Heapless(ParamsHeapless),
-    Vec(Vec<u8>),
-    String(String),
-}
-
-impl From<ParamsHeapless> for Params {
-    fn from(x: ParamsHeapless) -> Self {
-        Self::Heapless(x)
+mod alloc_mod {
+    use super::*;
+    /// Generic enumeration for additional parameters, including parameters which rely on heap
+    /// allocations.
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    #[derive(Debug, Clone)]
+    pub enum Params {
+        Heapless(ParamsHeapless),
+        Store(StoreAddr),
+        Vec(Vec<u8>),
+        String(String),
     }
-}
 
-impl From<Vec<u8>> for Params {
-    fn from(val: Vec<u8>) -> Self {
-        Self::Vec(val)
+    impl From<StoreAddr> for Params {
+        fn from(x: StoreAddr) -> Self {
+            Self::Store(x)
+        }
     }
-}
 
-/// Converts a byte slice into the [Params::Vec] variant
-impl From<&[u8]> for Params {
-    fn from(val: &[u8]) -> Self {
-        Self::Vec(val.to_vec())
+    impl From<ParamsHeapless> for Params {
+        fn from(x: ParamsHeapless) -> Self {
+            Self::Heapless(x)
+        }
     }
-}
 
-impl From<String> for Params {
-    fn from(val: String) -> Self {
-        Self::String(val)
+    impl From<Vec<u8>> for Params {
+        fn from(val: Vec<u8>) -> Self {
+            Self::Vec(val)
+        }
     }
-}
 
-/// Converts a string slice into the [Params::String] variant
-impl From<&str> for Params {
-    fn from(val: &str) -> Self {
-        Self::String(val.to_string())
+    /// Converts a byte slice into the [Params::Vec] variant
+    impl From<&[u8]> for Params {
+        fn from(val: &[u8]) -> Self {
+            Self::Vec(val.to_vec())
+        }
+    }
+
+    impl From<String> for Params {
+        fn from(val: String) -> Self {
+            Self::String(val)
+        }
+    }
+
+    /// Converts a string slice into the [Params::String] variant
+    impl From<&str> for Params {
+        fn from(val: &str) -> Self {
+            Self::String(val.to_string())
+        }
     }
 }