Struct ErrorTemplate 

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

Parsed representation of an #[error("...")] template.

Templates are represented as a sequence of literal segments and placeholders. The structure mirrors the internal representation used by formatting machinery, but keeps the slices borrowed from the original input to avoid unnecessary allocations.

Examples

use masterror_template::template::{ErrorTemplate, TemplateIdentifier};

let template = ErrorTemplate::parse("{code}: {message}").expect("parse");
let rendered = format!(
    "{}",
    template.display_with(|placeholder, f| match placeholder.identifier() {
        TemplateIdentifier::Named("code") => write!(f, "{}", 404),
        TemplateIdentifier::Named("message") => f.write_str("Not Found"),
        _ => Ok(())
    })
);

assert_eq!(rendered, "404: Not Found");

Implementations

impl<'a> ErrorTemplate<'a>

pub fn parse(source: &'a str) -> Result<Self, TemplateError>

Parses an error display template.

pub const fn source(&self) -> &'a str

Returns the original template string.

pub fn segments(&self) -> &[TemplateSegment<'a>]

Returns the parsed segments.

pub fn placeholders(&self) -> impl Iterator<Item = &TemplatePlaceholder<'a>>

Iterates over placeholder segments in order of appearance.

pub fn display_with<F>(&'a self, resolver: F) -> DisplayWith<'a, 'a, F>

where F: Fn(&TemplatePlaceholder<'a>, &mut Formatter<'_>) -> Result,

Produces a display implementation that delegates placeholder rendering to the provided resolver.

Trait Implementations

impl<'a> Clone for ErrorTemplate<'a>

fn clone(&self) -> ErrorTemplate<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ErrorTemplate<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for ErrorTemplate<'a>

fn eq(&self, other: &ErrorTemplate<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for ErrorTemplate<'a>

impl<'a> StructuralPartialEq for ErrorTemplate<'a>