io: add impls for slices.

Author: Dirbaio

embedded-io/src/impls/mod.rs

@@ -0,0 +1,2 @@
+mod slice_mut;
+mod slice_ref;

embedded-io/src/impls/slice_mut.rs

@@ -0,0 +1,31 @@
+use crate::{Io, Write};
+use core::mem;
+
+impl Io for &mut [u8] {
+    type Error = core::convert::Infallible;
+}
+
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
+///
+/// If the number of bytes to be written exceeds the size of the slice, write operations will
+/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
+/// kind `ErrorKind::WriteZero`.
+impl Write for &mut [u8] {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        let amt = core::cmp::min(buf.len(), self.len());
+        let (a, b) = mem::take(self).split_at_mut(amt);
+        a.copy_from_slice(&buf[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}

embedded-io/src/impls/slice_ref.rs

@@ -0,0 +1,41 @@
+use crate::{BufRead, Io, Read};
+
+impl Io for &[u8] {
+    type Error = core::convert::Infallible;
+}
+
+/// Read is implemented for `&[u8]` by copying from the slice.
+///
+/// Note that reading updates the slice to point to the yet unread part.
+/// The slice will be empty when EOF is reached.
+impl Read for &[u8] {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        let amt = core::cmp::min(buf.len(), self.len());
+        let (a, b) = self.split_at(amt);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if amt == 1 {
+            buf[0] = a[0];
+        } else {
+            buf[..amt].copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(amt)
+    }
+}
+
+impl BufRead for &[u8] {
+    #[inline]
+    fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+        Ok(*self)
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        *self = &self[amt..];
+    }
+}

embedded-io/src/lib.rs

@@ -4,6 +4,8 @@
 
 use core::fmt;
 
+mod impls;
+
 /// Enumeration of possible methods to seek within an I/O object.
 ///
 /// Semantics are the same as [`std::io::SeekFrom`], check its documentation for details.