Struct buffer_redux::LineWriter

pub struct LineWriter<W: Write>(/* private fields */);

A drop-in replacement for std::io::LineWriter with more functionality.

This is, in fact, only a thin wrapper around BufWriter<W, policy::FlushOnNewline>, which demonstrates the power of custom WriterPolicy implementations.

Implementations

impl<W: Write> LineWriter<W>

pub fn new(inner: W) -> Self

Wrap inner with the default buffer capacity.

pub fn with_capacity(cap: usize, inner: W) -> Self

Wrap inner with the given buffer capacity.

pub fn new_ringbuf(inner: W) -> Self

Wrap inner with the default buffer capacity using a ringbuffer.

pub fn with_capacity_ringbuf(cap: usize, inner: W) -> Self

Wrap inner with the given buffer capacity using a ringbuffer.

pub fn with_buffer(buf: Buffer, inner: W) -> LineWriter<W>

Wrap inner with an existing Buffer instance.

Note

Does not clear the buffer first! If there is data already in the buffer it will be written out on the next flush!

pub fn get_ref(&self) -> &W

Get a reference to the inner writer.

pub fn get_mut(&mut self) -> &mut W

Get a mutable reference to the inner writer.

Note

If the buffer has not been flushed, writing directly to the inner type will cause data inconsistency.

pub fn capacity(&self) -> usize

Get the capacity of the inner buffer.

pub fn buf_len(&self) -> usize

Get the number of bytes currently in the buffer.

pub fn reserve(&mut self, additional: usize)

Ensure enough space in the buffer for at least additional bytes. May not be quite exact due to implementation details of the buffer’s allocator.

pub fn into_inner(self) -> Result<W, IntoInnerError<Self>>

Flush the buffer and unwrap, returning the inner writer on success, or a type wrapping self plus the error otherwise.

pub fn into_inner_with_err(self) -> (W, Option<Error>)

Flush the buffer and unwrap, returning the inner writer and any error encountered during flushing.

pub fn into_inner_with_buf(self) -> (W, Buffer)

Consume self and return both the underlying writer and the buffer.

Trait Implementations

impl<W: Write + Debug> Debug for LineWriter<W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W: Write> Write for LineWriter<W>

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

Write a buffer into this writer, returning how many bytes were written.

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

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

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, fmt: 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.