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(&mut self, value: T)
     where
         W: access::Safe,
@@ -290,6 +299,7 @@ where
     ///
     /// assert_eq!(volatile.read(), 43);
     /// ```
+    #[inline]
     pub fn update<F>(&mut 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<'a, F, U>(&'a 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<'a, F, U>(
         &'a self,
         f: F,
@@ -402,6 +415,7 @@ where
         unsafe { VolatilePtr::new_generic(f(self.pointer)) }
     }
 
+    #[inline]
     pub unsafe fn map_mut<F, U>(&mut self, f: F) -> VolatilePtr<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>(&mut self, f: F) -> VolatilePtr<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) -> VolatilePtr<T, Access<R, access::NoAccess>> {
         assert!(index < self.pointer.len(), "index out of bounds");
         unsafe {
@@ -489,6 +508,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn index_mut<I>(
         &mut self,
         index: I,
@@ -502,6 +522,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     #[cfg(feature = "very_unstable")]
+    #[inline]
     pub const fn index_mut_const(&mut self, index: usize) -> VolatilePtr<T, Access<R, W>> {
         assert!(index < self.pointer.len(), "index out of bounds");
         unsafe {
@@ -512,6 +533,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     /// Returns an iterator over the slice.
+    #[inline]
     pub fn iter<'b>(
         &'b self,
     ) -> impl Iterator<Item = VolatilePtr<'b, T, Access<R, access::NoAccess>>> + 'b {
@@ -520,6 +542,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>(
         &'b mut self,
     ) -> impl Iterator<Item = VolatilePtr<'b, T, Access<R, W>>> + 'b {
@@ -563,6 +586,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,
@@ -620,6 +644,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(&mut self, src: &[T])
     where
         T: Copy,
@@ -674,6 +699,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(&mut self, src: impl RangeBounds<usize>, dest: usize)
     where
         T: Copy,
@@ -699,6 +725,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn split_at(
         &self,
         mid: usize,
@@ -712,6 +739,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe { self.split_at_unchecked(mid) }
     }
 
+    #[inline]
     pub fn split_at_mut(
         &mut self,
         mid: usize,
@@ -725,6 +753,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,
@@ -741,6 +770,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     unsafe fn split_at_mut_unchecked(
         &mut self,
         mid: usize,
@@ -767,6 +797,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
         }
     }
 
+    #[inline]
     pub fn as_chunks<const N: usize>(
         &self,
     ) -> (
@@ -782,6 +813,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<[[T; N]], Access<R, access::NoAccess>> {
@@ -800,6 +832,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>(
         &mut self,
     ) -> (
@@ -815,6 +848,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>(
         &mut self,
     ) -> VolatilePtr<[[T; N]], Access<R, W>> {
@@ -833,6 +867,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>> {
@@ -876,6 +911,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(&mut self, value: u8)
     where
         W: access::Safe,
@@ -916,6 +952,7 @@ impl<T, R, W, const N: usize> VolatilePtr<'_, [T; N], Access<R, W>> {
     ///
     /// assert_eq!(dst, [1, 2]);
     /// ```
+    #[inline]
     pub fn as_slice(&self) -> VolatilePtr<[T], Access<R, access::NoAccess>> {
         unsafe {
             self.map(|array| {
@@ -948,6 +985,7 @@ impl<T, R, W, const N: usize> VolatilePtr<'_, [T; N], Access<R, W>> {
     ///
     /// assert_eq!(dst, [1, 2]);
     /// ```
+    #[inline]
     pub fn as_slice_mut<'a>(&'a mut self) -> VolatilePtr<'a, [T], Access<R, W>> {
         unsafe {
             self.map_mut(|array| {
@@ -978,6 +1016,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) }
     }
@@ -1002,6 +1041,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) }
     }
@@ -1012,20 +1052,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(&mut self, value: T)
     where
         W: access::Unsafe,
     {
         unsafe { ptr::write_volatile(self.pointer.as_ptr(), value) };
     }
 
+    #[inline]
     pub unsafe fn update_unsafe<F>(&mut self, f: F)
     where
         R: access::Unsafe,