Use iterator to replace GuestMemory's redundant methods

Now we have iterator for the GuestMemory trait, so remove with_regions(),
with_regions_mut() and map_and_fold().

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

src/guest_memory.rs

@@ -201,63 +201,8 @@ pub trait GuestMemory<'a> {
     /// Gets an iterator over the entries in the collection.
     fn iter(&'a self) -> Self::I;
 
-    /// Perform the specified action on each region.
-    /// It only walks children of current region and do not step into sub regions.
-    fn with_regions<F, E>(&self, cb: F) -> std::result::Result<(), E>
-    where
-        F: Fn(usize, &Self::R) -> std::result::Result<(), E>;
-
-    /// Perform the specified action on each region mutably.
-    /// It only walks children of current region and do not step into sub regions.
-    fn with_regions_mut<F, E>(&self, cb: F) -> std::result::Result<(), E>
-    where
-        F: FnMut(usize, &Self::R) -> std::result::Result<(), E>;
-
-    /// Applies two functions, specified as callbacks, on the inner memory regions.
-    ///
-    /// # Arguments
-    /// * `init` - Starting value of the accumulator for the `foldf` function.
-    /// * `mapf` - "Map" function, applied to all the inner memory regions. It returns an array of
-    ///            the same size as the memory regions array, containing the function's results
-    ///            for each region.
-    /// * `foldf` - "Fold" function, applied to the array returned by `mapf`. It acts as an
-    ///             operator, applying itself to the `init` value and to each subsequent elemnent
-    ///             in the array returned by `mapf`.
-    ///
-    /// # Examples
-    ///
-    /// * Compute the total size of all memory mappings in KB by iterating over the memory regions
-    ///   and dividing their sizes to 1024, then summing up the values in an accumulator.
-    ///
-    /// ```
-    /// # #[cfg(feature = "backend-mmap")]
-    /// # fn test_map_fold() -> Result<(), ()> {
-    /// # use vm_memory::{GuestAddress, GuestMemory, GuestMemoryRegion, mmap::GuestMemoryMmap};
-    ///     let start_addr1 = GuestAddress(0x0);
-    ///     let start_addr2 = GuestAddress(0x400);
-    ///     let mem = GuestMemoryMmap::new(&vec![(start_addr1, 1024), (start_addr2, 2048)]).unwrap();
-    ///     let total_size = mem.map_and_fold(
-    ///         0,
-    ///         |(_, region)| region.len() / 1024,
-    ///         |acc, size| acc + size
-    ///     );
-    ///     println!("Total memory size = {} KB", total_size);
-    ///     Ok(())
-    /// # }
-    /// ```
-    fn map_and_fold<F, G, T>(&self, init: T, mapf: F, foldf: G) -> T
-    where
-        F: Fn((usize, &Self::R)) -> T,
-        G: Fn(T, T) -> T;
-
     /// Get maximum (inclusive) address managed by the region.
-    fn end_addr(&self) -> GuestAddress {
-        self.map_and_fold(
-            GuestAddress(0),
-            |(_, region)| region.end_addr(),
-            std::cmp::max,
-        )
-    }
+    fn end_addr(&self) -> GuestAddress;
 
     /// Convert an absolute address into an address space (GuestMemory)
     /// to a relative address within this region, or return None if

src/mmap.rs

@@ -484,32 +484,11 @@ impl<'a> GuestMemory<'a> for GuestMemoryMmap {
         self.regions.iter()
     }
 
-    fn with_regions<F, E>(&self, cb: F) -> std::result::Result<(), E>
-    where
-        F: Fn(usize, &Self::R) -> std::result::Result<(), E>,
-    {
-        for (index, region) in self.regions.iter().enumerate() {
-            cb(index, region)?;
-        }
-        Ok(())
-    }
-
-    fn with_regions_mut<F, E>(&self, mut cb: F) -> std::result::Result<(), E>
-    where
-        F: FnMut(usize, &Self::R) -> std::result::Result<(), E>,
-    {
-        for (index, region) in self.regions.iter().enumerate() {
-            cb(index, region)?;
-        }
-        Ok(())
-    }
-
-    fn map_and_fold<F, G, T>(&self, init: T, mapf: F, foldf: G) -> T
-    where
-        F: Fn((usize, &Self::R)) -> T,
-        G: Fn(T, T) -> T,
-    {
-        self.regions.iter().enumerate().map(mapf).fold(init, foldf)
+    fn end_addr(&self) -> GuestAddress {
+        self.regions
+            .iter()
+            .max_by_key(|x| x.start_addr())
+            .map_or_else(|| GuestAddress(0), |x| x.end_addr())
     }
 }
 
@@ -769,24 +748,8 @@ mod tests {
             (GuestAddress(0x0), region_size),
             (GuestAddress(0x1000), region_size),
         ];
-        let mut iterated_regions = Vec::new();
         let gm = GuestMemoryMmap::new(&regions).unwrap();
 
-        let res: Result<()> = gm.with_regions(|_, region| {
-            assert_eq!(region.len(), region_size as GuestUsize);
-            Ok(())
-        });
-        assert!(res.is_ok());
-
-        let res: Result<()> = gm.with_regions_mut(|_, region| {
-            iterated_regions.push((region.start_addr(), region.len() as usize));
-            Ok(())
-        });
-        assert!(res.is_ok());
-        assert_eq!(regions, iterated_regions);
-        assert_eq!(gm.clone().regions[0].guest_base, regions[0].0);
-        assert_eq!(gm.clone().regions[1].guest_base, regions[1].0);
-
         let mut size = 0;
         let mut count = 0;
         for region in gm.iter() {