keep those traits split for now..

satrs-core/src/pool.rs

@@ -71,6 +71,7 @@ use core::fmt::{Display, Formatter};
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "std")]
 use std::error::Error;
+use delegate::delegate;
 
 type NumBlocks = u16;
 pub type StoreAddr = u64;
@@ -217,7 +218,9 @@ pub trait PoolProviderMemInPlace {
         }
         Ok(self.read(addr)?.len())
     }
+}
 
+pub trait PoolProviderMemInPlaceWithGuards: PoolProviderMemInPlace {
     /// This function behaves like [PoolProvider::read], but consumes the provided address
     /// and returns a RAII conformant guard object.
     ///
@@ -239,52 +242,6 @@ pub trait PoolProviderMemInPlace {
     fn modify_with_guard(&mut self, addr: StoreAddr) -> PoolRwGuard<Self>;
 }
 
-#[cfg(feature = "alloc")]
-mod alloc_mod {
-    use super::{PoolProviderMemInPlace, StaticPoolAddr};
-    use crate::pool::{NumBlocks, StoreAddr, StoreError, StoreIdError};
-    use alloc::vec;
-    use alloc::vec::Vec;
-    use delegate::delegate;
-    #[cfg(feature = "std")]
-    use std::sync::{Arc, RwLock};
-
-    #[cfg(feature = "std")]
-    pub type SharedStaticMemoryPool = Arc<RwLock<StaticMemoryPool>>;
-
-    type PoolSize = usize;
-    const STORE_FREE: PoolSize = PoolSize::MAX;
-    pub const POOL_MAX_SIZE: PoolSize = STORE_FREE - 1;
-
-    /// Configuration structure of the [static memory pool][StaticMemoryPool]
-    ///
-    /// # Parameters
-    ///
-    /// * `cfg`: Vector of tuples which represent a subpool. The first entry in the tuple specifies the
-    ///       number of memory blocks in the subpool, the second entry the size of the blocks
-    #[derive(Clone)]
-    pub struct StaticPoolConfig {
-        cfg: Vec<(NumBlocks, usize)>,
-    }
-
-    impl StaticPoolConfig {
-        pub fn new(cfg: Vec<(NumBlocks, usize)>) -> Self {
-            StaticPoolConfig { cfg }
-        }
-
-        pub fn cfg(&self) -> &Vec<(NumBlocks, usize)> {
-            &self.cfg
-        }
-
-        pub fn sanitize(&mut self) -> usize {
-            self.cfg
-                .retain(|&(bucket_num, size)| bucket_num > 0 && size < POOL_MAX_SIZE);
-            self.cfg
-                .sort_unstable_by(|(_, sz0), (_, sz1)| sz0.partial_cmp(sz1).unwrap());
-            self.cfg.len()
-        }
-    }
-
 pub struct PoolGuard<'a, MemProvider: PoolProviderMemInPlace + ?Sized> {
     pool: &'a mut MemProvider,
     pub addr: StoreAddr,
@@ -349,6 +306,51 @@ mod alloc_mod {
     );
 }
 
+#[cfg(feature = "alloc")]
+mod alloc_mod {
+    use super::{PoolProviderMemInPlace, StaticPoolAddr, PoolProviderMemInPlaceWithGuards, PoolRwGuard, PoolGuard};
+    use crate::pool::{NumBlocks, StoreAddr, StoreError, StoreIdError};
+    use alloc::vec;
+    use alloc::vec::Vec;
+    #[cfg(feature = "std")]
+    use std::sync::{Arc, RwLock};
+
+    #[cfg(feature = "std")]
+    pub type SharedStaticMemoryPool = Arc<RwLock<StaticMemoryPool>>;
+
+    type PoolSize = usize;
+    const STORE_FREE: PoolSize = PoolSize::MAX;
+    pub const POOL_MAX_SIZE: PoolSize = STORE_FREE - 1;
+
+    /// Configuration structure of the [static memory pool][StaticMemoryPool]
+    ///
+    /// # Parameters
+    ///
+    /// * `cfg`: Vector of tuples which represent a subpool. The first entry in the tuple specifies the
+    ///       number of memory blocks in the subpool, the second entry the size of the blocks
+    #[derive(Clone)]
+    pub struct StaticPoolConfig {
+        cfg: Vec<(NumBlocks, usize)>,
+    }
+
+    impl StaticPoolConfig {
+        pub fn new(cfg: Vec<(NumBlocks, usize)>) -> Self {
+            StaticPoolConfig { cfg }
+        }
+
+        pub fn cfg(&self) -> &Vec<(NumBlocks, usize)> {
+            &self.cfg
+        }
+
+        pub fn sanitize(&mut self) -> usize {
+            self.cfg
+                .retain(|&(bucket_num, size)| bucket_num > 0 && size < POOL_MAX_SIZE);
+            self.cfg
+                .sort_unstable_by(|(_, sz0), (_, sz1)| sz0.partial_cmp(sz1).unwrap());
+            self.cfg.len()
+        }
+    }
+
     /// Pool implementation providing sub-pools with fixed size memory blocks.
     ///
     /// This is a simple memory pool implementation which pre-allocates all sub-pools using a given pool
@@ -535,6 +537,9 @@ mod alloc_mod {
             }
             Ok(true)
         }
+    }
+
+    impl PoolProviderMemInPlaceWithGuards for StaticMemoryPool {
         fn modify_with_guard(&mut self, addr: StoreAddr) -> PoolRwGuard<Self> {
             PoolRwGuard::new(self, addr)
         }
@@ -549,7 +554,7 @@ mod alloc_mod {
 mod tests {
     use crate::pool::{
         PoolGuard, PoolProviderMemInPlace, PoolRwGuard, StaticMemoryPool, StaticPoolAddr,
-        StaticPoolConfig, StoreError, StoreIdError, POOL_MAX_SIZE,
+        StaticPoolConfig, StoreError, StoreIdError, POOL_MAX_SIZE, PoolProviderMemInPlaceWithGuards,
     };
     use std::vec;