io: add ReadReady, WriteReady.

Author: Dirbaio

embedded-io-async/src/lib.rs

@@ -9,7 +9,9 @@ extern crate alloc;
 
 mod impls;
 
-pub use embedded_io::{Error, ErrorKind, Io, ReadExactError, SeekFrom, WriteAllError};
+pub use embedded_io::{
+    Error, ErrorKind, Io, ReadExactError, ReadReady, SeekFrom, WriteAllError, WriteReady,
+};
 
 /// Async reader.
 ///

embedded-io/CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- Added `ReadReady`, `WriteReady` traits. They allow peeking whether the i/o handle is ready to read/write, so they allow using the traits in a non-blocking way.
 - Moved `embedded_io::blocking` to the crate root.
 - Split async traits to the `embedded-io-async` crate.
 - Split async trait adapters to separate crates.

embedded-io/src/impls/boxx.rs

@@ -1,4 +1,4 @@
-use crate::{BufRead, Io, Read, Seek, Write};
+use crate::{BufRead, Io, Read, ReadReady, Seek, Write, WriteReady};
 use alloc::boxed::Box;
 
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
@@ -45,3 +45,19 @@ impl<T: ?Sized + Seek> Seek for Box<T> {
         T::seek(self, pos)
     }
 }
+
+#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
+impl<T: ?Sized + ReadReady> ReadReady for Box<T> {
+    #[inline]
+    fn read_ready(&mut self) -> Result<bool, Self::Error> {
+        T::read_ready(self)
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
+impl<T: ?Sized + WriteReady> WriteReady for Box<T> {
+    #[inline]
+    fn write_ready(&mut self) -> Result<bool, Self::Error> {
+        T::write_ready(self)
+    }
+}

embedded-io/src/lib.rs

@@ -262,6 +262,33 @@ pub trait Seek: crate::Io {
     }
 }
 
+/// Get whether a reader is ready.
+///
+/// This allows using a [`Read`] or [`BufRead`] in a nonblocking fashion, i.e. trying to read
+/// only when it is ready.
+pub trait ReadReady: crate::Io {
+    /// Get whether the reader is ready for immediately reading.
+    ///
+    /// This usually means that there is either some bytes have been received and are buffered and ready to be read,
+    /// or that the reader is at EOF.
+    ///
+    /// If this returns `true`, it's guaranteed that the next call to [`Read::read`] or [`BufRead::fill_buf`] will not block.
+    fn read_ready(&mut self) -> Result<bool, Self::Error>;
+}
+
+/// Get whether a writer is ready.
+///
+/// This allows using a [`Write`] in a nonblocking fashion, i.e. trying to write
+/// only when it is ready.
+pub trait WriteReady: crate::Io {
+    /// Get whether the writer is ready for immediately writeing.
+    ///
+    /// This usually means that there is free space in the internal transmit buffer.
+    ///
+    /// If this returns `true`, it's guaranteed that the next call to [`Write::write`] will not block.
+    fn write_ready(&mut self) -> Result<bool, Self::Error>;
+}
+
 impl<T: ?Sized + Read> Read for &mut T {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
@@ -297,3 +324,17 @@ impl<T: ?Sized + Seek> Seek for &mut T {
         T::seek(self, pos)
     }
 }
+
+impl<T: ?Sized + ReadReady> ReadReady for &mut T {
+    #[inline]
+    fn read_ready(&mut self) -> Result<bool, Self::Error> {
+        T::read_ready(self)
+    }
+}
+
+impl<T: ?Sized + WriteReady> WriteReady for &mut T {
+    #[inline]
+    fn write_ready(&mut self) -> Result<bool, Self::Error> {
+        T::write_ready(self)
+    }
+}