Struct Renderer 

pub struct Renderer<'a> { /* private fields */ }

A builder for rendering a Template with arguments.

Examples

use formatx::Template;

let template = Template::new("{} + {} = {}").unwrap();
let result = template.render()
    .arg(&1)
    .arg(&2)
    .arg(&3)
    .finish()
    .unwrap();
assert_eq!(result, "1 + 2 = 3");

Implementations

impl<'a> Renderer<'a>

pub fn arg(&mut self, value: &'a (impl Display + Debug)) -> &mut Self

Add a positional argument.

pub fn named( &mut self, name: &'a str, value: &'a (impl Display + Debug), ) -> &mut Self

Add a named argument.

Examples found in repository

examples/struct.rs (line 34)

fn main() {
    let origin = Point { x: 0.0, y: 0.0 };
    let target = Point { x: 3.5, y: -2.1 };

    // Display
    let result = formatx!("From {} to {}", origin, target).unwrap();
    println!("{result}");

    // Debug
    let result = formatx!("Debug: {:?}", origin).unwrap();
    println!("{result}");

    // Pretty debug
    let result = formatx!("Pretty: {:#?}", origin).unwrap();
    println!("{result}");

    // Template reuse
    let template = formatx::Template::new("Point {name}: {point}").unwrap();
    let r1 = template.render()
        .named("name", &"Origin")
        .named("point", &origin)
        .finish()
        .unwrap();
    let r2 = template.render()
        .named("name", &"Target")
        .named("point", &target)
        .finish()
        .unwrap();
    println!("{r1}");
    println!("{r2}");
}

pub fn finish(&self) -> Result<String, Error>

Strict: produce the formatted output.

Returns Err(Error::MissingArgument) if any placeholder references an argument that was not provided.

Examples found in repository

examples/struct.rs (line 36)

fn main() {
    let origin = Point { x: 0.0, y: 0.0 };
    let target = Point { x: 3.5, y: -2.1 };

    // Display
    let result = formatx!("From {} to {}", origin, target).unwrap();
    println!("{result}");

    // Debug
    let result = formatx!("Debug: {:?}", origin).unwrap();
    println!("{result}");

    // Pretty debug
    let result = formatx!("Pretty: {:#?}", origin).unwrap();
    println!("{result}");

    // Template reuse
    let template = formatx::Template::new("Point {name}: {point}").unwrap();
    let r1 = template.render()
        .named("name", &"Origin")
        .named("point", &origin)
        .finish()
        .unwrap();
    let r2 = template.render()
        .named("name", &"Target")
        .named("point", &target)
        .finish()
        .unwrap();
    println!("{r1}");
    println!("{r2}");
}

pub fn finish_lenient(&self) -> Result<String, Error>

Lenient: produce the formatted output.

Missing arguments are replaced with an empty string "" instead of producing an error.