# Struct std::io::BufWriter [−] [src]

    pub struct BufWriter<W: Write> {
        // some fields omitted
    }

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` on `TcpStream` results in a system call. A `BufWriter` keeps an in-memory buffer of data and writes it to an underlying writer in large, infrequent batches.

The buffer will be written out when the writer is dropped.

# Examples

Let's write the numbers one through ten to a `TcpStream`:

fn main() { use std::io::prelude::*; use std::net::TcpStream; let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap(); for i in 1..10 { stream.write(&[i]).unwrap(); } }

    use std::io::prelude::*;
    use std::net::TcpStream;

    let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();

    for i in 1..10 {
        stream.write(&[i]).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`:

fn main() { 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 1..10 { stream.write(&[i]).unwrap(); } }

    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 1..10 {
        stream.write(&[i]).unwrap();
    }

By wrapping the stream with a `BufWriter`, these ten writes are all grouped together by the buffer, and will all be written out in one system call when the `stream` is dropped.

## Methods

### `impl<W: Write> BufWriter<W>`

#### `fn new(inner: W) -> BufWriter<W>`

Creates a new `BufWriter` with a default buffer capacity.

# Examples

fn main() { use std::io::BufWriter; use std::net::TcpStream; let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap()); }

    use std::io::BufWriter;
    use std::net::TcpStream;

    let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());

#### `fn with_capacity(cap: usize, inner: W) -> BufWriter<W>`

Creates a new `BufWriter` with the specified buffer capacity.

# Examples

Creating a buffer with a buffer of a hundred bytes.

fn main() { 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); }

    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);

#### `fn get_ref(&self) -> &W`

Gets a reference to the underlying writer.

# Examples

fn main() { 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(); }

    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();

#### `fn get_mut(&mut self) -> &mut W`

Gets a mutable reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

# Examples

fn main() { 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(); }

    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();

#### `fn into_inner(self) -> Result<W, IntoInnerError<BufWriter<W>>>`

Unwraps this `BufWriter`, returning the underlying writer.

The buffer is written out before returning the writer.

# Examples

fn main() { 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(); }

    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();

## Trait Implementations

### `impl<W: Write> Write for BufWriter<W>`

#### `fn write(&mut self, buf: &[u8]) -> Result<usize>`

#### `fn flush(&mut self) -> Result<()>`

#### `fn write_all(&mut self, buf: &[u8]) -> Result<()>`

#### `fn write_fmt(&mut self, fmt: Arguments) -> Result<()>`

#### `fn by_ref(&mut self) -> &mut Self where Self: Sized`

#### `fn broadcast<W: Write>(self, other: W) -> Broadcast<Self, W> where Self: Sized`

### `impl<W: Write> Debug for BufWriter<W> where W: Debug`

#### `fn fmt(&self, fmt: &mut Formatter) -> Result`

### `impl<W: Write + Seek> Seek for BufWriter<W>`

#### `fn seek(&mut self, pos: SeekFrom) -> Result<u64>`

### `impl<W: Write> Drop for BufWriter<W>`

#### `fn drop(&mut self)`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)