strfmt 0.1.6

strfmt: rust library for formatting dynamic strings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

//! strfmt crate

use std::fmt;
use std::fmt::Write;
use std::collections::HashMap;
use std::string::String;

#[cfg(test)]
mod tests;
mod types;
mod formatter;
mod fmtstr;

#[macro_use]
mod fmtnum;

pub use types::{Result, FmtError, Alignment, Sign};
pub use fmtstr::strfmt_map;
pub use formatter::Formatter;

// u128 & i128 unstable (see https://github.com/rust-lang/rust/issues/35118)
fmtint!(u8 i8 u16 i16 u32 i32 u64 i64 usize isize);
fmtfloat!(f32 f64);

/// Rust-style format a string given a `HashMap` of the variables.
pub fn strfmt<T: fmt::Display>(fmtstr: &str, vars: &HashMap<String, T>) -> Result<String> {
    let formatter = |mut fmt: Formatter| {
        let v = match vars.get(fmt.key) {
            Some(v) => v,
            None => {
                let mut msg = String::new();
                write!(msg, "Invalid key: {}", fmt.key).unwrap();
                return Err(FmtError::KeyError(msg));
            },
        };
        fmt.str(v.to_string().as_str())
    };
    strfmt_map(fmtstr, &formatter)
}

pub trait Format {
    fn format<D: fmt::Display>(&self, vars: &HashMap<String, D>) -> Result<String>;
}

impl Format for String {
    fn format<D: fmt::Display>(&self, vars: &HashMap<String, D>) -> Result<String> {
        strfmt(self.as_str(), vars)
    }
}

impl Format for str {
    fn format<D: fmt::Display>(&self, vars: &HashMap<String, D>) -> Result<String> {
        strfmt(self, vars)
    }
}