library/std/src/io/buffered/bufwriter.rs - third_party/rust - Git at Google

 use crate::fmt;
 use crate::io::{
     self, Error, ErrorKind, IntoInnerError, IoSlice, Seek, SeekFrom, Write, DEFAULT_BUF_SIZE,
 };

 /// Wraps a writer and buffers its output.
 ///
 /// It can be excessively inefficient to work directly with something that
 /// implements [`Write`]. For example, every call to
 /// [`write`][`TcpStream::write`] on [`TcpStream`] results in a system call. A
 /// `BufWriter<W>` keeps an in-memory buffer of data and writes it to an underlying
 /// writer in large, infrequent batches.
 ///
 /// `BufWriter<W>` can improve the speed of programs that make *small* and
 /// *repeated* write calls to the same file or network socket. It does not
 /// help when writing very large amounts at once, or writing just one or a few
 /// times. It also provides no advantage when writing to a destination that is
 /// in memory, like a [`Vec`]<u8>`.
 ///
 /// It is critical to call [`flush`] before `BufWriter<W>` is dropped. Though
 /// dropping will attempt to flush the contents of the buffer, any errors
 /// that happen in the process of dropping will be ignored. Calling [`flush`]
 /// ensures that the buffer is empty and thus dropping will not even attempt
 /// file operations.
 ///
 /// # Examples
 ///
 /// Let's write the numbers one through ten to a [`TcpStream`]:
 ///
 /// ```no_run
 /// use std::io::prelude::*;
 /// use std::net::TcpStream;
 ///
 /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
 ///
 /// for i in 0..10 {
 ///     stream.write(&[i+1]).unwrap();
 /// }
 /// ```
 ///
 /// Because we're not buffering, we write each one in turn, incurring the
 /// overhead of a system call per byte written. We can fix this with a
 /// `BufWriter<W>`:
 ///
 /// ```no_run
 /// use std::io::prelude::*;
 /// use std::io::BufWriter;
 /// use std::net::TcpStream;
 ///
 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 ///
 /// for i in 0..10 {
 ///     stream.write(&[i+1]).unwrap();
 /// }
 /// stream.flush().unwrap();
 /// ```
 ///
 /// By wrapping the stream with a `BufWriter<W>`, these ten writes are all grouped
 /// together by the buffer and will all be written out in one system call when
 /// the `stream` is flushed.
 ///
 /// [`TcpStream::write`]: Write::write
 /// [`TcpStream`]: crate::net::TcpStream
 /// [`flush`]: Write::flush
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BufWriter<W: Write> {
     inner: Option<W>,
     buf: Vec<u8>,
     // #30888: If the inner writer panics in a call to write, we don't want to
     // write the buffered data a second time in BufWriter's destructor. This
     // flag tells the Drop impl if it should skip the flush.
     panicked: bool,
 }

 impl<W: Write> BufWriter<W> {
     /// Creates a new `BufWriter<W>` with a default buffer capacity. The default is currently 8 KB,
     /// but may change in the future.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(inner: W) -> BufWriter<W> {
         BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
     }

     /// Creates a new `BufWriter<W>` with the specified buffer capacity.
     ///
     /// # Examples
     ///
     /// Creating a buffer with a buffer of a hundred bytes.
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
     /// let mut buffer = BufWriter::with_capacity(100, stream);
     /// ```
     #[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 }
     }

     /// Send data in our local buffer into the inner writer, looping as
     /// necessary until either it's all been sent or an error occurs.
     ///
     /// Because all the data in the buffer has been reported to our owner as
     /// "successfully written" (by returning nonzero success values from
     /// `write`), any 0-length writes from `inner` must be reported as i/o
     /// errors from this method.
     pub(super) fn flush_buf(&mut self) -> io::Result<()> {
         /// Helper struct to ensure the buffer is updated after all the writes
         /// are complete. It tracks the number of written bytes and drains them
         /// all from the front of the buffer when dropped.
         struct BufGuard<'a> {
             buffer: &'a mut Vec<u8>,
             written: usize,
         }

         impl<'a> BufGuard<'a> {
             fn new(buffer: &'a mut Vec<u8>) -> Self {
                 Self { buffer, written: 0 }
             }

             /// The unwritten part of the buffer
             fn remaining(&self) -> &[u8] {
                 &self.buffer[self.written..]
             }

             /// Flag some bytes as removed from the front of the buffer
             fn consume(&mut self, amt: usize) {
                 self.written += amt;
             }

             /// true if all of the bytes have been written
             fn done(&self) -> bool {
                 self.written >= self.buffer.len()
             }
         }

         impl Drop for BufGuard<'_> {
             fn drop(&mut self) {
                 if self.written > 0 {
                     self.buffer.drain(..self.written);
                 }
             }
         }

         let mut guard = BufGuard::new(&mut self.buf);
         let inner = self.inner.as_mut().unwrap();
         while !guard.done() {
             self.panicked = true;
             let r = inner.write(guard.remaining());
             self.panicked = false;

             match r {
                 Ok(0) => {
                     return Err(Error::new(
                         ErrorKind::WriteZero,
                         "failed to write the buffered data",
                     ));
                 }
                 Ok(n) => guard.consume(n),
                 Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
                 Err(e) => return Err(e),
             }
         }
         Ok(())
     }

     /// Buffer some data without flushing it, regardless of the size of the
     /// data. Writes as much as possible without exceeding capacity. Returns
     /// the number of bytes written.
     pub(super) fn write_to_buf(&mut self, buf: &[u8]) -> usize {
         let available = self.buf.capacity() - self.buf.len();
         let amt_to_buffer = available.min(buf.len());
         self.buf.extend_from_slice(&buf[..amt_to_buffer]);
         amt_to_buffer
     }

     /// Gets a reference to the underlying writer.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // we can use reference just like buffer
     /// let reference = buffer.get_ref();
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get_ref(&self) -> &W {
         self.inner.as_ref().unwrap()
     }

     /// Gets a mutable reference to the underlying writer.
     ///
     /// It is inadvisable to directly write to the underlying writer.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // we can use reference just like buffer
     /// 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()
     }

     /// Returns a reference to the internally buffered data.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // See how many bytes are currently buffered
     /// let bytes_buffered = buf_writer.buffer().len();
     /// ```
     #[stable(feature = "bufreader_buffer", since = "1.37.0")]
     pub fn buffer(&self) -> &[u8] {
         &self.buf
     }

     /// Returns the number of bytes the internal buffer can hold without flushing.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // Check the capacity of the inner buffer
     /// let capacity = buf_writer.capacity();
     /// // Calculate how many bytes can be written without flushing
     /// let without_flush = capacity - buf_writer.buffer().len();
     /// ```
     #[stable(feature = "buffered_io_capacity", since = "1.46.0")]
     pub fn capacity(&self) -> usize {
         self.buf.capacity()
     }

     /// Unwraps this `BufWriter<W>`, returning the underlying writer.
     ///
     /// The buffer is written out before returning the writer.
     ///
     /// # Errors
     ///
     /// An [`Err`] will be returned if an error occurs while flushing the buffer.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // unwrap the TcpStream and flush the buffer
     /// let stream = buffer.into_inner().unwrap();
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
         match self.flush_buf() {
             Err(e) => Err(IntoInnerError::new(self, e)),
             Ok(()) => Ok(self.inner.take().unwrap()),
         }
     }
 }

 #[stable(feature = "rust1", since = "1.0.0")]
 impl<W: Write> Write for BufWriter<W> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         if self.buf.len() + buf.len() > self.buf.capacity() {
             self.flush_buf()?;
         }
         // FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
         if buf.len() >= self.buf.capacity() {
             self.panicked = true;
             let r = self.get_mut().write(buf);
             self.panicked = false;
             r
         } else {
             self.buf.extend_from_slice(buf);
             Ok(buf.len())
         }
     }

     fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
         // Normally, `write_all` just calls `write` in a loop. We can do better
         // by calling `self.get_mut().write_all()` directly, which avoids
         // round trips through the buffer in the event of a series of partial
         // writes in some circumstances.
         if self.buf.len() + buf.len() > self.buf.capacity() {
             self.flush_buf()?;
         }
         // FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
         if buf.len() >= self.buf.capacity() {
             self.panicked = true;
             let r = self.get_mut().write_all(buf);
             self.panicked = false;
             r
         } else {
             self.buf.extend_from_slice(buf);
             Ok(())
         }
     }

     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         let total_len = bufs.iter().map(|b| b.len()).sum::<usize>();
         if self.buf.len() + total_len > self.buf.capacity() {
             self.flush_buf()?;
         }
         // FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
         if total_len >= self.buf.capacity() {
             self.panicked = true;
             let r = self.get_mut().write_vectored(bufs);
             self.panicked = false;
             r
         } else {
             bufs.iter().for_each(|b| self.buf.extend_from_slice(b));
             Ok(total_len)
         }
     }

     fn is_write_vectored(&self) -> bool {
         self.get_ref().is_write_vectored()
     }

     fn flush(&mut self) -> io::Result<()> {
         self.flush_buf().and_then(|()| self.get_mut().flush())
     }
 }

 #[stable(feature = "rust1", since = "1.0.0")]
 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())
             .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
             .finish()
     }
 }

 #[stable(feature = "rust1", since = "1.0.0")]
 impl<W: Write + Seek> Seek for BufWriter<W> {
     /// Seek to the offset, in bytes, in the underlying writer.
     ///
     /// Seeking always writes out the internal buffer before seeking.
     fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
         self.flush_buf()?;
         self.get_mut().seek(pos)
     }
 }

 #[stable(feature = "rust1", since = "1.0.0")]
 impl<W: Write> Drop for BufWriter<W> {
     fn drop(&mut self) {
         if self.inner.is_some() && !self.panicked {
             // dtors should not panic, so we ignore a failed flush
             let _r = self.flush_buf();
         }
     }
 }
	use crate::fmt;
	use crate::io::{
	self, Error, ErrorKind, IntoInnerError, IoSlice, Seek, SeekFrom, Write, DEFAULT_BUF_SIZE,
	};

	/// Wraps a writer and buffers its output.
	///
	/// It can be excessively inefficient to work directly with something that
	/// implements [`Write`]. For example, every call to
	/// [`write`][`TcpStream::write`] on [`TcpStream`] results in a system call. A
	/// `BufWriter<W>` keeps an in-memory buffer of data and writes it to an underlying
	/// writer in large, infrequent batches.
	///
	/// `BufWriter<W>` can improve the speed of programs that make small and
	/// repeated write calls to the same file or network socket. It does not
	/// help when writing very large amounts at once, or writing just one or a few
	/// times. It also provides no advantage when writing to a destination that is
	/// in memory, like a [`Vec`]<u8>`.
	///
	/// It is critical to call [`flush`] before `BufWriter<W>` is dropped. Though
	/// dropping will attempt to flush the contents of the buffer, any errors
	/// that happen in the process of dropping will be ignored. Calling [`flush`]
	/// ensures that the buffer is empty and thus dropping will not even attempt
	/// file operations.
	///
	/// # Examples
	///
	/// Let's write the numbers one through ten to a [`TcpStream`]:
	///
	/// ```no_run
	/// use std::io::prelude::*;
	/// use std::net::TcpStream;
	///
	/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
	///
	/// for i in 0..10 {
	/// stream.write(&[i+1]).unwrap();
	/// }
	/// ```
	///
	/// Because we're not buffering, we write each one in turn, incurring the
	/// overhead of a system call per byte written. We can fix this with a
	/// `BufWriter<W>`:
	///
	/// ```no_run
	/// use std::io::prelude::*;
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// for i in 0..10 {
	/// stream.write(&[i+1]).unwrap();
	/// }
	/// stream.flush().unwrap();
	/// ```
	///
	/// By wrapping the stream with a `BufWriter<W>`, these ten writes are all grouped
	/// together by the buffer and will all be written out in one system call when
	/// the `stream` is flushed.
	///
	/// [`TcpStream::write`]: Write::write
	/// [`TcpStream`]: crate::net::TcpStream
	/// [`flush`]: Write::flush
	#[stable(feature = "rust1", since = "1.0.0")]
	pub struct BufWriter<W: Write> {
	inner: Option<W>,
	buf: Vec<u8>,
	// #30888: If the inner writer panics in a call to write, we don't want to
	// write the buffered data a second time in BufWriter's destructor. This
	// flag tells the Drop impl if it should skip the flush.
	panicked: bool,
	}

	impl<W: Write> BufWriter<W> {
	/// Creates a new `BufWriter<W>` with a default buffer capacity. The default is currently 8 KB,
	/// but may change in the future.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	/// ```
	#[stable(feature = "rust1", since = "1.0.0")]
	pub fn new(inner: W) -> BufWriter<W> {
	BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
	}

	/// Creates a new `BufWriter<W>` with the specified buffer capacity.
	///
	/// # Examples
	///
	/// Creating a buffer with a buffer of a hundred bytes.
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
	/// let mut buffer = BufWriter::with_capacity(100, stream);
	/// ```
	#[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 }
	}

	/// Send data in our local buffer into the inner writer, looping as
	/// necessary until either it's all been sent or an error occurs.
	///
	/// Because all the data in the buffer has been reported to our owner as
	/// "successfully written" (by returning nonzero success values from
	/// `write`), any 0-length writes from `inner` must be reported as i/o
	/// errors from this method.
	pub(super) fn flush_buf(&mut self) -> io::Result<()> {
	/// Helper struct to ensure the buffer is updated after all the writes
	/// are complete. It tracks the number of written bytes and drains them
	/// all from the front of the buffer when dropped.
	struct BufGuard<'a> {
	buffer: &'a mut Vec<u8>,
	written: usize,
	}

	impl<'a> BufGuard<'a> {
	fn new(buffer: &'a mut Vec<u8>) -> Self {
	Self { buffer, written: 0 }
	}

	/// The unwritten part of the buffer
	fn remaining(&self) -> &[u8] {
	&self.buffer[self.written..]
	}

	/// Flag some bytes as removed from the front of the buffer
	fn consume(&mut self, amt: usize) {
	self.written += amt;
	}

	/// true if all of the bytes have been written
	fn done(&self) -> bool {
	self.written >= self.buffer.len()
	}
	}

	impl Drop for BufGuard<'_> {
	fn drop(&mut self) {
	if self.written > 0 {
	self.buffer.drain(..self.written);
	}
	}
	}

	let mut guard = BufGuard::new(&mut self.buf);
	let inner = self.inner.as_mut().unwrap();
	while !guard.done() {
	self.panicked = true;
	let r = inner.write(guard.remaining());
	self.panicked = false;

	match r {
	Ok(0) => {
	return Err(Error::new(
	ErrorKind::WriteZero,
	"failed to write the buffered data",
	));
	}
	Ok(n) => guard.consume(n),
	Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
	Err(e) => return Err(e),
	}
	}
	Ok(())
	}

	/// Buffer some data without flushing it, regardless of the size of the
	/// data. Writes as much as possible without exceeding capacity. Returns
	/// the number of bytes written.
	pub(super) fn write_to_buf(&mut self, buf: &[u8]) -> usize {
	let available = self.buf.capacity() - self.buf.len();
	let amt_to_buffer = available.min(buf.len());
	self.buf.extend_from_slice(&buf[..amt_to_buffer]);
	amt_to_buffer
	}

	/// Gets a reference to the underlying writer.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// // we can use reference just like buffer
	/// let reference = buffer.get_ref();
	/// ```
	#[stable(feature = "rust1", since = "1.0.0")]
	pub fn get_ref(&self) -> &W {
	self.inner.as_ref().unwrap()
	}

	/// Gets a mutable reference to the underlying writer.
	///
	/// It is inadvisable to directly write to the underlying writer.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// // we can use reference just like buffer
	/// 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()
	}

	/// Returns a reference to the internally buffered data.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// // See how many bytes are currently buffered
	/// let bytes_buffered = buf_writer.buffer().len();
	/// ```
	#[stable(feature = "bufreader_buffer", since = "1.37.0")]
	pub fn buffer(&self) -> &[u8] {
	&self.buf
	}

	/// Returns the number of bytes the internal buffer can hold without flushing.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// // Check the capacity of the inner buffer
	/// let capacity = buf_writer.capacity();
	/// // Calculate how many bytes can be written without flushing
	/// let without_flush = capacity - buf_writer.buffer().len();
	/// ```
	#[stable(feature = "buffered_io_capacity", since = "1.46.0")]
	pub fn capacity(&self) -> usize {
	self.buf.capacity()
	}

	/// Unwraps this `BufWriter<W>`, returning the underlying writer.
	///
	/// The buffer is written out before returning the writer.
	///
	/// # Errors
	///
	/// An [`Err`] will be returned if an error occurs while flushing the buffer.
	///
	/// # Examples
	///
	/// ```no_run
	/// use std::io::BufWriter;
	/// use std::net::TcpStream;
	///
	/// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
	///
	/// // unwrap the TcpStream and flush the buffer
	/// let stream = buffer.into_inner().unwrap();
	/// ```
	#[stable(feature = "rust1", since = "1.0.0")]
	pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
	match self.flush_buf() {
	Err(e) => Err(IntoInnerError::new(self, e)),
	Ok(()) => Ok(self.inner.take().unwrap()),
	}
	}
	}

	#[stable(feature = "rust1", since = "1.0.0")]
	impl<W: Write> Write for BufWriter<W> {
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	if self.buf.len() + buf.len() > self.buf.capacity() {
	self.flush_buf()?;
	}
	// FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
	if buf.len() >= self.buf.capacity() {
	self.panicked = true;
	let r = self.get_mut().write(buf);
	self.panicked = false;
	r
	} else {
	self.buf.extend_from_slice(buf);
	Ok(buf.len())
	}
	}

	fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
	// Normally, `write_all` just calls `write` in a loop. We can do better
	// by calling `self.get_mut().write_all()` directly, which avoids
	// round trips through the buffer in the event of a series of partial
	// writes in some circumstances.
	if self.buf.len() + buf.len() > self.buf.capacity() {
	self.flush_buf()?;
	}
	// FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
	if buf.len() >= self.buf.capacity() {
	self.panicked = true;
	let r = self.get_mut().write_all(buf);
	self.panicked = false;
	r
	} else {
	self.buf.extend_from_slice(buf);
	Ok(())
	}
	}

	fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
	let total_len = bufs.iter().map(\|b\| b.len()).sum::<usize>();
	if self.buf.len() + total_len > self.buf.capacity() {
	self.flush_buf()?;
	}
	// FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
	if total_len >= self.buf.capacity() {
	self.panicked = true;
	let r = self.get_mut().write_vectored(bufs);
	self.panicked = false;
	r
	} else {
	bufs.iter().for_each(\|b\| self.buf.extend_from_slice(b));
	Ok(total_len)
	}
	}

	fn is_write_vectored(&self) -> bool {
	self.get_ref().is_write_vectored()
	}

	fn flush(&mut self) -> io::Result<()> {
	self.flush_buf().and_then(\|()\| self.get_mut().flush())
	}
	}

	#[stable(feature = "rust1", since = "1.0.0")]
	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())
	.field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
	.finish()
	}
	}

	#[stable(feature = "rust1", since = "1.0.0")]
	impl<W: Write + Seek> Seek for BufWriter<W> {
	/// Seek to the offset, in bytes, in the underlying writer.
	///
	/// Seeking always writes out the internal buffer before seeking.
	fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
	self.flush_buf()?;
	self.get_mut().seek(pos)
	}
	}

	#[stable(feature = "rust1", since = "1.0.0")]
	impl<W: Write> Drop for BufWriter<W> {
	fn drop(&mut self) {
	if self.inner.is_some() && !self.panicked {
	// dtors should not panic, so we ignore a failed flush
	let _r = self.flush_buf();
	}
	}
	}