Struct IoWriter 

pub struct IoWriter<F1, F2>(/* private fields */);

A writer that uses write_bytes and has both write and flush methods.

It calls write_bytes for each formatted chunk like the FmtWriter, but provides write and flush methods that allows you to use BufWriter, LineWriter etc.

Write function can return either (), usize, for<E> Result<(), E> or for<E> Result<usize, E>.

The usize itself or in Result indicates how many bytes were written. write_fmt method that is used by write! and writeln! will continuously call write until there is no more data to be written or a non-ErrorKind::Interrupted kind is returned.

Flush function can return either () or [for<E> Result<(), E>].

Panics

Writer panics if the write function returns Result::Err.

Implementations

impl<F1, F2> IoWriter<F1, F2>

where F1: WriteStr, F2: Flush,

pub fn new(write: F1, flush: F2) -> Self

Creates a new IoWriter from an object that implements WriteBytes and object that implements Flush.

impl<F1> IoWriter<F1, ()>

where F1: WriteStr,

pub fn from_closure<F, Ts>(closure: F) -> Self

where F: IntoWriteFn<Ts, WriteFn = F1>,

Creates a new IoWriter with a WriteBytes wrapper deduced with IntoWriteFn by the closure signature and constructed from it.

impl<F1> IoWriter<F1, ()>

where Self: Write,

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

Writes a formatted string into this writer.

This method is primarily used to interface with the format_args! macro, but it is rare that this should explicitly be called. The write! macro should be favored to invoke this method instead.

Trait Implementations

impl<F1: Clone, F2: Clone> Clone for IoWriter<F1, F2>

fn clone(&self) -> IoWriter<F1, F2>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F1: Debug, F2: Debug> Debug for IoWriter<F1, F2>

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

Formats the value using the given formatter.

impl<F1, F2> Flush for IoWriter<F1, F2>

where F2: Flush, F2::Output: ExpectIoFlushResult,

type Output = Result<(), Error>

The resulting type after flushing.

fn flush(&mut self) -> Self::Output

Performs flush.

impl<F1: PartialEq, F2: PartialEq> PartialEq for IoWriter<F1, F2>

fn eq(&self, other: &IoWriter<F1, F2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F1, F2> Write for IoWriter<F1, F2>

where Self: WriteBytes<Output = Result<usize>> + Flush<Output = Result<()>>,

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

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

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

Flushes 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, 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.

impl<F1, F2> WriteBytes for IoWriter<F1, F2>

where F1: WriteBytes, F1::Output: ExpectIoWriteResult,

type Output = Result<usize, Error>

The resulting type after writing.

fn write_bytes(&mut self, buf: &[u8]) -> Self::Output

Performs byte writing.

impl<F1: Copy, F2: Copy> Copy for IoWriter<F1, F2>

impl<F1: Eq, F2: Eq> Eq for IoWriter<F1, F2>

impl<F1, F2> StructuralPartialEq for IoWriter<F1, F2>