1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Buffering wrappers for I/O traits
18 use io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
21 /// The `BufReader` struct adds buffering to any reader.
23 /// It can be excessively inefficient to work directly with a [`Read`] instance.
24 /// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]
25 /// results in a system call. A `BufReader` performs large, infrequent reads on
26 /// the underlying [`Read`] and maintains an in-memory buffer of the results.
28 /// `BufReader` can improve the speed of programs that make *small* and
29 /// *repeated* read calls to the same file or network socket. It does not
30 /// help when reading very large amounts at once, or reading just one or a few
31 /// times. It also provides no advantage when reading from a source that is
32 /// already in memory, like a `Vec<u8>`.
34 /// [`Read`]: ../../std/io/trait.Read.html
35 /// [`TcpStream::read`]: ../../std/net/struct.TcpStream.html#method.read
36 /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
41 /// use std::io::prelude::*;
42 /// use std::io::BufReader;
43 /// use std::fs::File;
45 /// fn main() -> std::io::Result<()> {
46 /// let f = File::open("log.txt")?;
47 /// let mut reader = BufReader::new(f);
49 /// let mut line = String::new();
50 /// let len = reader.read_line(&mut line)?;
51 /// println!("First line is {} bytes long", len);
55 #[stable(feature = "rust1", since = "1.0.0")]
56 pub struct BufReader<R> {
63 impl<R: Read> BufReader<R> {
64 /// Creates a new `BufReader` with a default buffer capacity. The default is currently 8 KB,
65 /// but may change in the future.
70 /// use std::io::BufReader;
71 /// use std::fs::File;
73 /// fn main() -> std::io::Result<()> {
74 /// let f = File::open("log.txt")?;
75 /// let reader = BufReader::new(f);
79 #[stable(feature = "rust1", since = "1.0.0")]
80 pub fn new(inner: R) -> BufReader<R> {
81 BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
84 /// Creates a new `BufReader` with the specified buffer capacity.
88 /// Creating a buffer with ten bytes of capacity:
91 /// use std::io::BufReader;
92 /// use std::fs::File;
94 /// fn main() -> std::io::Result<()> {
95 /// let f = File::open("log.txt")?;
96 /// let reader = BufReader::with_capacity(10, f);
100 #[stable(feature = "rust1", since = "1.0.0")]
101 pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
103 let mut buffer = Vec::with_capacity(cap);
105 inner.initializer().initialize(&mut buffer);
108 buf: buffer.into_boxed_slice(),
115 /// Gets a reference to the underlying reader.
117 /// It is inadvisable to directly read from the underlying reader.
122 /// use std::io::BufReader;
123 /// use std::fs::File;
125 /// fn main() -> std::io::Result<()> {
126 /// let f1 = File::open("log.txt")?;
127 /// let reader = BufReader::new(f1);
129 /// let f2 = reader.get_ref();
133 #[stable(feature = "rust1", since = "1.0.0")]
134 pub fn get_ref(&self) -> &R { &self.inner }
136 /// Gets a mutable reference to the underlying reader.
138 /// It is inadvisable to directly read from the underlying reader.
143 /// use std::io::BufReader;
144 /// use std::fs::File;
146 /// fn main() -> std::io::Result<()> {
147 /// let f1 = File::open("log.txt")?;
148 /// let mut reader = BufReader::new(f1);
150 /// let f2 = reader.get_mut();
154 #[stable(feature = "rust1", since = "1.0.0")]
155 pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
157 /// Returns a reference to the internally buffered data.
159 /// Unlike `fill_buf`, this will not attempt to fill the buffer if it is empty.
164 /// # #![feature(bufreader_buffer)]
165 /// use std::io::{BufReader, BufRead};
166 /// use std::fs::File;
168 /// fn main() -> std::io::Result<()> {
169 /// let f = File::open("log.txt")?;
170 /// let mut reader = BufReader::new(f);
171 /// assert!(reader.buffer().is_empty());
173 /// if reader.fill_buf()?.len() > 0 {
174 /// assert!(!reader.buffer().is_empty());
179 #[unstable(feature = "bufreader_buffer", issue = "45323")]
180 pub fn buffer(&self) -> &[u8] {
181 &self.buf[self.pos..self.cap]
184 /// Unwraps this `BufReader`, returning the underlying reader.
186 /// Note that any leftover data in the internal buffer is lost.
191 /// use std::io::BufReader;
192 /// use std::fs::File;
194 /// fn main() -> std::io::Result<()> {
195 /// let f1 = File::open("log.txt")?;
196 /// let reader = BufReader::new(f1);
198 /// let f2 = reader.into_inner();
202 #[stable(feature = "rust1", since = "1.0.0")]
203 pub fn into_inner(self) -> R { self.inner }
206 impl<R: Seek> BufReader<R> {
207 /// Seeks relative to the current position. If the new position lies within the buffer,
208 /// the buffer will not be flushed, allowing for more efficient seeks.
209 /// This method does not return the location of the underlying reader, so the caller
210 /// must track this information themselves if it is required.
211 #[unstable(feature = "bufreader_seek_relative", issue = "31100")]
212 pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
213 let pos = self.pos as u64;
215 if let Some(new_pos) = pos.checked_sub((-offset) as u64) {
216 self.pos = new_pos as usize;
220 if let Some(new_pos) = pos.checked_add(offset as u64) {
221 if new_pos <= self.cap as u64 {
222 self.pos = new_pos as usize;
227 self.seek(SeekFrom::Current(offset)).map(|_|())
231 #[stable(feature = "rust1", since = "1.0.0")]
232 impl<R: Read> Read for BufReader<R> {
233 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
234 // If we don't have any buffered data and we're doing a massive read
235 // (larger than our internal buffer), bypass our internal buffer
237 if self.pos == self.cap && buf.len() >= self.buf.len() {
238 return self.inner.read(buf);
241 let mut rem = self.fill_buf()?;
248 // we can't skip unconditionally because of the large buffer case in read.
249 unsafe fn initializer(&self) -> Initializer {
250 self.inner.initializer()
254 #[stable(feature = "rust1", since = "1.0.0")]
255 impl<R: Read> BufRead for BufReader<R> {
256 fn fill_buf(&mut self) -> io::Result<&[u8]> {
257 // If we've reached the end of our internal buffer then we need to fetch
258 // some more data from the underlying reader.
259 // Branch using `>=` instead of the more correct `==`
260 // to tell the compiler that the pos..cap slice is always valid.
261 if self.pos >= self.cap {
262 debug_assert!(self.pos == self.cap);
263 self.cap = self.inner.read(&mut self.buf)?;
266 Ok(&self.buf[self.pos..self.cap])
269 fn consume(&mut self, amt: usize) {
270 self.pos = cmp::min(self.pos + amt, self.cap);
274 #[stable(feature = "rust1", since = "1.0.0")]
275 impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
276 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
277 fmt.debug_struct("BufReader")
278 .field("reader", &self.inner)
279 .field("buffer", &format_args!("{}/{}", self.cap - self.pos, self.buf.len()))
284 #[stable(feature = "rust1", since = "1.0.0")]
285 impl<R: Seek> Seek for BufReader<R> {
286 /// Seek to an offset, in bytes, in the underlying reader.
288 /// The position used for seeking with `SeekFrom::Current(_)` is the
289 /// position the underlying reader would be at if the `BufReader` had no
292 /// Seeking always discards the internal buffer, even if the seek position
293 /// would otherwise fall within it. This guarantees that calling
294 /// `.into_inner()` immediately after a seek yields the underlying reader
295 /// at the same position.
297 /// To seek without discarding the internal buffer, use [`Seek::seek_relative`].
299 /// See [`std::io::Seek`] for more details.
301 /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
302 /// where `n` minus the internal buffer length overflows an `i64`, two
303 /// seeks will be performed instead of one. If the second seek returns
304 /// `Err`, the underlying reader will be left at the same position it would
305 /// have if you called `seek` with `SeekFrom::Current(0)`.
306 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
308 if let SeekFrom::Current(n) = pos {
309 let remainder = (self.cap - self.pos) as i64;
310 // it should be safe to assume that remainder fits within an i64 as the alternative
311 // means we managed to allocate 8 exbibytes and that's absurd.
312 // But it's not out of the realm of possibility for some weird underlying reader to
313 // support seeking by i64::min_value() so we need to handle underflow when subtracting
315 if let Some(offset) = n.checked_sub(remainder) {
316 result = self.inner.seek(SeekFrom::Current(offset))?;
318 // seek backwards by our remainder, and then by the offset
319 self.inner.seek(SeekFrom::Current(-remainder))?;
320 self.pos = self.cap; // empty the buffer
321 result = self.inner.seek(SeekFrom::Current(n))?;
324 // Seeking with Start/End doesn't care about our buffer length.
325 result = self.inner.seek(pos)?;
327 self.pos = self.cap; // empty the buffer
332 /// Wraps a writer and buffers its output.
334 /// It can be excessively inefficient to work directly with something that
335 /// implements [`Write`]. For example, every call to
336 /// [`write`][`Tcpstream::write`] on [`TcpStream`] results in a system call. A
337 /// `BufWriter` keeps an in-memory buffer of data and writes it to an underlying
338 /// writer in large, infrequent batches.
340 /// `BufWriter` can improve the speed of programs that make *small* and
341 /// *repeated* write calls to the same file or network socket. It does not
342 /// help when writing very large amounts at once, or writing just one or a few
343 /// times. It also provides no advantage when writing to a destination that is
344 /// in memory, like a `Vec<u8>`.
346 /// When the `BufWriter` is dropped, the contents of its buffer will be written
347 /// out. However, any errors that happen in the process of flushing the buffer
348 /// when the writer is dropped will be ignored. Code that wishes to handle such
349 /// errors must manually call [`flush`] before the writer is dropped.
353 /// Let's write the numbers one through ten to a [`TcpStream`]:
356 /// use std::io::prelude::*;
357 /// use std::net::TcpStream;
359 /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
362 /// stream.write(&[i+1]).unwrap();
366 /// Because we're not buffering, we write each one in turn, incurring the
367 /// overhead of a system call per byte written. We can fix this with a
371 /// use std::io::prelude::*;
372 /// use std::io::BufWriter;
373 /// use std::net::TcpStream;
375 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
378 /// stream.write(&[i+1]).unwrap();
382 /// By wrapping the stream with a `BufWriter`, these ten writes are all grouped
383 /// together by the buffer, and will all be written out in one system call when
384 /// the `stream` is dropped.
386 /// [`Write`]: ../../std/io/trait.Write.html
387 /// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write
388 /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
389 /// [`flush`]: #method.flush
390 #[stable(feature = "rust1", since = "1.0.0")]
391 pub struct BufWriter<W: Write> {
394 // #30888: If the inner writer panics in a call to write, we don't want to
395 // write the buffered data a second time in BufWriter's destructor. This
396 // flag tells the Drop impl if it should skip the flush.
400 /// An error returned by `into_inner` which combines an error that
401 /// happened while writing out the buffer, and the buffered writer object
402 /// which may be used to recover from the condition.
407 /// use std::io::BufWriter;
408 /// use std::net::TcpStream;
410 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
412 /// // do stuff with the stream
414 /// // we want to get our `TcpStream` back, so let's try:
416 /// let stream = match stream.into_inner() {
419 /// // Here, e is an IntoInnerError
420 /// panic!("An error occurred");
425 #[stable(feature = "rust1", since = "1.0.0")]
426 pub struct IntoInnerError<W>(W, Error);
428 impl<W: Write> BufWriter<W> {
429 /// Creates a new `BufWriter` with a default buffer capacity. The default is currently 8 KB,
430 /// but may change in the future.
435 /// use std::io::BufWriter;
436 /// use std::net::TcpStream;
438 /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
440 #[stable(feature = "rust1", since = "1.0.0")]
441 pub fn new(inner: W) -> BufWriter<W> {
442 BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
445 /// Creates a new `BufWriter` with the specified buffer capacity.
449 /// Creating a buffer with a buffer of a hundred bytes.
452 /// use std::io::BufWriter;
453 /// use std::net::TcpStream;
455 /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
456 /// let mut buffer = BufWriter::with_capacity(100, stream);
458 #[stable(feature = "rust1", since = "1.0.0")]
459 pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
462 buf: Vec::with_capacity(cap),
467 fn flush_buf(&mut self) -> io::Result<()> {
469 let len = self.buf.len();
470 let mut ret = Ok(());
471 while written < len {
472 self.panicked = true;
473 let r = self.inner.as_mut().unwrap().write(&self.buf[written..]);
474 self.panicked = false;
478 ret = Err(Error::new(ErrorKind::WriteZero,
479 "failed to write the buffered data"));
482 Ok(n) => written += n,
483 Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
484 Err(e) => { ret = Err(e); break }
489 self.buf.drain(..written);
494 /// Gets a reference to the underlying writer.
499 /// use std::io::BufWriter;
500 /// use std::net::TcpStream;
502 /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
504 /// // we can use reference just like buffer
505 /// let reference = buffer.get_ref();
507 #[stable(feature = "rust1", since = "1.0.0")]
508 pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
510 /// Gets a mutable reference to the underlying writer.
512 /// It is inadvisable to directly write to the underlying writer.
517 /// use std::io::BufWriter;
518 /// use std::net::TcpStream;
520 /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
522 /// // we can use reference just like buffer
523 /// let reference = buffer.get_mut();
525 #[stable(feature = "rust1", since = "1.0.0")]
526 pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
528 /// Returns a reference to the internally buffered data.
533 /// # #![feature(bufreader_buffer)]
534 /// use std::io::BufWriter;
535 /// use std::net::TcpStream;
537 /// let mut buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
539 /// // See how many bytes are currently buffered
540 /// let bytes_buffered = buf_writer.buffer().len();
542 #[unstable(feature = "bufreader_buffer", issue = "45323")]
543 pub fn buffer(&self) -> &[u8] {
547 /// Unwraps this `BufWriter`, returning the underlying writer.
549 /// The buffer is written out before returning the writer.
553 /// An `Err` will be returned if an error occurs while flushing the buffer.
558 /// use std::io::BufWriter;
559 /// use std::net::TcpStream;
561 /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
563 /// // unwrap the TcpStream and flush the buffer
564 /// let stream = buffer.into_inner().unwrap();
566 #[stable(feature = "rust1", since = "1.0.0")]
567 pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
568 match self.flush_buf() {
569 Err(e) => Err(IntoInnerError(self, e)),
570 Ok(()) => Ok(self.inner.take().unwrap())
575 #[stable(feature = "rust1", since = "1.0.0")]
576 impl<W: Write> Write for BufWriter<W> {
577 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
578 if self.buf.len() + buf.len() > self.buf.capacity() {
581 if buf.len() >= self.buf.capacity() {
582 self.panicked = true;
583 let r = self.inner.as_mut().unwrap().write(buf);
584 self.panicked = false;
587 Write::write(&mut self.buf, buf)
590 fn flush(&mut self) -> io::Result<()> {
591 self.flush_buf().and_then(|()| self.get_mut().flush())
595 #[stable(feature = "rust1", since = "1.0.0")]
596 impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
597 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
598 fmt.debug_struct("BufWriter")
599 .field("writer", &self.inner.as_ref().unwrap())
600 .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
605 #[stable(feature = "rust1", since = "1.0.0")]
606 impl<W: Write + Seek> Seek for BufWriter<W> {
607 /// Seek to the offset, in bytes, in the underlying writer.
609 /// Seeking always writes out the internal buffer before seeking.
610 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
611 self.flush_buf().and_then(|_| self.get_mut().seek(pos))
615 #[stable(feature = "rust1", since = "1.0.0")]
616 impl<W: Write> Drop for BufWriter<W> {
618 if self.inner.is_some() && !self.panicked {
619 // dtors should not panic, so we ignore a failed flush
620 let _r = self.flush_buf();
625 impl<W> IntoInnerError<W> {
626 /// Returns the error which caused the call to `into_inner()` to fail.
628 /// This error was returned when attempting to write the internal buffer.
633 /// use std::io::BufWriter;
634 /// use std::net::TcpStream;
636 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
638 /// // do stuff with the stream
640 /// // we want to get our `TcpStream` back, so let's try:
642 /// let stream = match stream.into_inner() {
645 /// // Here, e is an IntoInnerError, let's log the inner error.
647 /// // We'll just 'log' to stdout for this example.
648 /// println!("{}", e.error());
650 /// panic!("An unexpected error occurred.");
654 #[stable(feature = "rust1", since = "1.0.0")]
655 pub fn error(&self) -> &Error { &self.1 }
657 /// Returns the buffered writer instance which generated the error.
659 /// The returned object can be used for error recovery, such as
660 /// re-inspecting the buffer.
665 /// use std::io::BufWriter;
666 /// use std::net::TcpStream;
668 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
670 /// // do stuff with the stream
672 /// // we want to get our `TcpStream` back, so let's try:
674 /// let stream = match stream.into_inner() {
677 /// // Here, e is an IntoInnerError, let's re-examine the buffer:
678 /// let buffer = e.into_inner();
680 /// // do stuff to try to recover
682 /// // afterwards, let's just return the stream
683 /// buffer.into_inner().unwrap()
687 #[stable(feature = "rust1", since = "1.0.0")]
688 pub fn into_inner(self) -> W { self.0 }
691 #[stable(feature = "rust1", since = "1.0.0")]
692 impl<W> From<IntoInnerError<W>> for Error {
693 fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
696 #[stable(feature = "rust1", since = "1.0.0")]
697 impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
698 fn description(&self) -> &str {
699 error::Error::description(self.error())
703 #[stable(feature = "rust1", since = "1.0.0")]
704 impl<W> fmt::Display for IntoInnerError<W> {
705 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
710 /// Wraps a writer and buffers output to it, flushing whenever a newline
711 /// (`0x0a`, `'\n'`) is detected.
713 /// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.
714 /// But it only does this batched write when it goes out of scope, or when the
715 /// internal buffer is full. Sometimes, you'd prefer to write each line as it's
716 /// completed, rather than the entire buffer at once. Enter `LineWriter`. It
717 /// does exactly that.
719 /// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the
720 /// `LineWriter` goes out of scope or when its internal buffer is full.
722 /// [bufwriter]: struct.BufWriter.html
724 /// If there's still a partial line in the buffer when the `LineWriter` is
725 /// dropped, it will flush those contents.
729 /// We can use `LineWriter` to write one line at a time, significantly
730 /// reducing the number of actual writes to the file.
733 /// use std::fs::{self, File};
734 /// use std::io::prelude::*;
735 /// use std::io::LineWriter;
737 /// fn main() -> std::io::Result<()> {
738 /// let road_not_taken = b"I shall be telling this with a sigh
739 /// Somewhere ages and ages hence:
740 /// Two roads diverged in a wood, and I -
741 /// I took the one less traveled by,
742 /// And that has made all the difference.";
744 /// let file = File::create("poem.txt")?;
745 /// let mut file = LineWriter::new(file);
747 /// file.write_all(b"I shall be telling this with a sigh")?;
749 /// // No bytes are written until a newline is encountered (or
750 /// // the internal buffer is filled).
751 /// assert_eq!(fs::read_to_string("poem.txt")?, "");
752 /// file.write_all(b"\n")?;
754 /// fs::read_to_string("poem.txt")?,
755 /// "I shall be telling this with a sigh\n",
758 /// // Write the rest of the poem.
759 /// file.write_all(b"Somewhere ages and ages hence:
760 /// Two roads diverged in a wood, and I -
761 /// I took the one less traveled by,
762 /// And that has made all the difference.")?;
764 /// // The last line of the poem doesn't end in a newline, so
765 /// // we have to flush or drop the `LineWriter` to finish
769 /// // Confirm the whole poem was written.
770 /// assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);
774 #[stable(feature = "rust1", since = "1.0.0")]
775 pub struct LineWriter<W: Write> {
780 impl<W: Write> LineWriter<W> {
781 /// Creates a new `LineWriter`.
786 /// use std::fs::File;
787 /// use std::io::LineWriter;
789 /// fn main() -> std::io::Result<()> {
790 /// let file = File::create("poem.txt")?;
791 /// let file = LineWriter::new(file);
795 #[stable(feature = "rust1", since = "1.0.0")]
796 pub fn new(inner: W) -> LineWriter<W> {
797 // Lines typically aren't that long, don't use a giant buffer
798 LineWriter::with_capacity(1024, inner)
801 /// Creates a new `LineWriter` with a specified capacity for the internal
807 /// use std::fs::File;
808 /// use std::io::LineWriter;
810 /// fn main() -> std::io::Result<()> {
811 /// let file = File::create("poem.txt")?;
812 /// let file = LineWriter::with_capacity(100, file);
816 #[stable(feature = "rust1", since = "1.0.0")]
817 pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
819 inner: BufWriter::with_capacity(cap, inner),
824 /// Gets a reference to the underlying writer.
829 /// use std::fs::File;
830 /// use std::io::LineWriter;
832 /// fn main() -> std::io::Result<()> {
833 /// let file = File::create("poem.txt")?;
834 /// let file = LineWriter::new(file);
836 /// let reference = file.get_ref();
840 #[stable(feature = "rust1", since = "1.0.0")]
841 pub fn get_ref(&self) -> &W { self.inner.get_ref() }
843 /// Gets a mutable reference to the underlying writer.
845 /// Caution must be taken when calling methods on the mutable reference
846 /// returned as extra writes could corrupt the output stream.
851 /// use std::fs::File;
852 /// use std::io::LineWriter;
854 /// fn main() -> std::io::Result<()> {
855 /// let file = File::create("poem.txt")?;
856 /// let mut file = LineWriter::new(file);
858 /// // we can use reference just like file
859 /// let reference = file.get_mut();
863 #[stable(feature = "rust1", since = "1.0.0")]
864 pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
866 /// Unwraps this `LineWriter`, returning the underlying writer.
868 /// The internal buffer is written out before returning the writer.
872 /// An `Err` will be returned if an error occurs while flushing the buffer.
877 /// use std::fs::File;
878 /// use std::io::LineWriter;
880 /// fn main() -> std::io::Result<()> {
881 /// let file = File::create("poem.txt")?;
883 /// let writer: LineWriter<File> = LineWriter::new(file);
885 /// let file: File = writer.into_inner()?;
889 #[stable(feature = "rust1", since = "1.0.0")]
890 pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
891 self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
892 IntoInnerError(LineWriter {
900 #[stable(feature = "rust1", since = "1.0.0")]
901 impl<W: Write> Write for LineWriter<W> {
902 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
907 // Find the last newline character in the buffer provided. If found then
908 // we're going to write all the data up to that point and then flush,
909 // otherwise we just write the whole block to the underlying writer.
910 let i = match memchr::memrchr(b'\n', buf) {
912 None => return self.inner.write(buf),
916 // Ok, we're going to write a partial amount of the data given first
917 // followed by flushing the newline. After we've successfully written
918 // some data then we *must* report that we wrote that data, so future
919 // errors are ignored. We set our internal `need_flush` flag, though, in
920 // case flushing fails and we need to try it first next time.
921 let n = self.inner.write(&buf[..i + 1])?;
922 self.need_flush = true;
923 if self.flush().is_err() || n != i + 1 {
927 // At this point we successfully wrote `i + 1` bytes and flushed it out,
928 // meaning that the entire line is now flushed out on the screen. While
929 // we can attempt to finish writing the rest of the data provided.
930 // Remember though that we ignore errors here as we've successfully
931 // written data, so we need to report that.
932 match self.inner.write(&buf[i + 1..]) {
938 fn flush(&mut self) -> io::Result<()> {
940 self.need_flush = false;
945 #[stable(feature = "rust1", since = "1.0.0")]
946 impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
947 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
948 fmt.debug_struct("LineWriter")
949 .field("writer", &self.inner.inner)
951 &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
959 use io::{self, BufReader, BufWriter, LineWriter, SeekFrom};
960 use sync::atomic::{AtomicUsize, Ordering};
964 /// A dummy reader intended at testing short-reads propagation.
965 pub struct ShortReader {
969 impl Read for ShortReader {
970 fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
971 if self.lengths.is_empty() {
974 Ok(self.lengths.remove(0))
980 fn test_buffered_reader() {
981 let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
982 let mut reader = BufReader::with_capacity(2, inner);
984 let mut buf = [0, 0, 0];
985 let nread = reader.read(&mut buf);
986 assert_eq!(nread.unwrap(), 3);
987 assert_eq!(buf, [5, 6, 7]);
988 assert_eq!(*reader.buffer(), []);
990 let mut buf = [0, 0];
991 let nread = reader.read(&mut buf);
992 assert_eq!(nread.unwrap(), 2);
993 assert_eq!(buf, [0, 1]);
994 assert_eq!(*reader.buffer(), []);
997 let nread = reader.read(&mut buf);
998 assert_eq!(nread.unwrap(), 1);
999 assert_eq!(buf, [2]);
1000 assert_eq!(*reader.buffer(), [3]);
1002 let mut buf = [0, 0, 0];
1003 let nread = reader.read(&mut buf);
1004 assert_eq!(nread.unwrap(), 1);
1005 assert_eq!(buf, [3, 0, 0]);
1006 assert_eq!(*reader.buffer(), []);
1008 let nread = reader.read(&mut buf);
1009 assert_eq!(nread.unwrap(), 1);
1010 assert_eq!(buf, [4, 0, 0]);
1011 assert_eq!(*reader.buffer(), []);
1013 assert_eq!(reader.read(&mut buf).unwrap(), 0);
1017 fn test_buffered_reader_seek() {
1018 let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1019 let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1021 assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));
1022 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1023 assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));
1024 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1025 assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));
1026 assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));
1028 assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));
1032 fn test_buffered_reader_seek_relative() {
1033 let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1034 let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1036 assert!(reader.seek_relative(3).is_ok());
1037 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1038 assert!(reader.seek_relative(0).is_ok());
1039 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1040 assert!(reader.seek_relative(1).is_ok());
1041 assert_eq!(reader.fill_buf().ok(), Some(&[1][..]));
1042 assert!(reader.seek_relative(-1).is_ok());
1043 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1044 assert!(reader.seek_relative(2).is_ok());
1045 assert_eq!(reader.fill_buf().ok(), Some(&[2, 3][..]));
1049 fn test_buffered_reader_seek_underflow() {
1050 // gimmick reader that yields its position modulo 256 for each byte
1051 struct PositionReader {
1054 impl Read for PositionReader {
1055 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1056 let len = buf.len();
1058 *x = self.pos as u8;
1059 self.pos = self.pos.wrapping_add(1);
1064 impl Seek for PositionReader {
1065 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
1067 SeekFrom::Start(n) => {
1070 SeekFrom::Current(n) => {
1071 self.pos = self.pos.wrapping_add(n as u64);
1073 SeekFrom::End(n) => {
1074 self.pos = u64::max_value().wrapping_add(n as u64);
1081 let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
1082 assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
1083 assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));
1084 assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1085 // the following seek will require two underlying seeks
1086 let expected = 9223372036854775802;
1087 assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));
1088 assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1089 // seeking to 0 should empty the buffer.
1090 assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));
1091 assert_eq!(reader.get_ref().pos, expected);
1095 fn test_buffered_writer() {
1096 let inner = Vec::new();
1097 let mut writer = BufWriter::with_capacity(2, inner);
1099 writer.write(&[0, 1]).unwrap();
1100 assert_eq!(*writer.buffer(), []);
1101 assert_eq!(*writer.get_ref(), [0, 1]);
1103 writer.write(&[2]).unwrap();
1104 assert_eq!(*writer.buffer(), [2]);
1105 assert_eq!(*writer.get_ref(), [0, 1]);
1107 writer.write(&[3]).unwrap();
1108 assert_eq!(*writer.buffer(), [2, 3]);
1109 assert_eq!(*writer.get_ref(), [0, 1]);
1111 writer.flush().unwrap();
1112 assert_eq!(*writer.buffer(), []);
1113 assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1115 writer.write(&[4]).unwrap();
1116 writer.write(&[5]).unwrap();
1117 assert_eq!(*writer.buffer(), [4, 5]);
1118 assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1120 writer.write(&[6]).unwrap();
1121 assert_eq!(*writer.buffer(), [6]);
1122 assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
1124 writer.write(&[7, 8]).unwrap();
1125 assert_eq!(*writer.buffer(), []);
1126 assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
1128 writer.write(&[9, 10, 11]).unwrap();
1129 assert_eq!(*writer.buffer(), []);
1130 assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1132 writer.flush().unwrap();
1133 assert_eq!(*writer.buffer(), []);
1134 assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1138 fn test_buffered_writer_inner_flushes() {
1139 let mut w = BufWriter::with_capacity(3, Vec::new());
1140 w.write(&[0, 1]).unwrap();
1141 assert_eq!(*w.get_ref(), []);
1142 let w = w.into_inner().unwrap();
1143 assert_eq!(w, [0, 1]);
1147 fn test_buffered_writer_seek() {
1148 let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));
1149 w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
1150 w.write_all(&[6, 7]).unwrap();
1151 assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));
1152 assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
1153 assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));
1154 w.write_all(&[8, 9]).unwrap();
1155 assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
1159 fn test_read_until() {
1160 let inner: &[u8] = &[0, 1, 2, 1, 0];
1161 let mut reader = BufReader::with_capacity(2, inner);
1162 let mut v = Vec::new();
1163 reader.read_until(0, &mut v).unwrap();
1166 reader.read_until(2, &mut v).unwrap();
1167 assert_eq!(v, [1, 2]);
1169 reader.read_until(1, &mut v).unwrap();
1172 reader.read_until(8, &mut v).unwrap();
1175 reader.read_until(9, &mut v).unwrap();
1180 fn test_line_buffer_fail_flush() {
1182 struct FailFlushWriter<'a>(&'a mut Vec<u8>);
1184 impl<'a> Write for FailFlushWriter<'a> {
1185 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
1186 self.0.extend_from_slice(buf);
1189 fn flush(&mut self) -> io::Result<()> {
1190 Err(io::Error::new(io::ErrorKind::Other, "flush failed"))
1194 let mut buf = Vec::new();
1196 let mut writer = LineWriter::new(FailFlushWriter(&mut buf));
1197 let to_write = b"abc\ndef";
1198 if let Ok(written) = writer.write(to_write) {
1199 assert!(written < to_write.len(), "didn't flush on new line");
1204 assert!(buf.is_empty(), "write returned an error but wrote data");
1208 fn test_line_buffer() {
1209 let mut writer = LineWriter::new(Vec::new());
1210 writer.write(&[0]).unwrap();
1211 assert_eq!(*writer.get_ref(), []);
1212 writer.write(&[1]).unwrap();
1213 assert_eq!(*writer.get_ref(), []);
1214 writer.flush().unwrap();
1215 assert_eq!(*writer.get_ref(), [0, 1]);
1216 writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
1217 assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
1218 writer.flush().unwrap();
1219 assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
1220 writer.write(&[3, b'\n']).unwrap();
1221 assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
1225 fn test_read_line() {
1226 let in_buf: &[u8] = b"a\nb\nc";
1227 let mut reader = BufReader::with_capacity(2, in_buf);
1228 let mut s = String::new();
1229 reader.read_line(&mut s).unwrap();
1230 assert_eq!(s, "a\n");
1232 reader.read_line(&mut s).unwrap();
1233 assert_eq!(s, "b\n");
1235 reader.read_line(&mut s).unwrap();
1238 reader.read_line(&mut s).unwrap();
1244 let in_buf: &[u8] = b"a\nb\nc";
1245 let reader = BufReader::with_capacity(2, in_buf);
1246 let mut it = reader.lines();
1247 assert_eq!(it.next().unwrap().unwrap(), "a".to_string());
1248 assert_eq!(it.next().unwrap().unwrap(), "b".to_string());
1249 assert_eq!(it.next().unwrap().unwrap(), "c".to_string());
1250 assert!(it.next().is_none());
1254 fn test_short_reads() {
1255 let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
1256 let mut reader = BufReader::new(inner);
1257 let mut buf = [0, 0];
1258 assert_eq!(reader.read(&mut buf).unwrap(), 0);
1259 assert_eq!(reader.read(&mut buf).unwrap(), 1);
1260 assert_eq!(reader.read(&mut buf).unwrap(), 2);
1261 assert_eq!(reader.read(&mut buf).unwrap(), 0);
1262 assert_eq!(reader.read(&mut buf).unwrap(), 1);
1263 assert_eq!(reader.read(&mut buf).unwrap(), 0);
1264 assert_eq!(reader.read(&mut buf).unwrap(), 0);
1269 fn dont_panic_in_drop_on_panicked_flush() {
1270 struct FailFlushWriter;
1272 impl Write for FailFlushWriter {
1273 fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
1274 fn flush(&mut self) -> io::Result<()> {
1275 Err(io::Error::last_os_error())
1279 let writer = FailFlushWriter;
1280 let _writer = BufWriter::new(writer);
1282 // If writer panics *again* due to the flush error then the process will
1288 #[cfg_attr(target_os = "emscripten", ignore)]
1289 fn panic_in_write_doesnt_flush_in_drop() {
1290 static WRITES: AtomicUsize = AtomicUsize::new(0);
1294 impl Write for PanicWriter {
1295 fn write(&mut self, _: &[u8]) -> io::Result<usize> {
1296 WRITES.fetch_add(1, Ordering::SeqCst);
1299 fn flush(&mut self) -> io::Result<()> { Ok(()) }
1303 let mut writer = BufWriter::new(PanicWriter);
1304 let _ = writer.write(b"hello world");
1305 let _ = writer.flush();
1306 }).join().unwrap_err();
1308 assert_eq!(WRITES.load(Ordering::SeqCst), 1);
1312 fn bench_buffered_reader(b: &mut test::Bencher) {
1314 BufReader::new(io::empty())
1319 fn bench_buffered_writer(b: &mut test::Bencher) {
1321 BufWriter::new(io::sink())
1325 struct AcceptOneThenFail {
1330 impl Write for AcceptOneThenFail {
1331 fn write(&mut self, data: &[u8]) -> io::Result<usize> {
1333 assert_eq!(data, b"a\nb\n");
1334 self.written = true;
1337 Err(io::Error::new(io::ErrorKind::NotFound, "test"))
1341 fn flush(&mut self) -> io::Result<()> {
1342 assert!(self.written);
1343 assert!(!self.flushed);
1344 self.flushed = true;
1345 Err(io::Error::new(io::ErrorKind::Other, "test"))
1350 fn erroneous_flush_retried() {
1351 let a = AcceptOneThenFail {
1356 let mut l = LineWriter::new(a);
1357 assert_eq!(l.write(b"a\nb\na").unwrap(), 4);
1358 assert!(l.get_ref().written);
1359 assert!(l.get_ref().flushed);
1360 l.get_mut().flushed = false;
1362 assert_eq!(l.write(b"a").unwrap_err().kind(), io::ErrorKind::Other)