io: add adapters to/from std::io.

Author: Dirbaio

embedded-io/src/adapters.rs

@@ -0,0 +1,161 @@
+//! Adapters to/from `std::io` traits.
+//!
+//! To interoperate with `std::io`, wrap a type in one of these
+//! adapters.
+//!
+//! There's no separate adapters for Read/ReadBuf/Write traits. Instead, a single
+//! adapter implements the right traits based on what the inner type implements.
+//! This allows adapting a `Read+Write`, for example.
+
+use crate::SeekFrom;
+
+/// Adapter from `std::io` traits.
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+#[derive(Clone)]
+pub struct FromStd<T: ?Sized> {
+    inner: T,
+}
+
+impl<T> FromStd<T> {
+    /// Create a new adapter.
+    pub fn new(inner: T) -> Self {
+        Self { inner }
+    }
+
+    /// Consume the adapter, returning the inner object.
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T: ?Sized> FromStd<T> {
+    /// Borrow the inner object.
+    pub fn inner(&self) -> &T {
+        &self.inner
+    }
+
+    /// Mutably borrow the inner object.
+    pub fn inner_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+impl<T: ?Sized> crate::Io for FromStd<T> {
+    type Error = std::io::Error;
+}
+
+impl<T: std::io::Read + ?Sized> crate::Read for FromStd<T> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        self.inner.read(buf)
+    }
+}
+
+impl<T: std::io::BufRead + ?Sized> crate::BufRead for FromStd<T> {
+    fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+        self.inner.fill_buf()
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.inner.consume(amt)
+    }
+}
+
+impl<T: std::io::Write + ?Sized> crate::Write for FromStd<T> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        self.inner.write(buf)
+    }
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        self.inner.flush()
+    }
+}
+
+impl<T: std::io::Seek + ?Sized> crate::Seek for FromStd<T> {
+    fn seek(&mut self, pos: crate::SeekFrom) -> Result<u64, Self::Error> {
+        self.inner.seek(pos.into())
+    }
+}
+
+/// Adapter to `std::io` traits.
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub struct ToStd<T: ?Sized> {
+    inner: T,
+}
+
+impl<T> ToStd<T> {
+    /// Create a new adapter.
+    pub fn new(inner: T) -> Self {
+        Self { inner }
+    }
+
+    /// Consume the adapter, returning the inner object.
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T: ?Sized> ToStd<T> {
+    /// Borrow the inner object.
+    pub fn inner(&self) -> &T {
+        &self.inner
+    }
+
+    /// Mutably borrow the inner object.
+    pub fn inner_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+impl<T: crate::Read + ?Sized> std::io::Read for ToStd<T> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+        self.inner.read(buf).map_err(to_io_error)
+    }
+}
+
+impl<T: crate::Write + ?Sized> std::io::Write for ToStd<T> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
+        self.inner.write(buf).map_err(to_io_error)
+    }
+    fn flush(&mut self) -> Result<(), std::io::Error> {
+        self.inner.flush().map_err(to_io_error)
+    }
+}
+
+impl<T: crate::Seek + ?Sized> std::io::Seek for ToStd<T> {
+    fn seek(&mut self, pos: std::io::SeekFrom) -> Result<u64, std::io::Error> {
+        self.inner.seek(pos.into()).map_err(to_io_error)
+    }
+}
+
+fn to_io_error<T: core::fmt::Debug>(err: T) -> std::io::Error {
+    let kind = std::io::ErrorKind::Other;
+    std::io::Error::new(kind, format!("{:?}", err))
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl crate::Error for std::io::Error {
+    fn kind(&self) -> crate::ErrorKind {
+        crate::ErrorKind::Other
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl From<SeekFrom> for std::io::SeekFrom {
+    fn from(pos: SeekFrom) -> Self {
+        match pos {
+            SeekFrom::Start(n) => std::io::SeekFrom::Start(n),
+            SeekFrom::End(n) => std::io::SeekFrom::End(n),
+            SeekFrom::Current(n) => std::io::SeekFrom::Current(n),
+        }
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl From<std::io::SeekFrom> for SeekFrom {
+    fn from(pos: std::io::SeekFrom) -> SeekFrom {
+        match pos {
+            std::io::SeekFrom::Start(n) => SeekFrom::Start(n),
+            std::io::SeekFrom::End(n) => SeekFrom::End(n),
+            std::io::SeekFrom::Current(n) => SeekFrom::Current(n),
+        }
+    }
+}

embedded-io/src/lib.rs

@@ -8,6 +8,9 @@ use core::fmt;
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
+#[cfg(feature = "std")]
+pub mod adapters;
+
 mod impls;
 
 /// Enumeration of possible methods to seek within an I/O object.