Remove futures::i2c::Transactional and remove required min_type_alias_impl_trait feature as a result

Author: lachlansneff

src/futures/i2c.rs

@@ -16,8 +16,8 @@
 //! Since 7-bit addressing is the mode of the majority of I2C devices,
 //! `SevenBitAddress` has been set as default mode and thus can be omitted if desired.
 
-use core::future::Future;
-pub use crate::blocking::i2c::{AddressMode, SevenBitAddress, TenBitAddress, Operation};
+use core::{future::Future, mem::MaybeUninit};
+pub use crate::blocking::i2c::{AddressMode, SevenBitAddress, TenBitAddress};
 
 /// Async read
 pub trait Read<A: AddressMode = SevenBitAddress> {
@@ -46,7 +46,7 @@ pub trait Read<A: AddressMode = SevenBitAddress> {
     /// - `MAK` = master acknowledge
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
-    fn read<'a>(&'a mut self, address: A, buffer: &'a mut [u8]) -> Self::ReadFuture<'a>;
+    fn read<'a>(&'a mut self, address: A, read: &'a mut [MaybeUninit<u8>]) -> Self::ReadFuture<'a>;
 }
 
 /// Async write
@@ -74,7 +74,7 @@ pub trait Write<A: AddressMode = SevenBitAddress> {
     /// - `SAK` = slave acknowledge
     /// - `Bi` = ith byte of data
     /// - `SP` = stop condition
-    fn write<'a>(&'a mut self, address: A, bytes: &'a [u8]) -> Self::WriteFuture<'a>;
+    fn write<'a>(&'a mut self, address: A, write: &'a [u8]) -> Self::WriteFuture<'a>;
 }
 
 /// Async write + read
@@ -86,7 +86,7 @@ pub trait WriteRead<A: AddressMode = SevenBitAddress> {
     where
         Self: 'a;
 
-    /// Writes bytes to slave with address `address` and then reads enough bytes to fill `buffer` *in a
+    /// Writes bytes to slave with address `address` and then reads enough bytes to fill `read` *in a
     /// single transaction*
     ///
     /// # I2C Events (contract)
@@ -111,72 +111,7 @@ pub trait WriteRead<A: AddressMode = SevenBitAddress> {
     fn write_read<'a>(
         &'a mut self,
         address: A,
-        bytes: &'a [u8],
-        buffer: &'a mut [u8],
+        write: &'a [u8],
+        read: &'a mut [MaybeUninit<u8>],
     ) -> Self::WriteReadFuture<'a>;
 }
-
-/// Transactional I2C interface.
-///
-/// This allows combining operations within an I2C transaction.
-pub trait Transactional<A: AddressMode = SevenBitAddress> {
-    /// Error type
-    type Error;
-    /// The future associated with the `exec` method.
-    type ExecFuture<'a>: Future<Output = Result<(), Self::Error>> + 'a
-    where
-        Self: 'a;
-
-    /// Execute the provided operations on the I2C bus.
-    ///
-    /// Transaction contract:
-    /// - Before executing the first operation an ST is sent automatically. This is followed by SAD+R/W as appropriate.
-    /// - Data from adjacent operations of the same type are sent after each other without an SP or SR.
-    /// - Between adjacent operations of a different type an SR and SAD+R/W is sent.
-    /// - After executing the last operation an SP is sent automatically.
-    /// - If the last operation is a `Read` the master does not send an acknowledge for the last byte.
-    ///
-    /// - `ST` = start condition
-    /// - `SAD+R/W` = slave address followed by bit 1 to indicate reading or 0 to indicate writing
-    /// - `SR` = repeated start condition
-    /// - `SP` = stop condition
-    fn exec<'a>(&'a mut self, address: A, operations: &'a mut [Operation<'a>])
-        -> Self::ExecFuture<'a>;
-}
-
-/// Default implementation of `futures::i2c::Transactional` for `futures::i2c::{Read, Write}` implementers.
-///
-/// If you implement `futures::i2c::Read` and `futures::i2c::Write` for your I2C peripheral,
-/// you can use this default implementation so to automatically implement
-/// `futures::i2c::Transactional` as well.
-pub mod transactional {
-    use super::{Future, AddressMode, Operation, Read, Transactional, Write};
-
-    /// Default implementation of `futures::i2c::Write`, `futures::i2c::Read` and
-    /// `futures::i2c::WriteRead` traits for `futures::i2c::Transactional` implementers.
-    pub trait Default<A: AddressMode>: Read<A> + Write<A> {}
-
-    impl<A, E, S> Transactional<A> for S
-    where
-        A: AddressMode + Copy + 'static,
-        S: Default<A> + Read<A, Error = E> + Write<A, Error = E>,
-        E: 'static,
-    {
-        type Error = E;
-
-        type ExecFuture<'a> where Self: 'a = impl Future<Output = Result<(), Self::Error>> + 'a;
-
-        fn exec<'a>(&'a mut self, address: A, operations: &'a mut [Operation<'a>]) -> Self::ExecFuture<'a> {
-            async move {
-                for op in operations {
-                    match op {
-                        Operation::Read(buffer) => self.read(address, buffer).await?,
-                        Operation::Write(buffer) => self.write(address, buffer).await?,
-                    }
-                }
-
-                Ok(())
-            }
-        }
-    }
-}

src/lib.rs

@@ -407,7 +407,7 @@
 #![doc(html_root_url = "https://docs.rs/embedded-hal/1.0.0-alpha.4")]
 #![deny(missing_docs)]
 #![no_std]
-#![cfg_attr(feature = "unstable-futures", feature(generic_associated_types, min_type_alias_impl_trait))]
+#![cfg_attr(feature = "unstable-futures", feature(generic_associated_types))]
 
 pub mod blocking;
 pub mod fmt;