Remove StaticXBuffer, make XBuffer impls require static. Fixes #10

Author: Dirbaio

src/lib.rs

@@ -105,7 +105,7 @@ pub unsafe trait WriteBuffer {
 
 unsafe impl<B, T> ReadBuffer for B
 where
-    B: Deref<Target = T> + StableDeref,
+    B: Deref<Target = T> + StableDeref + 'static,
     T: ReadTarget + ?Sized,
 {
     type Word = T::Word;
@@ -117,7 +117,7 @@ where
 
 unsafe impl<B, T> WriteBuffer for B
 where
-    B: DerefMut<Target = T> + StableDeref,
+    B: DerefMut<Target = T> + StableDeref + 'static,
     T: WriteTarget + ?Sized,
 {
     type Word = T::Word;
@@ -153,7 +153,7 @@ unsafe impl Word for i64 {}
 /// # Safety
 ///
 /// - `as_read_buffer` must adhere to the safety requirements
-///   documented for `DmaReadBuffer::dma_read_buffer`.
+///   documented for `ReadBuffer::read_buffer`.
 pub unsafe trait ReadTarget {
     type Word: Word;
 
@@ -172,7 +172,7 @@ pub unsafe trait ReadTarget {
 /// # Safety
 ///
 /// - `as_write_buffer` must adhere to the safety requirements
-///   documented for `DmaWriteBuffer::dma_write_buffer`.
+///   documented for `WriteBuffer::write_buffer`.
 pub unsafe trait WriteTarget {
     type Word: Word;
 
@@ -256,75 +256,6 @@ unsafe impl<T: WriteTarget> WriteTarget for MaybeUninit<T> {
     type Word = T::Word;
 }
 
-/// Trait for buffers that can be given to DMA for reading. This is a more strict version of
-/// [ReadBuffer](trait.ReadBuffer.html), if you are not sure about which one to use on your safe
-/// API, prefer this one. This trait also allows end users to __unsafely__ bypass the `'static`
-/// invariant.
-///
-/// # Safety
-///
-/// This has the same invariants as [ReadBuffer](trait.ReadBuffer.html) with the additional
-/// requirement that the buffer should have a `'static` lifetime.
-pub unsafe trait StaticReadBuffer: ReadBuffer {
-    type Word;
-
-    /// Provide a buffer usable for DMA reads.
-    ///
-    /// The return value is:
-    ///
-    /// - pointer to the start of the buffer
-    /// - buffer size in words
-    ///
-    /// # Safety
-    ///
-    /// Once this method has been called, it is unsafe to call any `&mut self`
-    /// methods on this object as long as the returned value is in use (by DMA).
-    unsafe fn static_read_buffer(&self) -> (*const <Self as StaticReadBuffer>::Word, usize);
-}
-
-/// Trait for buffers that can be given to DMA for writing. This is a more strict version of
-/// [WriteBuffer](trait.WriteBuffer.html), if you are not sure about which one to use on your safe
-/// API, prefer this one. This trait also allows end users to __unsafely__ bypass the `'static`
-/// invariant.
-///
-/// # Safety
-///
-/// This has the same invariants as [WriteBuffer](trait.WriteBuffer.html) with the additional
-/// requirement that the buffer should have a `'static` lifetime.
-pub unsafe trait StaticWriteBuffer: WriteBuffer {
-    type Word;
-
-    /// Provide a buffer usable for DMA writes.
-    ///
-    /// The return value is:
-    ///
-    /// - pointer to the start of the buffer
-    /// - buffer size in words
-    ///
-    /// # Safety
-    ///
-    /// Once this method has been called, it is unsafe to call any `&mut self`
-    /// methods, except for `write_buffer`, on this object as long as the
-    /// returned value is in use (by DMA).
-    unsafe fn static_write_buffer(&mut self) -> (*mut <Self as StaticWriteBuffer>::Word, usize);
-}
-
-unsafe impl<B: ReadBuffer + 'static> StaticReadBuffer for B {
-    type Word = <Self as ReadBuffer>::Word;
-
-    unsafe fn static_read_buffer(&self) -> (*const <Self as StaticReadBuffer>::Word, usize) {
-        self.read_buffer()
-    }
-}
-
-unsafe impl<B: WriteBuffer + 'static> StaticWriteBuffer for B {
-    type Word = <Self as WriteBuffer>::Word;
-
-    unsafe fn static_write_buffer(&mut self) -> (*mut <Self as StaticWriteBuffer>::Word, usize) {
-        self.write_buffer()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -337,40 +268,23 @@ mod tests {
         unsafe { buffer.read_buffer() }
     }
 
-    fn static_api_read<W, B>(buffer: B) -> (*const W, usize)
-    where
-        B: StaticReadBuffer<Word = W>,
-    {
-        unsafe { buffer.static_read_buffer() }
-    }
-
     fn api_write<W, B>(mut buffer: B) -> (*mut W, usize)
     where
         B: WriteBuffer<Word = W>,
     {
         unsafe { buffer.write_buffer() }
     }
 
-    fn static_api_write<W, B>(mut buffer: B) -> (*mut W, usize)
-    where
-        B: StaticWriteBuffer<Word = W>,
-    {
-        unsafe { buffer.static_write_buffer() }
-    }
-
     #[test]
     fn read_api() {
         const SIZE: usize = 128;
         static BUF: [u8; SIZE] = [0u8; SIZE];
         let local_buf = [0u8; SIZE];
 
-        let (ptr, size_local) = api_read(&local_buf);
+        let (ptr, size_local) = api_read(&BUF);
         assert!(unsafe { (&*ptr as &dyn Any).is::<u8>() });
         assert!(size_local == SIZE);
 
-        let (ptr, size_static) = static_api_read(&BUF);
-        assert!(unsafe { (&*ptr as &dyn Any).is::<u8>() });
-        assert!(size_static == SIZE);
     }
 
     #[test]
@@ -379,12 +293,8 @@ mod tests {
         static mut BUF: [u8; SIZE] = [0u8; SIZE];
         let mut local_buf = [0u8; SIZE];
 
-        let (ptr, size_local) = api_write(&mut local_buf);
+        let (ptr, size_local) = api_write(unsafe { &mut BUF });
         assert!(unsafe { (&*ptr as &dyn Any).is::<u8>() });
         assert!(size_local == SIZE);
-
-        let (ptr, size_static) = static_api_write(unsafe { &mut BUF });
-        assert!(unsafe { (&*ptr as &dyn Any).is::<u8>() });
-        assert!(size_static == SIZE);
     }
 }