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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

macro_rules! fmtint {
    ($($t:ident)*) => ($(
        #[allow(unused_comparisons)]
        impl<'a, 'b> Formatter<'a, 'b> {
            pub fn $t(&mut self, x: $t) -> Result<()> {
                let ty = match self.ty() {
                    None => ' ',
                    Some(c) => c,
                };

                if !self.is_int_type() {
                    let mut msg = String::new();
                    write!(msg, "Unknown format code {:?} for type", ty).unwrap();
                    return Err(FmtError::TypeError(msg));
                }

                if self.precision() != None {
                    return Err(FmtError::TypeError("precision not allowed for integers".to_string()));
                }

                if self.thousands() {
                    return Err(FmtError::Invalid("thousands specifier not yet supported".to_string()));
                }

                if self.fill() == '0' && self.align() == Alignment::Right {
                    return Err(FmtError::Invalid("sign aware 0 padding not yet supported".to_string()));
                }

                let mut s = String::new();

                if x >= 0 && self.sign_plus() {
                    self.write_str("+").unwrap();
                }

                if self.alternate() {
                    match ty {
                        'b' => self.write_str("0b").unwrap(),
                        'o' => self.write_str("0o").unwrap(),
                        'x' | 'X' => self.write_str("0x").unwrap(),
                        _ => {
                            let mut msg = String::new();
                            write!(msg, "alternate ('#') cannot be used with type {:?}", ty).unwrap();
                            return Err(FmtError::Invalid(msg));
                        }
                    }
                }

                match ty {
                    ' ' => write!(s, "{}", x).unwrap(),
                    'b' => write!(s, "{:b}", x).unwrap(),
                    'o' => write!(s, "{:o}", x).unwrap(),
                    'x' => write!(s, "{:x}", x).unwrap(),
                    'X' => write!(s, "{:X}", x).unwrap(),
                    _ => unreachable!(),
                }

                self.str_unchecked(s.as_str())
            }
    })*)
}

macro_rules! fmtfloat {
    ($($t:ident)*) => ($(
        impl<'a, 'b> Formatter<'a, 'b> {
            pub fn $t(&mut self, x: $t) -> Result<()> {
                let ty = match self.ty() {
                    None => 'f',
                    Some(c) => c,
                };

                if !self.is_float_type() {
                    let mut msg = String::new();
                    write!(msg, "Unknown format code {:?} for type", ty).unwrap();
                    return Err(FmtError::TypeError(msg));
                }

                if self.alternate() {
                    return Err(FmtError::TypeError("Alternate form (#) not allowed for floats".to_string()));
                }

                if self.thousands() {
                    return Err(FmtError::Invalid("thousands specifier not yet supported".to_string()));
                }

                if self.fill() == '0' && self.align() == Alignment::Right {
                    return Err(FmtError::Invalid("sign aware 0 padding not yet supported".to_string()));
                }

                let mut s = String::new();

                if x >= (0 as $t) && self.sign_plus() {
                    self.write_str("+").unwrap();
                }

                match self.precision() {
                    None => {
                        match ty {
                            'f' => write!(s, "{}", x).unwrap(),
                            'e' => write!(s, "{:e}", x).unwrap(),
                            'E' => write!(s, "{:E}", x).unwrap(),
                            _ => unreachable!(),
                        }
                    }
                    Some(p) => {
                        match ty {
                            'f' => write!(s, "{:.*}", p, x).unwrap(),
                            'e' => write!(s, "{:.*e}", p, x).unwrap(),
                            'E' => write!(s, "{:.*E}", p, x).unwrap(),
                            _ => unreachable!(),
                        }
                    }
                }

                let prev_prec = self.precision();
                self.set_precision(None);
                let out = self.str_unchecked(s.as_str());
                self.set_precision(prev_prec);
                out
            }
        })*)
}