| // Copyright (c) 2017 Baidu, Inc. All Rights Reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in |
| // the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Baidu, Inc., nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| use io::{self, SeekFrom, Read, Initializer, Write, Seek, BufRead, Error, ErrorKind}; |
| use core::cmp; |
| use core::fmt; |
| use core::mem; |
| |
| // ============================================================================= |
| // Forwarding implementations |
| |
| impl<'a, R: Read + ?Sized> Read for &'a mut R { |
| #[inline] |
| fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
| (**self).read(buf) |
| } |
| |
| #[inline] |
| unsafe fn initializer(&self) -> Initializer { |
| (**self).initializer() |
| } |
| |
| #[inline] |
| fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { |
| (**self).read_to_end(buf) |
| } |
| |
| #[inline] |
| fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { |
| (**self).read_to_string(buf) |
| } |
| |
| #[inline] |
| fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { |
| (**self).read_exact(buf) |
| } |
| } |
| |
| impl<'a, W: Write + ?Sized> Write for &'a mut W { |
| #[inline] |
| fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) } |
| |
| #[inline] |
| fn flush(&mut self) -> io::Result<()> { (**self).flush() } |
| |
| #[inline] |
| fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { |
| (**self).write_all(buf) |
| } |
| |
| #[inline] |
| fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> { |
| (**self).write_fmt(fmt) |
| } |
| } |
| |
| impl<'a, S: Seek + ?Sized> Seek for &'a mut S { |
| #[inline] |
| fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) } |
| } |
| |
| impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B { |
| #[inline] |
| fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() } |
| |
| #[inline] |
| fn consume(&mut self, amt: usize) { (**self).consume(amt) } |
| |
| #[inline] |
| fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> { |
| (**self).read_until(byte, buf) |
| } |
| |
| #[inline] |
| fn read_line(&mut self, buf: &mut String) -> io::Result<usize> { |
| (**self).read_line(buf) |
| } |
| } |
| |
| impl<R: Read + ?Sized> Read for Box<R> { |
| #[inline] |
| fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
| (**self).read(buf) |
| } |
| |
| #[inline] |
| unsafe fn initializer(&self) -> Initializer { |
| (**self).initializer() |
| } |
| |
| #[inline] |
| fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { |
| (**self).read_to_end(buf) |
| } |
| |
| #[inline] |
| fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { |
| (**self).read_to_string(buf) |
| } |
| |
| #[inline] |
| fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { |
| (**self).read_exact(buf) |
| } |
| } |
| |
| impl<W: Write + ?Sized> Write for Box<W> { |
| #[inline] |
| fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) } |
| |
| #[inline] |
| fn flush(&mut self) -> io::Result<()> { (**self).flush() } |
| |
| #[inline] |
| fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { |
| (**self).write_all(buf) |
| } |
| |
| #[inline] |
| fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> { |
| (**self).write_fmt(fmt) |
| } |
| } |
| |
| impl<S: Seek + ?Sized> Seek for Box<S> { |
| #[inline] |
| fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) } |
| } |
| |
| impl<B: BufRead + ?Sized> BufRead for Box<B> { |
| #[inline] |
| fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() } |
| |
| #[inline] |
| fn consume(&mut self, amt: usize) { (**self).consume(amt) } |
| |
| #[inline] |
| fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> { |
| (**self).read_until(byte, buf) |
| } |
| |
| #[inline] |
| fn read_line(&mut self, buf: &mut String) -> io::Result<usize> { |
| (**self).read_line(buf) |
| } |
| } |
| |
| // ============================================================================= |
| // 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<'a> Read for &'a [u8] { |
| #[inline] |
| fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
| 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] |
| unsafe fn initializer(&self) -> Initializer { |
| Initializer::nop() |
| } |
| |
| #[inline] |
| fn read_exact(&mut self, buf: &mut [u8]) -> io::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<'a> BufRead for &'a [u8] { |
| #[inline] |
| fn fill_buf(&mut self) -> io::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<'a> Write for &'a mut [u8] { |
| #[inline] |
| fn write(&mut self, data: &[u8]) -> io::Result<usize> { |
| 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]) -> io::Result<()> { |
| if self.write(data)? == data.len() { |
| Ok(()) |
| } else { |
| Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer")) |
| } |
| } |
| |
| #[inline] |
| fn flush(&mut self) -> io::Result<()> { Ok(()) } |
| } |
| |
| /// Write is implemented for `Vec<u8>` by appending to the vector. |
| /// The vector will grow as needed. |
| impl Write for Vec<u8> { |
| #[inline] |
| fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
| self.extend_from_slice(buf); |
| Ok(buf.len()) |
| } |
| |
| #[inline] |
| fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { |
| self.extend_from_slice(buf); |
| Ok(()) |
| } |
| |
| #[inline] |
| fn flush(&mut self) -> io::Result<()> { Ok(()) } |
| } |