Remove new_with_access

Author: josephlr

src/access.rs

@@ -15,33 +15,7 @@ impl Unsafe for SafeAccess {}
 impl Safe for SafeAccess {}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Access<R, W> {
-    pub read: R,
-    pub write: W,
-}
-
-impl Access<SafeAccess, NoAccess> {
-    pub const fn read_only() -> ReadOnly {
-        Access {
-            read: SafeAccess,
-            write: NoAccess,
-        }
-    }
-
-    pub const fn write_only() -> WriteOnly {
-        Access {
-            read: NoAccess,
-            write: SafeAccess,
-        }
-    }
-
-    pub const fn read_write() -> ReadWrite {
-        Access {
-            read: SafeAccess,
-            write: SafeAccess,
-        }
-    }
-}
+pub struct Access<R, W>(R, W);
 
 pub type ReadOnly = Access<SafeAccess, NoAccess>;
 pub type WriteOnly = Access<NoAccess, SafeAccess>;

src/lib.rs

@@ -25,7 +25,6 @@ use access::{Access, ReadOnly, ReadWrite, WriteOnly};
 use core::{
     fmt,
     marker::PhantomData,
-    mem,
     ptr::{self, NonNull},
 };
 #[cfg(feature = "unstable")]
@@ -115,15 +114,15 @@ where
     T: ?Sized,
 {
     pub unsafe fn new_read_write(pointer: NonNull<T>) -> VolatilePtr<'static, T> {
-        unsafe { VolatilePtr::new_with_access(pointer, Access::read_write()) }
+        unsafe { VolatilePtr::new_generic(pointer) }
     }
 
     pub const unsafe fn new_read_only(pointer: NonNull<T>) -> VolatilePtr<'static, T, ReadOnly> {
-        unsafe { VolatilePtr::new_with_access(pointer, Access::read_only()) }
+        unsafe { VolatilePtr::new_generic(pointer) }
     }
 
     pub const unsafe fn new_write_only(pointer: NonNull<T>) -> VolatilePtr<'static, T, WriteOnly> {
-        unsafe { VolatilePtr::new_with_access(pointer, Access::write_only()) }
+        unsafe { VolatilePtr::new_generic(pointer) }
     }
 
     /// Constructs a new volatile instance wrapping the given reference.
@@ -149,14 +148,6 @@ where
     /// volatile.write(1);
     /// assert_eq!(volatile.read(), 1);
     /// ```
-    pub const unsafe fn new_with_access<A>(
-        pointer: NonNull<T>,
-        access: A,
-    ) -> VolatilePtr<'static, T, A> {
-        mem::forget(access); // needed because we cannot require `A: Copy` on stable Rust yet
-        unsafe { Self::new_generic(pointer) }
-    }
-
     pub const unsafe fn new_generic<'a, A>(pointer: NonNull<T>) -> VolatilePtr<'a, T, A> {
         VolatilePtr {
             pointer,

src/tests.rs

@@ -33,34 +33,26 @@ fn test_access() {
 
     // ReadWrite
     assert_eq!(
-        unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), Access::read_write()) }
-            .read(),
+        unsafe { VolatilePtr::new_read_write(NonNull::from(&mut val)) }.read(),
         42
     );
-    unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), Access::read_write()) }
-        .write(50);
+    unsafe { VolatilePtr::new_read_write(NonNull::from(&mut val)) }.write(50);
     assert_eq!(val, 50);
-    unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), Access::read_write()) }
-        .update(|i| *i += 1);
+    unsafe { VolatilePtr::new_read_write(NonNull::from(&mut val)) }.update(|i| *i += 1);
     assert_eq!(val, 51);
 
     // ReadOnly and WriteOnly
     assert_eq!(
-        unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), Access::read_only()) }
-            .read(),
+        unsafe { VolatilePtr::new_read_only(NonNull::from(&mut val)) }.read(),
         51
     );
-    unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), Access::write_only()) }
-        .write(12);
+    unsafe { VolatilePtr::new_write_only(NonNull::from(&mut val)) }.write(12);
     assert_eq!(val, 12);
 
     // Custom: safe read + safe write
     {
-        let access = Access {
-            read: SafeAccess,
-            write: SafeAccess,
-        };
-        let mut volatile = unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), access) };
+        type Custom = Access<SafeAccess, SafeAccess>;
+        let mut volatile = unsafe { VolatilePtr::new_generic::<Custom>(NonNull::from(&mut val)) };
         let random: i32 = rand::random();
         volatile.write(i64::from(random));
         assert_eq!(volatile.read(), i64::from(random));
@@ -71,11 +63,8 @@ fn test_access() {
 
     // Custom: safe read + unsafe write
     {
-        let access = Access {
-            read: SafeAccess,
-            write: UnsafeAccess,
-        };
-        let mut volatile = unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), access) };
+        type Custom = Access<SafeAccess, UnsafeAccess>;
+        let mut volatile = unsafe { VolatilePtr::new_generic::<Custom>(NonNull::from(&mut val)) };
         let random: i32 = rand::random();
         unsafe { volatile.write_unsafe(i64::from(random)) };
         assert_eq!(volatile.read(), i64::from(random));
@@ -86,23 +75,17 @@ fn test_access() {
 
     // Custom: safe read + no write
     {
-        let access = Access {
-            read: SafeAccess,
-            write: NoAccess,
-        };
+        type Custom = Access<SafeAccess, NoAccess>;
         let random = rand::random();
         val = random;
-        let volatile = unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), access) };
+        let volatile = unsafe { VolatilePtr::new_generic::<Custom>(NonNull::from(&mut val)) };
         assert_eq!(volatile.read(), i64::from(random));
     }
 
     // Custom: unsafe read + safe write
     {
-        let access = Access {
-            read: UnsafeAccess,
-            write: SafeAccess,
-        };
-        let mut volatile = unsafe { VolatilePtr::new_with_access(NonNull::from(&mut val), access) };
+        type Custom = Access<UnsafeAccess, SafeAccess>;
+        let mut volatile = unsafe { VolatilePtr::new_generic::<Custom>(NonNull::from(&mut val)) };
         let random: i32 = rand::random();
         volatile.write(i64::from(random));
         assert_eq!(unsafe { volatile.read_unsafe() }, i64::from(random));