Struct Replace 

pub struct Replace<A, B, C> {
    pub source: A,
    pub needle: B,
    pub replacement: C,
}

A Writeable adapter that replaces occurrences of a needle with a replacement.

This adapter performs the replacement in a streaming fashion during write_to, requiring zero allocations.

Examples

use writeable::adapters::Replace;
use writeable::assert_writeable_eq;
use writeable::concat_writeable;

let source = concat_writeable!("I 💖 🦀", " and 🦀 loves me!");
let replace = Replace {
    source,
    needle: "🦀",
    replacement: "Rust",
};

assert_writeable_eq!(replace, "I 💖 Rust and Rust loves me!");

Fields

source: A

The source writeable.

needle: B

The needle to search for.

replacement: C

The replacement writeable.

Implementations

impl<'a, A: Writeable, C: Writeable> Replace<A, &'a str, C>

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient Writeable implementation.

If you don’t need an allocated String, but e.g. need to write this to some sink, it is more efficient to use Writeable directly.

Trait Implementations

impl<A: Debug, B: Debug, C: Debug> Debug for Replace<A, B, C>

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

Formats the value using the given formatter.

impl<'a, A: Writeable, C: Writeable> Display for Replace<A, &'a str, C>

This trait is implemented for compatibility with fmt!. To create a string, Writeable::write_to_string is usually more efficient.

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

Formats the value using the given formatter.

impl<A, C> Writeable for Replace<A, &str, C>

where A: Writeable, C: Writeable,

fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result

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

fn writeable_length_hint(&self) -> LengthHint

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

fn write_to_parts<S: PartsWrite + ?Sized>(&self, sink: &mut S) -> Result

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.

fn writeable_borrow(&self) -> Option<&str>

Returns a &str that matches the output of write_to, if possible.

fn write_to_string(&self) -> Cow<'_, str>

Creates a new string with the data from this Writeable.