Trait sp_std::fmt::Write1.0.0[−][src]

pub trait Write {
    pub fn write_str(&mut self, s: &str) -> Result<(), Error>;

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

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

A trait for writing or formatting into Unicode-accepting buffers or streams.

This trait only accepts UTF-8–encoded data and is not flushable. If you only want to accept Unicode and you don’t need flushing, you should implement this trait; otherwise you should implement std::io::Write.

Required methods

pub fn write_str(&mut self, s: &str) -> Result<(), Error>[src]

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

This method can only succeed if the entire string slice was successfully written, and this method will not return until all data has been written or an error occurs.

Errors

This function will return an instance of Error on error.

Examples

use std::fmt::{Error, Write};

fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
    f.write_str(s)
}

let mut buf = String::new();
writer(&mut buf, "hola").unwrap();
assert_eq!(&buf, "hola");
Loading content...

Provided methods

pub fn write_char(&mut self, c: char) -> Result<(), Error>1.1.0[src]

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

A single char may be encoded as more than one byte. This method can only succeed if the entire byte sequence was successfully written, and this method will not return until all data has been written or an error occurs.

Errors

This function will return an instance of Error on error.

Examples

use std::fmt::{Error, Write};

fn writer<W: Write>(f: &mut W, c: char) -> Result<(), Error> {
    f.write_char(c)
}

let mut buf = String::new();
writer(&mut buf, 'a').unwrap();
writer(&mut buf, 'b').unwrap();
assert_eq!(&buf, "ab");

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

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

This method should generally not be invoked manually, but rather through the write! macro itself.

Examples

use std::fmt::{Error, Write};

fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
    f.write_fmt(format_args!("{}", s))
}

let mut buf = String::new();
writer(&mut buf, "world").unwrap();
assert_eq!(&buf, "world");
Loading content...

Implementations on Foreign Types

impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, [src]

impl Write for String[src]

Loading content...

Implementors

impl Write for Writer[src]

impl<'_> Write for Formatter<'_>1.2.0[src]

Loading content...