Trait writeable::Writeable

source · [−]
pub trait Writeable {
    fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result { ... }
    fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> Result { ... }
    fn write_len(&self) -> LengthHint { ... }
    fn write_to_string(&self) -> Cow<'_, str> { ... }
}
Expand description

Writeable is an alternative to std::fmt::Display with the addition of a length function.

Provided Methods

Writes bytes to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.

Returns a hint for the number of bytes that will be written to the sink.

Override this method if it can be computed quickly.

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster.

The default impl allocates an owned String. However, if it is possible to return a borrowed string, overwrite this method to return a Cow::Borrowed.

To remove the Cow wrapper, call .into_owned().

Examples

Inspect a Writeable before writing it to the sink:

use writeable::Writeable;
use core::fmt::{Write, Result};

fn write_if_ascii<W, S>(w: &W, sink: &mut S) -> Result
where
    W: Writeable + ?Sized,
    S: Write + ?Sized,
{
    let s = w.write_to_string();
    if s.is_ascii() {
        sink.write_str(&s)
    } else {
        Ok(())
    }
}

Convert the Writeable into a fully owned String:

use writeable::Writeable;

fn make_string(w: &impl Writeable) -> String {
    w.write_to_string().into_owned()
}

Implementations on Foreign Types

Returns a borrowed str.

Examples
use writeable::Writeable;
use std::borrow::Cow;

let cow = "foo".write_to_string();
assert!(matches!(cow, Cow::Borrowed(_)));

Implementors