chore: remove deprecated methods

The old `Read`/`Write` based APIs for operating on guest memory have
been deprecated for a fairly long time now, and are superseceded by
their `ReadVolatile`/`WriteVolatile` equivalents.

The `fold` and friends functions have been deprecated for way longer.

Various `.as_ptr` APIs in volatile_memory.rs are deprecated in favor of
pointer guards.

Let's clean up the crate and remove all of these.

Signed-off-by: Patrick Roy <roypat@amazon.co.uk>

Author: roypat

CHANGELOG.md

@@ -6,6 +6,13 @@
 
 - \[[#311](https://github.com/rust-vmm/vm-memory/pull/311)\] Allow compiling without the ReadVolatile and WriteVolatile implementations
 
+### Removed
+
+- \[[#307](https://github.com/rust-vmm/vm-memory/pull/304)\] Remove deprecated functions `Bytes::read_from`, `Bytes::read_exact_from`,
+  `Bytes::write_to`, `Bytes::write_all_to`, `GuestMemory::as_slice`, `GuestMemory::as_slice_mut`, `GuestMemory::with_regions`, 
+  `GuestMemory::with_regions_mut`, `GuestMemory::map_and_fold`, `VolatileSlice::as_ptr`, `VolatileRef::as_ptr`, and
+  `VolatileArrayRef::as_ptr`.
+
 ## \[v0.16.1\]
 
 ### Added

src/bitmap/mod.rs

@@ -109,7 +109,6 @@ pub type MS<'a, M> = BS<'a, <<M as GuestMemory>::R as GuestMemoryRegion>::B>;
 pub(crate) mod tests {
     use super::*;
 
-    use std::io::Cursor;
     use std::marker::PhantomData;
     use std::mem::size_of_val;
     use std::result::Result;
@@ -264,26 +263,6 @@ pub(crate) mod tests {
         .unwrap();
         dirty_offset += step;
 
-        // Test `read_from`.
-        #[allow(deprecated)] // test of deprecated functions
-        h.test_access(bytes, dirty_offset, BUF_SIZE, |m, addr| {
-            assert_eq!(
-                m.read_from(addr, &mut Cursor::new(&buf), BUF_SIZE).unwrap(),
-                BUF_SIZE
-            )
-        })
-        .unwrap();
-        dirty_offset += step;
-
-        // Test `read_exact_from`.
-        #[allow(deprecated)] // test of deprecated functions
-        h.test_access(bytes, dirty_offset, BUF_SIZE, |m, addr| {
-            m.read_exact_from(addr, &mut Cursor::new(&buf), BUF_SIZE)
-                .unwrap()
-        })
-        .unwrap();
-        dirty_offset += step;
-
         // Test `store`.
         h.test_access(bytes, dirty_offset, size_of_val(&val), |m, addr| {
             m.store(val, addr, Ordering::Relaxed).unwrap()

src/bytes.rs

@@ -11,7 +11,6 @@
 //! Define the `ByteValued` trait to mark that it is safe to instantiate the struct with random
 //! data.
 
-use std::io::{Read, Write};
 use std::mem::{size_of, MaybeUninit};
 use std::result::Result;
 use std::slice::{from_raw_parts, from_raw_parts_mut};
@@ -277,72 +276,6 @@ pub trait Bytes<A> {
         self.read_slice(result.as_mut_slice(), addr).map(|_| result)
     }
 
-    /// Reads up to `count` bytes from an object and writes them into the container at `addr`.
-    ///
-    /// Returns the number of bytes written into the container.
-    ///
-    /// # Arguments
-    /// * `addr` - Begin writing at this address.
-    /// * `src` - Copy from `src` into the container.
-    /// * `count` - Copy `count` bytes from `src` into the container.
-    #[deprecated(
-        note = "Use `.read_volatile_from` or the functions of the `ReadVolatile` trait instead"
-    )]
-    fn read_from<F>(&self, addr: A, src: &mut F, count: usize) -> Result<usize, Self::E>
-    where
-        F: Read;
-
-    /// Reads exactly `count` bytes from an object and writes them into the container at `addr`.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `count` bytes couldn't have been copied from `src` to the container.
-    /// Part of the data may have been copied nevertheless.
-    ///
-    /// # Arguments
-    /// * `addr` - Begin writing at this address.
-    /// * `src` - Copy from `src` into the container.
-    /// * `count` - Copy exactly `count` bytes from `src` into the container.
-    #[deprecated(
-        note = "Use `.read_exact_volatile_from` or the functions of the `ReadVolatile` trait instead"
-    )]
-    fn read_exact_from<F>(&self, addr: A, src: &mut F, count: usize) -> Result<(), Self::E>
-    where
-        F: Read;
-
-    /// Reads up to `count` bytes from the container at `addr` and writes them it into an object.
-    ///
-    /// Returns the number of bytes written into the object.
-    ///
-    /// # Arguments
-    /// * `addr` - Begin reading from this address.
-    /// * `dst` - Copy from the container to `dst`.
-    /// * `count` - Copy `count` bytes from the container to `dst`.
-    #[deprecated(
-        note = "Use `.write_volatile_to` or the functions of the `WriteVolatile` trait instead"
-    )]
-    fn write_to<F>(&self, addr: A, dst: &mut F, count: usize) -> Result<usize, Self::E>
-    where
-        F: Write;
-
-    /// Reads exactly `count` bytes from the container at `addr` and writes them into an object.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `count` bytes couldn't have been copied from the container to `dst`.
-    /// Part of the data may have been copied nevertheless.
-    ///
-    /// # Arguments
-    /// * `addr` - Begin reading from this address.
-    /// * `dst` - Copy from the container to `dst`.
-    /// * `count` - Copy exactly `count` bytes from the container to `dst`.
-    #[deprecated(
-        note = "Use `.write_all_volatile_to` or the functions of the `WriteVolatile` trait instead"
-    )]
-    fn write_all_to<F>(&self, addr: A, dst: &mut F, count: usize) -> Result<(), Self::E>
-    where
-        F: Write;
-
     /// Atomically store a value at the specified address.
     fn store<T: AtomicAccess>(&self, val: T, addr: A, order: Ordering) -> Result<(), Self::E>;
 
@@ -481,34 +414,6 @@ pub(crate) mod tests {
             Ok(())
         }
 
-        fn read_from<F>(&self, _: usize, _: &mut F, _: usize) -> Result<usize, Self::E>
-        where
-            F: Read,
-        {
-            unimplemented!()
-        }
-
-        fn read_exact_from<F>(&self, _: usize, _: &mut F, _: usize) -> Result<(), Self::E>
-        where
-            F: Read,
-        {
-            unimplemented!()
-        }
-
-        fn write_to<F>(&self, _: usize, _: &mut F, _: usize) -> Result<usize, Self::E>
-        where
-            F: Write,
-        {
-            unimplemented!()
-        }
-
-        fn write_all_to<F>(&self, _: usize, _: &mut F, _: usize) -> Result<(), Self::E>
-        where
-            F: Write,
-        {
-            unimplemented!()
-        }
-
         fn store<T: AtomicAccess>(
             &self,
             _val: T,