# Struct ethcore_util::standard::io::BufWriter 1.0.0 [−] [src]

    pub struct BufWriter<W> where W: Write { /* 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`:

    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`:

    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> BufWriter<W> where W: Write`

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

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

# Examples

    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.

    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

    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

    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

    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 for BufWriter<W> where W: Write`

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

Write a buffer into this object, returning how many bytes were written. Read more

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

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

Attempts to write an entire buffer into this write. Read more

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

Writes a formatted string into this writer, returning any error encountered. Read more

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

Creates a "by reference" adaptor for this instance of `Write`. Read more

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

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

Formats the value using the given formatter.

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

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

Seek to the offset, in bytes, in the underlying writer.

Seeking always writes out the internal buffer before seeking.

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

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

A method called when the value goes out of scope. Read more

# 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
+
  Collapse/expand all sections

## 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` or `* -> vec`)