4 self, BufRead, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
8 // =============================================================================
9 // Forwarding implementations
11 #[stable(feature = "rust1", since = "1.0.0")]
12 impl<R: Read + ?Sized> Read for &mut R {
14 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
19 fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
20 (**self).read_vectored(bufs)
24 unsafe fn initializer(&self) -> Initializer {
25 (**self).initializer()
29 fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
30 (**self).read_to_end(buf)
34 fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
35 (**self).read_to_string(buf)
39 fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
40 (**self).read_exact(buf)
43 #[stable(feature = "rust1", since = "1.0.0")]
44 impl<W: Write + ?Sized> Write for &mut W {
46 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
51 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
52 (**self).write_vectored(bufs)
56 fn flush(&mut self) -> io::Result<()> {
61 fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
62 (**self).write_all(buf)
66 fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
67 (**self).write_fmt(fmt)
70 #[stable(feature = "rust1", since = "1.0.0")]
71 impl<S: Seek + ?Sized> Seek for &mut S {
73 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
77 #[stable(feature = "rust1", since = "1.0.0")]
78 impl<B: BufRead + ?Sized> BufRead for &mut B {
80 fn fill_buf(&mut self) -> io::Result<&[u8]> {
85 fn consume(&mut self, amt: usize) {
90 fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
91 (**self).read_until(byte, buf)
95 fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
96 (**self).read_line(buf)
100 #[stable(feature = "rust1", since = "1.0.0")]
101 impl<R: Read + ?Sized> Read for Box<R> {
103 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
108 fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
109 (**self).read_vectored(bufs)
113 unsafe fn initializer(&self) -> Initializer {
114 (**self).initializer()
118 fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
119 (**self).read_to_end(buf)
123 fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
124 (**self).read_to_string(buf)
128 fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
129 (**self).read_exact(buf)
132 #[stable(feature = "rust1", since = "1.0.0")]
133 impl<W: Write + ?Sized> Write for Box<W> {
135 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
140 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
141 (**self).write_vectored(bufs)
145 fn flush(&mut self) -> io::Result<()> {
150 fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
151 (**self).write_all(buf)
155 fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
156 (**self).write_fmt(fmt)
159 #[stable(feature = "rust1", since = "1.0.0")]
160 impl<S: Seek + ?Sized> Seek for Box<S> {
162 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
166 #[stable(feature = "rust1", since = "1.0.0")]
167 impl<B: BufRead + ?Sized> BufRead for Box<B> {
169 fn fill_buf(&mut self) -> io::Result<&[u8]> {
174 fn consume(&mut self, amt: usize) {
175 (**self).consume(amt)
179 fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
180 (**self).read_until(byte, buf)
184 fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
185 (**self).read_line(buf)
189 // Used by panicking::default_hook
191 /// This impl is only used by printing logic, so any error returned is always
192 /// of kind `Other`, and should be ignored.
193 impl Write for Box<dyn (::realstd::io::Write) + Send> {
194 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
195 (**self).write(buf).map_err(|_| ErrorKind::Other.into())
198 fn flush(&mut self) -> io::Result<()> {
199 (**self).flush().map_err(|_| ErrorKind::Other.into())
203 // =============================================================================
204 // In-memory buffer implementations
206 /// Read is implemented for `&[u8]` by copying from the slice.
208 /// Note that reading updates the slice to point to the yet unread part.
209 /// The slice will be empty when EOF is reached.
210 #[stable(feature = "rust1", since = "1.0.0")]
211 impl Read for &[u8] {
213 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
214 let amt = cmp::min(buf.len(), self.len());
215 let (a, b) = self.split_at(amt);
217 // First check if the amount of bytes we want to read is small:
218 // `copy_from_slice` will generally expand to a call to `memcpy`, and
219 // for a single byte the overhead is significant.
223 buf[..amt].copy_from_slice(a);
231 fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
234 nread += self.read(buf)?;
244 unsafe fn initializer(&self) -> Initializer {
249 fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
250 if buf.len() > self.len() {
251 return Err(Error::new(ErrorKind::UnexpectedEof, "failed to fill whole buffer"));
253 let (a, b) = self.split_at(buf.len());
255 // First check if the amount of bytes we want to read is small:
256 // `copy_from_slice` will generally expand to a call to `memcpy`, and
257 // for a single byte the overhead is significant.
261 buf.copy_from_slice(a);
269 fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
270 buf.extend_from_slice(*self);
271 let len = self.len();
272 *self = &self[len..];
277 #[stable(feature = "rust1", since = "1.0.0")]
278 impl BufRead for &[u8] {
280 fn fill_buf(&mut self) -> io::Result<&[u8]> {
285 fn consume(&mut self, amt: usize) {
286 *self = &self[amt..];
290 /// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
293 /// Note that writing updates the slice to point to the yet unwritten part.
294 /// The slice will be empty when it has been completely overwritten.
295 #[stable(feature = "rust1", since = "1.0.0")]
296 impl Write for &mut [u8] {
298 fn write(&mut self, data: &[u8]) -> io::Result<usize> {
299 let amt = cmp::min(data.len(), self.len());
300 let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
301 a.copy_from_slice(&data[..amt]);
307 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
308 let mut nwritten = 0;
310 nwritten += self.write(buf)?;
320 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
321 if self.write(data)? == data.len() {
324 Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
329 fn flush(&mut self) -> io::Result<()> {
334 /// Write is implemented for `Vec<u8>` by appending to the vector.
335 /// The vector will grow as needed.
336 #[stable(feature = "rust1", since = "1.0.0")]
337 impl Write for Vec<u8> {
339 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
340 self.extend_from_slice(buf);
345 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
346 let len = bufs.iter().map(|b| b.len()).sum();
349 self.extend_from_slice(buf);
355 fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
356 self.extend_from_slice(buf);
361 fn flush(&mut self) -> io::Result<()> {
368 use crate::io::prelude::*;
371 fn bench_read_slice(b: &mut test::Bencher) {
373 let mut dst = [0; 128];
376 let mut rd = &buf[..];
378 let _ = rd.read(&mut dst);
379 test::black_box(&dst);
385 fn bench_write_slice(b: &mut test::Bencher) {
386 let mut buf = [0; 1024];
390 let mut wr = &mut buf[..];
392 let _ = wr.write_all(&src);
393 test::black_box(&wr);
399 fn bench_read_vec(b: &mut test::Bencher) {
400 let buf = vec![5; 1024];
401 let mut dst = [0; 128];
404 let mut rd = &buf[..];
406 let _ = rd.read(&mut dst);
407 test::black_box(&dst);
413 fn bench_write_vec(b: &mut test::Bencher) {
414 let mut buf = Vec::with_capacity(1024);
418 let mut wr = &mut buf[..];
420 let _ = wr.write_all(&src);
421 test::black_box(&wr);