Struct Template 

pub struct Template { /* private fields */ }

An owned, parsed format string that can be rendered many times with different arguments.

Examples

use formatx::Template;

let template = Template::new("{name} scored {score:.1}%").unwrap();
assert!(template.contains("name"));

let result = template.render()
    .named("name", &"Alice")
    .named("score", &95.678)
    .finish()
    .unwrap();
assert_eq!(result, "Alice scored 95.7%");

Implementations

impl Template

pub fn new<S: Into<String>>(source: S) -> Result<Self, Error>

Parse a format string into a reusable template.

Returns Err if the format string is malformed (unmatched braces, invalid specs, etc.).

Examples found in repository

examples/struct.rs (line 32)

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 render(&self) -> Renderer<'_>

Create a Renderer to format this template with arguments.

The renderer collects arguments and produces the formatted output.

Examples found in repository

examples/struct.rs (line 33)

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 contains(&self, name: &str) -> bool

Returns true if the template contains a placeholder with the given name.

pub fn placeholders(&self) -> Vec<&str>

Returns the names of all named placeholders in the template.

pub fn source(&self) -> &str

Returns the original format string.

Trait Implementations

impl Debug for Template

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

Formats the value using the given formatter.

impl Display for Template

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

Formats the value using the given formatter.

impl FromStr for Template

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.