Struct ParsedFmt

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

Preparsed formatting terms.

This is faster if you will be using the same format string again and again with different inputs.

use runtime_format::{FormatArgs, FormatKey, FormatKeyError, ParsedFmt};
use core::fmt;
impl FormatKey for DateTime {
    fn fmt(&self, key: &str, f: &mut fmt::Formatter<'_>) -> Result<(), FormatKeyError> {
         // ...
    }
}

let now = DateTime::now();
let fmt = ParsedFmt::new("{month} {day} {year} {hours}:{minutes}:{seconds}").unwrap();
let args = FormatArgs::new(&fmt, &now);
let expected = "Jan 25 2023 16:27:53";
assert_eq!(args.to_string(), expected);

Implementations

impl<'a> ParsedFmt<'a>

pub fn new(s: &'a str) -> Result<Self, FormatError<'a>>

Parse the given format string.

Errors

If the string could not be parsed, or there is a key that is unacceptable.

pub fn keys(&self) -> impl Iterator<Item = &str>

Return the keys that will be used when formatting.

let fmt = "Hello, {recipient}. Hope you are having a nice {time_descriptor}.";
let parsed = ParsedFmt::new(fmt).unwrap();
let keys: Vec<_> = parsed.keys().collect();
assert_eq!(keys, ["recipient", "time_descriptor"]);

pub fn with_args<'fs, 'fk, F: FormatKey>( &'fs self, fmt: &'fk F, ) -> FormatArgs<'fs, 'fk, Self, F>

Combine this parsed format with the given values into a FormatArgs

Trait Implementations

impl Debug for ParsedFmt<'_>

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

Formats the value using the given formatter.

impl<'a> FromIterator<ParseSegment<'a>> for ParsedFmt<'a>

fn from_iter<T: IntoIterator<Item = ParseSegment<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> ToFormatParser<'a> for ParsedFmt<'a>

type Parser = Copied<Iter<'a, ParseSegment<'a>>>

The Parser type that returns the ParseSegments

fn to_parser(&'a self) -> Self::Parser

Turn this value into the parser

fn unparsed(_: Self::Parser) -> &'a str

Get the unparsed str from this parser. Used to determine if there was an error while parsing.

impl<'a> TryFrom<&'a str> for ParsedFmt<'a>

type Error = FormatError<'a>

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<Self, Self::Error>

Performs the conversion.