feat(io): add connections with std

src/dev/mod.rs

@@ -325,7 +325,7 @@ impl_device!(&mut [T]);
 impl_device!(Vec<T>);
 impl_device!(Box<[T]>);
 
-#[cfg(not(no_std))]
+#[cfg(feature = "std")]
 impl<E: core::error::Error> Device<u8, E> for RefCell<File> {
     #[inline]
     fn size(&self) -> Size {

src/error.rs

@@ -19,6 +19,10 @@ pub enum Error<E: core::error::Error> {
 
     /// Path error
     Path(PathError),
+
+    /// Standard I/O error
+    #[cfg(feature = "std")]
+    IO(std::io::Error),
 }
 
 impl<E: core::error::Error> Display for Error<E> {
@@ -28,6 +32,8 @@ impl<E: core::error::Error> Display for Error<E> {
             Self::Device(device_error) => write!(formatter, "Device Error: {device_error}"),
             Self::Fs(fs_error) => write!(formatter, "Filesystem Error: {fs_error}"),
             Self::Path(path_error) => write!(formatter, "Path Error: {path_error}"),
+            #[cfg(feature = "std")]
+            Self::IO(io_error) => write!(formatter, "I/O Error: {io_error}"),
         }
     }
 }

src/io.rs

@@ -20,10 +20,11 @@ pub trait Read<E: core::error::Error> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error<E>>;
 }
 
-impl<E: core::error::Error, S: Read<E>> Read<E> for &mut S {
+#[cfg(feature = "std")]
+impl<E: core::error::Error, S: std::io::Read> Read<E> for S {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error<E>> {
-        (**self).read(buf)
+        std::io::Read::read(self, buf).map_err(|err| Error::IO(err))
     }
 }
 
@@ -54,15 +55,16 @@ pub trait Write<E: core::error::Error> {
     fn flush(&mut self) -> Result<(), Error<E>>;
 }
 
-impl<E: core::error::Error, S: Write<E>> Write<E> for &mut S {
+#[cfg(feature = "std")]
+impl<E: core::error::Error, S: std::io::Write> Write<E> for S {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> Result<usize, Error<E>> {
-        (**self).write(buf)
+        std::io::Write::write(self, buf).map_err(|err| Error::IO(err))
     }
 
     #[inline]
     fn flush(&mut self) -> Result<(), Error<E>> {
-        (**self).flush()
+        std::io::Write::flush(self).map_err(|err| Error::IO(err))
     }
 }
 
@@ -85,6 +87,30 @@ pub enum SeekFrom {
     Current(i64),
 }
 
+#[cfg(feature = "std")]
+impl From<std::io::SeekFrom> for SeekFrom {
+    #[inline]
+    fn from(value: std::io::SeekFrom) -> Self {
+        match value {
+            std::io::SeekFrom::Start(value) => Self::Start(value),
+            std::io::SeekFrom::End(value) => Self::End(value),
+            std::io::SeekFrom::Current(value) => Self::Current(value),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<SeekFrom> for std::io::SeekFrom {
+    #[inline]
+    fn from(value: SeekFrom) -> Self {
+        match value {
+            SeekFrom::Start(value) => Self::Start(value),
+            SeekFrom::End(value) => Self::End(value),
+            SeekFrom::Current(value) => Self::Current(value),
+        }
+    }
+}
+
 /// Provides a cursor which can be moved within a stream of bytes.
 ///
 /// See [`std::io::Seek`] for more information: this trait is a `no_std` based variant.
@@ -99,9 +125,10 @@ pub trait Seek<E: core::error::Error> {
     fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error<E>>;
 }
 
-impl<E: core::error::Error, S: Seek<E>> Seek<E> for &mut S {
+#[cfg(feature = "std")]
+impl<E: core::error::Error, S: std::io::Seek> Seek<E> for S {
     #[inline]
     fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error<E>> {
-        (**self).seek(pos)
+        std::io::Seek::seek(self, pos.into()).map_err(|err| Error::IO(err))
     }
 }