add #[inline] to a bunch of functions

Author: Freax13

src/lib.rs

@@ -145,14 +145,17 @@ impl<T> VolatilePtr<'_, T>
 where
     T: ?Sized,
 {
+    #[inline]
     pub unsafe fn new_read_write(pointer: NonNull<T>) -> VolatilePtr<'static, T> {
         unsafe { VolatilePtr::new_with_access(pointer, Access::read_write()) }
     }
 
+    #[inline]
     pub const unsafe fn new_read_only(pointer: NonNull<T>) -> VolatilePtr<'static, T, ReadOnly> {
         unsafe { VolatilePtr::new_with_access(pointer, Access::read_only()) }
     }
 
+    #[inline]
     pub const unsafe fn new_write_only(pointer: NonNull<T>) -> VolatilePtr<'static, T, WriteOnly> {
         unsafe { VolatilePtr::new_with_access(pointer, Access::write_only()) }
     }
@@ -180,6 +183,7 @@ where
     /// volatile.write(1);
     /// assert_eq!(volatile.read(), 1);
     /// ```
+    #[inline]
     pub const unsafe fn new_with_access<A>(
         pointer: NonNull<T>,
         access: A,
@@ -188,6 +192,7 @@ where
         unsafe { Self::new_generic(pointer) }
     }
 
+    #[inline]
     pub const unsafe fn new_generic<'a, A>(pointer: NonNull<T>) -> VolatilePtr<'a, T, A> {
         VolatilePtr {
             pointer,
@@ -196,13 +201,15 @@ where
         }
     }
 
+    #[inline]
     pub fn from_ref<'a>(reference: &'a T) -> VolatilePtr<'a, T, ReadOnly>
     where
         T: 'a,
     {
         unsafe { VolatilePtr::new_generic(reference.into()) }
     }
 
+    #[inline]
     pub fn from_mut_ref<'a>(reference: &'a mut T) -> VolatilePtr<'a, T>
     where
         T: 'a,
@@ -238,6 +245,7 @@ where
     /// let mut_reference = unsafe { VolatilePtr::new_read_write(NonNull::from(&mut value)) };
     /// assert_eq!(mut_reference.read(), 50);
     /// ```
+    #[inline]
     pub fn read(self) -> T
     where
         R: access::Safe,
@@ -265,6 +273,7 @@ where
     ///
     /// assert_eq!(volatile.read(), 50);
     /// ```
+    #[inline]
     pub fn write(self, value: T)
     where
         W: access::Safe,
@@ -290,6 +299,7 @@ where
     ///
     /// assert_eq!(volatile.read(), 43);
     /// ```
+    #[inline]
     pub fn update<F>(self, f: F)
     where
         R: access::Safe,
@@ -331,6 +341,7 @@ where
     ///
     /// assert_eq!(unsafe { *unwrapped }, 50); // non volatile access, be careful!
     /// ```
+    #[inline]
     pub fn as_ptr(self) -> NonNull<T> {
         self.pointer
     }
@@ -382,6 +393,7 @@ where
     ///    value
     /// })};
     /// ```
+    #[inline]
     pub unsafe fn map<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, access::NoAccess>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
@@ -391,6 +403,7 @@ where
     }
 
     #[cfg(feature = "very_unstable")]
+    #[inline]
     pub const unsafe fn map_const<F, U>(
         self,
         f: F,
@@ -402,6 +415,7 @@ where
         unsafe { VolatilePtr::new_generic(f(self.pointer)) }
     }
 
+    #[inline]
     pub unsafe fn map_mut<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, W>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
@@ -411,6 +425,7 @@ where
     }
 
     #[cfg(feature = "very_unstable")]
+    #[inline]
     pub const unsafe fn map_mut_const<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, W>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
@@ -423,10 +438,12 @@ where
 /// Methods for volatile slices
 #[cfg(feature = "unstable")]
 impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
+    #[inline]
     pub fn len(self) -> usize {
         self.pointer.len()
     }
 
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.pointer.len() == 0
     }
@@ -467,6 +484,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// let subslice = volatile.index(1..);
     /// assert_eq!(subslice.index(0).read(), 2);
     /// ```
