Add futures::Delay trait

Author: lachlansneff

src/futures/delay.rs

@@ -0,0 +1,27 @@
+//! Asynchronous Delays
+//!
+//! # What's the difference this trait and the `timer::CountDown` trait?
+//!
+//! The `Delay` trait provides an asynchronous delay abstraction and it's meant to be used either
+//! to build higher-level abstractions like I/O timeouts or by itself.
+
+use core::future::Future;
+
+/// Asynchronously wait a duration of time.
+pub trait Delay {
+    /// Enumeration of `Delay` errors.
+    type Error;
+
+    /// The future returned from `delay`.
+    type DelayFuture<'a>: Future<Output = Result<(), Self::Error>> + 'a
+    where
+        Self: 'a;
+
+    /// The unit of time used by this delay timer.
+    type Time;
+
+    /// Returns a future that will resolve when `duration` has passed.
+    /// It is not guaranteed that _exactly_ `duration` will pass, but it will
+    /// be `duration` or longer.
+    fn delay<'a>(&mut self, duration: impl Into<Self::Time>) -> Self::DelayFuture<'a>;
+}

src/futures/mod.rs

@@ -3,7 +3,6 @@
 //! This traits use `core::future::Future` and generic associated types.
 
 pub mod i2c;
-pub mod rng;
 pub mod serial;
 pub mod spi;
-pub mod timer;
+pub mod delay;

src/futures/rng.rs

@@ -31,7 +31,7 @@ pub trait TransferInPlace<W: 'static> {
     /// This method uses a single `readwrite` buffer.
     ///
     /// The returned buffer is the initialized `readwrite` buffer.
-    fn transfer_inplace<'a>(&'a mut self, readwrite: &'a mut [W]) -> Self::TransferInPlaceFuture<'a>;
+    fn transfer_inplace<'a>(&'a mut self, words: &'a mut [W]) -> Self::TransferInPlaceFuture<'a>;
 }
 
 /// Async write
@@ -45,7 +45,7 @@ pub trait Write<W> {
         Self: 'a;
 
     /// Writes `words` to the slave, ignoring all the incoming words
-    fn write<'a>(&'a mut self, words: &'a [W]) -> Self::WriteFuture<'a>;
+    fn write<'a>(&'a mut self, write: &'a [W]) -> Self::WriteFuture<'a>;
 }
 
 /// Async read
@@ -63,5 +63,5 @@ pub trait Read<W: 'static> {
     /// by this trait. Some hardware can configure what values (e.g. 0x00, 0xFF), some cannot.
     ///
     /// The returned buffer is the initialized `words` buffer.
-    fn read<'a>(&'a mut self, words: &'a mut [W]) -> Self::ReadFuture<'a>;
+    fn read<'a>(&'a mut self, read: &'a mut [W]) -> Self::ReadFuture<'a>;
 }