documentation fixes

satrs-core/src/pool.rs

@@ -27,7 +27,7 @@
 //!     assert_eq!(read_bytes, 4);
 //!     assert_eq!(read_buf[0], 42);
 //!     // Modify the stored data
-//!     let res = local_pool.update(&addr, |buf| {
+//!     let res = local_pool.modify(&addr, |buf| {
 //!         buf[0] = 12;
 //!     });
 //!     assert!(res.is_ok());
@@ -211,27 +211,32 @@ pub trait PoolProvider {
     /// be used to access the data stored in the pool
     fn add(&mut self, data: &[u8]) -> Result<StoreAddr, StoreError>;
 
-    /// The provider should attempt to reserve a free memory block with the appropriate size and
+    /// The provider should attempt to reserve a free memory block with the appropriate size first.
-    /// then return a mutable reference to it. Yields a [StoreAddr] which can be used to access
+    /// It then executes a user-provided closure and passes a mutable reference to that memory
-    /// the data stored in the pool
+    /// block to the closure. This allows the user to write data to the memory block.
+    /// The function should yield a [StoreAddr] which can be used to access the data stored in the
+    /// pool.
     fn free_element<W: FnMut(&mut [u8])>(
         &mut self,
         len: usize,
         writer: W,
     ) -> Result<StoreAddr, StoreError>;
 
-    /// Modify data added previously using a given [StoreAddr] by yielding a mutable reference
+    /// Modify data added previously using a given [StoreAddr]. The provider should use the store
-    /// to it
+    /// address to determine if a memory block exists for that address. If it does, it should
-    fn update<U: FnMut(&mut [u8])>(
+    /// call the user-provided closure and pass a mutable reference to the memory block
+    /// to the closure. This allows the user to modify the memory block.
+    fn modify<U: FnMut(&mut [u8])>(
         &mut self,
         addr: &StoreAddr,
         updater: U,
     ) -> Result<(), StoreError>;
 
-    /// Read data by yielding a read-only reference given a [StoreAddr]
+    /// The provider should copy the data from the memory block to the user-provided buffer if
+    /// it exists.
     fn read(&self, addr: &StoreAddr, buf: &mut [u8]) -> Result<usize, StoreError>;
 
-    /// Delete data inside the pool given a [StoreAddr]
+    /// Delete data inside the pool given a [StoreAddr].
     fn delete(&mut self, addr: StoreAddr) -> Result<(), StoreError>;
     fn has_element_at(&self, addr: &StoreAddr) -> Result<bool, StoreError>;
 
@@ -324,7 +329,7 @@ impl<'a, MemProvider: PoolProvider> PoolRwGuard<'a, MemProvider> {
     }
 
     pub fn update<U: FnMut(&mut [u8])>(&mut self, updater: &mut U) -> Result<(), StoreError> {
-        self.guard.pool.update(&self.guard.addr, updater)
+        self.guard.pool.modify(&self.guard.addr, updater)
     }
 
     delegate!(
@@ -532,7 +537,7 @@ mod alloc_mod {
             Ok(addr.into())
         }
 
-        fn update<U: FnMut(&mut [u8])>(
+        fn modify<U: FnMut(&mut [u8])>(
             &mut self,
             addr: &StoreAddr,
             mut updater: U,
@@ -712,7 +717,7 @@ mod tests {
         {
             // Verify that the slot is free by trying to get a reference to it
             local_pool
-                .update(&addr, &mut |buf: &mut [u8]| {
+                .modify(&addr, &mut |buf: &mut [u8]| {
                     buf[0] = 0;
                     buf[1] = 0x42;
                 })
@@ -911,22 +916,22 @@ mod tests {
         let addr2 = local_pool.add(&test_buf_2).expect("Adding data failed");
         let addr3 = local_pool.add(&test_buf_3).expect("Adding data failed");
         local_pool
-            .update(&addr0, |buf| {
+            .modify(&addr0, |buf| {
                 assert_eq!(buf, test_buf_0);
             })
             .expect("Modifying data failed");
         local_pool
-            .update(&addr1, |buf| {
+            .modify(&addr1, |buf| {
                 assert_eq!(buf, test_buf_1);
             })
             .expect("Modifying data failed");
         local_pool
-            .update(&addr2, |buf| {
+            .modify(&addr2, |buf| {
                 assert_eq!(buf, test_buf_2);
             })
             .expect("Modifying data failed");
         local_pool
-            .update(&addr3, |buf| {
+            .modify(&addr3, |buf| {
                 assert_eq!(buf, test_buf_3);
             })
             .expect("Modifying data failed");

satrs-example/src/tm_funnel.rs

@@ -104,7 +104,7 @@ impl TmFunnelStatic {
             let mut pool_guard = shared_pool.write().expect("Locking TM pool failed");
             let mut tm_copy = Vec::new();
             pool_guard
-                .update(&addr, |buf| {
+                .modify(&addr, |buf| {
                     let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN)
                         .expect("Creating TM zero copy writer failed");
                     self.common.apply_packet_processing(zero_copy_writer);