+    #[inline]
     pub fn index<I>(
         self,
         index: I,
@@ -480,6 +498,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     #[cfg(feature = "very_unstable")]
+    #[inline]
     pub const fn index_const(
         self,
         index: usize,
@@ -492,6 +511,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn index_mut<I>(
         self,
         index: I,
@@ -505,6 +525,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     #[cfg(feature = "very_unstable")]
+    #[inline]
     pub const fn index_mut_const(self, index: usize) -> VolatilePtr<'a, T, Access<R, W>> {
         assert!(index < self.pointer.len(), "index out of bounds");
         unsafe {
@@ -515,6 +536,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     /// Returns an iterator over the slice.
+    #[inline]
     pub fn iter<'b>(
         self,
     ) -> impl Iterator<Item = VolatilePtr<'a, T, Access<R, access::NoAccess>>> + 'b
@@ -528,6 +550,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     /// Returns an iterator that allows modifying each value.
+    #[inline]
     pub fn iter_mut<'b>(self) -> impl Iterator<Item = VolatilePtr<'a, T, Access<R, W>>> + 'b
     where
         'a: 'b,
@@ -572,6 +595,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// assert_eq!(src, [1, 2]);
     /// assert_eq!(dst, [5, 1, 2]);
     /// ```
+    #[inline]
     pub fn copy_into_slice(self, dst: &mut [T])
     where
         T: Copy,
@@ -629,6 +653,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// assert_eq!(src, [1, 2, 3, 4]);
     /// assert_eq!(dst, [3, 4]);
     /// ```
+    #[inline]
     pub fn copy_from_slice(self, src: &[T])
     where
         T: Copy,
@@ -683,6 +708,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// volatile.copy_within(1..5, 8);
     ///
     /// assert_eq!(&byte_array, b"Hello, Wello!");
+    #[inline]
     pub fn copy_within(self, src: impl RangeBounds<usize>, dest: usize)
     where
         T: Copy,
@@ -708,6 +734,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn split_at(
         self,
         mid: usize,
@@ -721,6 +748,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe { self.split_at_unchecked(mid) }
     }
 
+    #[inline]
     pub fn split_at_mut(
         self,
         mid: usize,
@@ -734,6 +762,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe { self.split_at_mut_unchecked(mid) }
     }
 
+    #[inline]
     unsafe fn split_at_unchecked(
         self,
         mid: usize,
@@ -750,6 +779,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     unsafe fn split_at_mut_unchecked(
         self,
         mid: usize,
@@ -776,6 +806,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn as_chunks<const N: usize>(
         self,
     ) -> (
@@ -791,6 +822,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         (array_slice, remainder)
     }
 
+    #[inline]
     pub unsafe fn as_chunks_unchecked<const N: usize>(
         self,
     ) -> VolatilePtr<'a, [[T; N]], Access<R, access::NoAccess>> {
@@ -809,6 +841,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe { VolatilePtr::new_generic(pointer) }
     }
 
+    #[inline]
     pub fn as_chunks_mut<const N: usize>(
         self,
     ) -> (
@@ -824,6 +857,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         (array_slice, remainder)
     }
 
+    #[inline]
     pub unsafe fn as_chunks_unchecked_mut<const N: usize>(
         self,
     ) -> VolatilePtr<'a, [[T; N]], Access<R, W>> {
@@ -842,6 +876,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe { VolatilePtr::new_generic(pointer) }
     }
 
+    #[inline]
     pub unsafe fn as_chunks_unchecked_by_val<const N: usize>(
         self,
     ) -> VolatilePtr<'a, [[T; N]], Access<R, W>> {
@@ -885,6 +920,7 @@ impl<R, W> VolatilePtr<'_, [u8], Access<R, W>> {
     /// buf.fill(1);
     /// assert_eq!(unsafe { buf.as_ptr().as_mut() }, &mut vec![1; 10]);
     /// ```
+    #[inline]
     pub fn fill(self, value: u8)
     where
         W: access::Safe,
@@ -925,6 +961,7 @@ impl<'a, T, R, W, const N: usize> VolatilePtr<'a, [T; N], Access<R, W>> {
     ///
     /// assert_eq!(dst, [1, 2]);
     /// ```
+    #[inline]
     pub fn as_slice(self) -> VolatilePtr<'a, [T], Access<R, access::NoAccess>> {
         unsafe {
             self.map(|array| {
@@ -957,6 +994,7 @@ impl<'a, T, R, W, const N: usize> VolatilePtr<'a, [T; N], Access<R, W>> {
     ///
     /// assert_eq!(dst, [1, 2]);
     /// ```
+    #[inline]
     pub fn as_slice_mut(self) -> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe {
             self.map_mut(|array| {
@@ -987,6 +1025,7 @@ where
     /// assert_eq!(read_only.read(), -4);
     /// // read_only.write(10); // compile-time error
     /// ```
+    #[inline]
     pub fn read_only(self) -> VolatilePtr<'a, T, Access<R, access::NoAccess>> {
         unsafe { VolatilePtr::new_generic(self.pointer) }
     }
@@ -1011,6 +1050,7 @@ where
     /// field_2.write(14);
     /// // field_2.read(); // compile-time error
     /// ```
+    #[inline]
     pub fn write_only(self) -> VolatilePtr<'a, T, Access<access::NoAccess, W>> {
         unsafe { VolatilePtr::new_generic(self.pointer) }
     }
@@ -1021,20 +1061,23 @@ impl<T, R, W> VolatilePtr<'_, T, Access<R, W>>
 where
     T: Copy + ?Sized,
 {
+    #[inline]
     pub unsafe fn read_unsafe(self) -> T
     where
         R: access::Unsafe,
     {
         unsafe { ptr::read_volatile(self.pointer.as_ptr()) }
     }
 
+    #[inline]
     pub unsafe fn write_unsafe(self, value: T)
     where
         W: access::Unsafe,
     {
         unsafe { ptr::write_volatile(self.pointer.as_ptr(), value) };
     }
 
+    #[inline]
     pub unsafe fn update_unsafe<F>(self, f: F)
     where
         R: access::Unsafe,
@@ -1051,6 +1094,7 @@ impl<'a, T, A> Clone for VolatilePtr<'a, T, A>
 where
     T: ?Sized,
 {
+    #[inline]
     fn clone(&self) -> Self {
         *self
     }