diff options
Diffstat (limited to 'src/libstd/io/buffered.rs')
| -rw-r--r-- | src/libstd/io/buffered.rs | 147 |
1 files changed, 80 insertions, 67 deletions
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 557da174d89..8e81b292f6f 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -5,8 +5,9 @@ use crate::io::prelude::*; use crate::cmp; use crate::error; use crate::fmt; -use crate::io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom, IoSlice, - IoSliceMut}; +use crate::io::{ + self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, SeekFrom, DEFAULT_BUF_SIZE, +}; use crate::memchr; /// The `BufReader<R>` struct adds buffering to any reader. @@ -100,12 +101,7 @@ impl<R: Read> BufReader<R> { let mut buffer = Vec::with_capacity(capacity); buffer.set_len(capacity); inner.initializer().initialize(&mut buffer); - BufReader { - inner, - buf: buffer.into_boxed_slice(), - pos: 0, - cap: 0, - } + BufReader { inner, buf: buffer.into_boxed_slice(), pos: 0, cap: 0 } } } } @@ -130,7 +126,9 @@ impl<R> BufReader<R> { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_ref(&self) -> &R { &self.inner } + pub fn get_ref(&self) -> &R { + &self.inner + } /// Gets a mutable reference to the underlying reader. /// @@ -151,7 +149,9 @@ impl<R> BufReader<R> { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self) -> &mut R { &mut self.inner } + pub fn get_mut(&mut self) -> &mut R { + &mut self.inner + } /// Returns a reference to the internally buffered data. /// @@ -199,7 +199,9 @@ impl<R> BufReader<R> { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn into_inner(self) -> R { self.inner } + pub fn into_inner(self) -> R { + self.inner + } /// Invalidates all data in the internal buffer. #[inline] @@ -220,17 +222,17 @@ impl<R: Seek> BufReader<R> { if offset < 0 { if let Some(new_pos) = pos.checked_sub((-offset) as u64) { self.pos = new_pos as usize; - return Ok(()) + return Ok(()); } } else { if let Some(new_pos) = pos.checked_add(offset as u64) { if new_pos <= self.cap as u64 { self.pos = new_pos as usize; - return Ok(()) + return Ok(()); } } } - self.seek(SeekFrom::Current(offset)).map(|_|()) + self.seek(SeekFrom::Current(offset)).map(|_| ()) } } @@ -293,7 +295,10 @@ impl<R: Read> BufRead for BufReader<R> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug { +impl<R> fmt::Debug for BufReader<R> +where + R: fmt::Debug, +{ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("BufReader") .field("reader", &self.inner) @@ -483,11 +488,7 @@ impl<W: Write> BufWriter<W> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(capacity: usize, inner: W) -> BufWriter<W> { - BufWriter { - inner: Some(inner), - buf: Vec::with_capacity(capacity), - panicked: false, - } + BufWriter { inner: Some(inner), buf: Vec::with_capacity(capacity), panicked: false } } fn flush_buf(&mut self) -> io::Result<()> { @@ -501,14 +502,16 @@ impl<W: Write> BufWriter<W> { match r { Ok(0) => { - ret = Err(Error::new(ErrorKind::WriteZero, - "failed to write the buffered data")); + ret = + Err(Error::new(ErrorKind::WriteZero, "failed to write the buffered data")); break; } Ok(n) => written += n, Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} - Err(e) => { ret = Err(e); break } - + Err(e) => { + ret = Err(e); + break; + } } } if written > 0 { @@ -531,7 +534,9 @@ impl<W: Write> BufWriter<W> { /// let reference = buffer.get_ref(); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() } + pub fn get_ref(&self) -> &W { + self.inner.as_ref().unwrap() + } /// Gets a mutable reference to the underlying writer. /// @@ -549,7 +554,9 @@ impl<W: Write> BufWriter<W> { /// let reference = buffer.get_mut(); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() } + pub fn get_mut(&mut self) -> &mut W { + self.inner.as_mut().unwrap() + } /// Returns a reference to the internally buffered data. /// @@ -592,7 +599,7 @@ impl<W: Write> BufWriter<W> { pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> { match self.flush_buf() { Err(e) => Err(IntoInnerError(self, e)), - Ok(()) => Ok(self.inner.take().unwrap()) + Ok(()) => Ok(self.inner.take().unwrap()), } } } @@ -634,7 +641,10 @@ impl<W: Write> Write for BufWriter<W> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug { +impl<W: Write> fmt::Debug for BufWriter<W> +where + W: fmt::Debug, +{ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("BufWriter") .field("writer", &self.inner.as_ref().unwrap()) @@ -693,7 +703,9 @@ impl<W> IntoInnerError<W> { /// }; /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn error(&self) -> &Error { &self.1 } + pub fn error(&self) -> &Error { + &self.1 + } /// Returns the buffered writer instance which generated the error. /// @@ -726,12 +738,16 @@ impl<W> IntoInnerError<W> { /// }; /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn into_inner(self) -> W { self.0 } + pub fn into_inner(self) -> W { + self.0 + } } #[stable(feature = "rust1", since = "1.0.0")] impl<W> From<IntoInnerError<W>> for Error { - fn from(iie: IntoInnerError<W>) -> Error { iie.1 } + fn from(iie: IntoInnerError<W>) -> Error { + iie.1 + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -856,10 +872,7 @@ impl<W: Write> LineWriter<W> { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W> { - LineWriter { - inner: BufWriter::with_capacity(capacity, inner), - need_flush: false, - } + LineWriter { inner: BufWriter::with_capacity(capacity, inner), need_flush: false } } /// Gets a reference to the underlying writer. @@ -879,7 +892,9 @@ impl<W: Write> LineWriter<W> { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_ref(&self) -> &W { self.inner.get_ref() } + pub fn get_ref(&self) -> &W { + self.inner.get_ref() + } /// Gets a mutable reference to the underlying writer. /// @@ -902,7 +917,9 @@ impl<W: Write> LineWriter<W> { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() } + pub fn get_mut(&mut self) -> &mut W { + self.inner.get_mut() + } /// Unwraps this `LineWriter`, returning the underlying writer. /// @@ -930,10 +947,7 @@ impl<W: Write> LineWriter<W> { #[stable(feature = "rust1", since = "1.0.0")] pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> { self.inner.into_inner().map_err(|IntoInnerError(buf, e)| { - IntoInnerError(LineWriter { - inner: buf, - need_flush: false, - }, e) + IntoInnerError(LineWriter { inner: buf, need_flush: false }, e) }) } } @@ -953,7 +967,6 @@ impl<W: Write> Write for LineWriter<W> { None => return self.inner.write(buf), }; - // Ok, we're going to write a partial amount of the data given first // followed by flushing the newline. After we've successfully written // some data then we *must* report that we wrote that data, so future @@ -962,7 +975,7 @@ impl<W: Write> Write for LineWriter<W> { let n = self.inner.write(&buf[..=i])?; self.need_flush = true; if self.flush().is_err() || n != i + 1 { - return Ok(n) + return Ok(n); } // At this point we successfully wrote `i + 1` bytes and flushed it out, @@ -984,12 +997,17 @@ impl<W: Write> Write for LineWriter<W> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug { +impl<W: Write> fmt::Debug for LineWriter<W> +where + W: fmt::Debug, +{ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("LineWriter") .field("writer", &self.inner.inner) - .field("buffer", - &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity())) + .field( + "buffer", + &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()), + ) .finish() } } @@ -1008,11 +1026,7 @@ mod tests { impl Read for ShortReader { fn read(&mut self, _: &mut [u8]) -> io::Result<usize> { - if self.lengths.is_empty() { - Ok(0) - } else { - Ok(self.lengths.remove(0)) - } + if self.lengths.is_empty() { Ok(0) } else { Ok(self.lengths.remove(0)) } } } @@ -1123,7 +1137,7 @@ mod tests { fn test_buffered_reader_seek_underflow() { // gimmick reader that yields its position modulo 256 for each byte struct PositionReader { - pos: u64 + pos: u64, } impl Read for PositionReader { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { @@ -1154,7 +1168,7 @@ mod tests { let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 }); assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..])); - assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5)); + assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value() - 5)); assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5)); // the following seek will require two underlying seeks let expected = 9223372036854775802; @@ -1361,7 +1375,7 @@ mod tests { #[test] fn test_short_reads() { - let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]}; + let inner = ShortReader { lengths: vec![0, 1, 2, 0, 1, 0] }; let mut reader = BufReader::new(inner); let mut buf = [0, 0]; assert_eq!(reader.read(&mut buf).unwrap(), 0); @@ -1379,7 +1393,9 @@ mod tests { struct FailFlushWriter; impl Write for FailFlushWriter { - fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) } + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + Ok(buf.len()) + } fn flush(&mut self) -> io::Result<()> { Err(io::Error::last_os_error()) } @@ -1405,30 +1421,30 @@ mod tests { WRITES.fetch_add(1, Ordering::SeqCst); panic!(); } - fn flush(&mut self) -> io::Result<()> { Ok(()) } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } } thread::spawn(|| { let mut writer = BufWriter::new(PanicWriter); let _ = writer.write(b"hello world"); let _ = writer.flush(); - }).join().unwrap_err(); + }) + .join() + .unwrap_err(); assert_eq!(WRITES.load(Ordering::SeqCst), 1); } #[bench] fn bench_buffered_reader(b: &mut test::Bencher) { - b.iter(|| { - BufReader::new(io::empty()) - }); + b.iter(|| BufReader::new(io::empty())); } #[bench] fn bench_buffered_writer(b: &mut test::Bencher) { - b.iter(|| { - BufWriter::new(io::sink()) - }); + b.iter(|| BufWriter::new(io::sink())); } struct AcceptOneThenFail { @@ -1457,10 +1473,7 @@ mod tests { #[test] fn erroneous_flush_retried() { - let a = AcceptOneThenFail { - written: false, - flushed: false, - }; + let a = AcceptOneThenFail { written: false, flushed: false }; let mut l = LineWriter::new(a); assert_eq!(l.write(b"a\nb\na").unwrap(), 4); |