use super::error::{Error, ErrorKind, Result}; use super::traits::{BufRead, Read, Seek, SeekFrom, Write}; use core::{cmp, fmt, mem}; // ============================================================================= // Forwarding implementations impl Read for &mut R { #[inline] fn read(&mut self, buf: &mut [u8]) -> Result { (**self).read(buf) } #[inline] fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { (**self).read_exact(buf) } } impl Write for &mut W { #[inline] fn write(&mut self, buf: &[u8]) -> Result { (**self).write(buf) } #[inline] fn flush(&mut self) -> Result<()> { (**self).flush() } #[inline] fn write_all(&mut self, buf: &[u8]) -> Result<()> { (**self).write_all(buf) } #[inline] fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> Result<()> { (**self).write_fmt(fmt) } } impl Seek for &mut S { #[inline] fn seek(&mut self, pos: SeekFrom) -> Result { (**self).seek(pos) } } impl BufRead for &mut B { #[inline] fn fill_buf(&mut self) -> Result<&[u8]> { (**self).fill_buf() } #[inline] fn consume(&mut self, amt: usize) { (**self).consume(amt) } } // ============================================================================= // In-memory buffer implementations /// 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 { let amt = 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) } #[inline] fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { if buf.len() > self.len() { return Err(Error::new( ErrorKind::UnexpectedEof, "failed to fill whole buffer", )); } let (a, b) = self.split_at(buf.len()); // 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 buf.len() == 1 { buf[0] = a[0]; } else { buf.copy_from_slice(a); } *self = b; Ok(()) } } impl BufRead for &[u8] { #[inline] fn fill_buf(&mut self) -> Result<&[u8]> { Ok(*self) } #[inline] fn consume(&mut self, amt: usize) { *self = &self[amt..]; } } /// 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. impl Write for &mut [u8] { #[inline] fn write(&mut self, data: &[u8]) -> Result { let amt = cmp::min(data.len(), self.len()); let (a, b) = mem::replace(self, &mut []).split_at_mut(amt); a.copy_from_slice(&data[..amt]); *self = b; Ok(amt) } #[inline] fn write_all(&mut self, data: &[u8]) -> Result<()> { if self.write(data)? == data.len() { Ok(()) } else { Err(Error::new( ErrorKind::WriteZero, "failed to write whole buffer", )) } } #[inline] fn flush(&mut self) -> Result<()> { Ok(()) } } /// Write is implemented for `Vec` by appending to the vector. /// The vector will grow as needed. #[cfg(feature = "alloc")] impl Write for alloc::vec::Vec { #[inline] fn write(&mut self, buf: &[u8]) -> Result { self.extend_from_slice(buf); Ok(buf.len()) } #[inline] fn write_all(&mut self, buf: &[u8]) -> Result<()> { self.extend_from_slice(buf); Ok(()) } #[inline] fn flush(&mut self) -> Result<()> { Ok(()) } }