Struct Writer

pub struct Writer<'a> { /* private fields */ }

Writer implements buffering for an std::io::Write object. If an error occurs writing to a Writer, no more data will be accepted and all subsequent writes, and flush, will return the error. After all data has been written, the client should call the flush method to guarantee all data has been forwarded to the underlying std::io::Write.

Consider using native Rust std::io::BufWriter.

Implementations

impl<'a> Writer<'a>

pub fn new(w: &'a mut dyn Write) -> Self

new returns a new Writer whose buffer has the default size.

Examples found in repository

examples/bufio-writer.rs (line 17)

fn example_writer() -> std::io::Result<()> {
    let stdout = std::io::stdout();
    let mut stdout_lock = stdout.lock();
    let mut w = bufio::Writer::new(&mut stdout_lock);
    w.write_all(b"Hello, ")?;
    w.write_all(b"world!")?;
    w.flush()?; // Don't forget to flush!
    Ok(())
}

pub fn new_size(w: &'a mut dyn Write, size: usize) -> Self

new_size returns a new Writer whose buffer has at least the specified size.

pub fn size(&self) -> usize

size returns the size of the underlying buffer in bytes.

pub fn reset(&mut self, w: &'a mut dyn Write)

reset discards any unflushed buffered data, clears any error, and resets b to write its output to w.

pub fn available(&self) -> usize

pub fn write_byte(&mut self, c: u8) -> Result<()>

write_byte writes a single byte.

pub fn write_string(&mut self, s: &str) -> Result<usize>

write_string writes a string. It returns the number of bytes written.

Trait Implementations

impl Write for Writer<'_>

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

Write writes the contents of p into the buffer. It returns the number of bytes written.

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

flush writes any buffered data to the underlying std::io::Write.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

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

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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.