Struct FmtToIo 

pub struct FmtToIo<W> {
    pub error: Option<Error>,
    /* private fields */
}

Adapter that enables writing through a fmt::Write to an underlying io::Write.

Examples

use io_adapters::WriteExtension;

let mut output1 = String::new();
let mut output2 = [0u8; 13]; // Or io::stdout() for example

my_common_writer(&mut output1).unwrap();
my_common_writer(&mut output2.as_mut_slice().write_adapter()).unwrap();

fn my_common_writer(mut output: impl fmt::Write) -> fmt::Result {
    write!(output, "Hello, World!")
}

assert_eq!(&output1, "Hello, World!");
assert_eq!(str::from_utf8(&output2).unwrap(), "Hello, World!");

Error handling

Error handling is unpleasant with this adapter due to the fmt::Write interface returning a stateless fmt::Error rather than an io::Error. Here is the suggested usage when unwrap doesn’t cut it:

let mut adapter = io::stdout().write_adapter();
match (conv(&mut adapter), adapter.error) {
  (Ok(()), None) => {}
  (Ok(()), Some(_)) => unreachable!(),
  (Err(fmt::Error), None) => { /* Handle format error. */ }
  (Err(fmt::Error), Some(e)) => { /* Handle I/O error. */ }
}

fn conv(output: impl fmt::Write) -> fmt::Result

Fields

error: Option<Error>

Trait Implementations

impl<W: Debug> Debug for FmtToIo<W>

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

Formats the value using the given formatter.

impl<W: Write> Write for FmtToIo<W>

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

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

Glue for usage of the write! macro with implementors of this trait.