fmt-utils 0.1.0

Various utilities for use with std::fmt::Display and fast_fmt::Fmt
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

/// Do not use this if you already have a buffer you can use.
/// See also: [`fmt_to_cleared_string`]
pub fn fmt_to_new_string<V, S>(value: V, strategy: &S) -> String
where
    V: fast_fmt::Fmt<S>,
{
    let mut buf = String::new();
    value.fmt(&mut buf, strategy).unwrap(); // should be infallible
    buf
}

pub fn fmt_to_cleared_string<'a, V, S>(mut buf: &'a mut String, value: V, strategy: &S) -> &'a str
where
    V: fast_fmt::Fmt<S>,
{
    buf.clear();
    value.fmt(&mut buf, strategy).unwrap(); // should be infallible
    buf
}

/// ```
/// use fmt_utils::fast_fmt::{Separated, fmt_to_cleared_string};
///
/// let mut buf = String::new();
///
/// assert_eq!(fmt_to_cleared_string(&mut buf, Separated { sep: ',', iter: &[] as &[char] }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Separated { sep: ',', iter: &['a'] }, &fast_fmt::Display), "a");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Separated { sep: ',', iter: &['a', 'b'] }, &fast_fmt::Display), "a,b");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Separated { sep: ',', iter: &['a', 'b', 'c'] }, &fast_fmt::Display), "a,b,c");
/// ```
#[derive(Copy, Clone, Debug)]
pub struct Separated<Sep, Iter>
where
    Iter: Copy + IntoIterator,
{
    pub sep: Sep,
    pub iter: Iter,
}

impl<Sep, Iter, S> fast_fmt::Fmt<S> for Separated<Sep, Iter>
where
    Iter: Copy + IntoIterator,
    Iter::Item: fast_fmt::Fmt<S>,
    Sep: fast_fmt::Fmt<S>,
{
    fn fmt<W: fast_fmt::Write>(&self, writer: &mut W, strategy: &S) -> Result<(), W::Error> {
        let mut it = self.iter.into_iter();
        if let Some(x) = it.next() {
            x.fmt(writer, strategy)?;
            for y in it {
                self.sep.fmt(writer, strategy)?;
                y.fmt(writer, strategy)?;
            }
        }
        Ok(())
    }

    fn size_hint(&self, strategy: &S) -> usize {
        let mut it = self.iter.into_iter();
        if let Some(x) = it.next() {
            let mut result = x.size_hint(strategy);
            let mut num_seps = 0;
            for y in it {
                result += y.size_hint(strategy);
                num_seps += 1;
            }
            if num_seps > 0 {
                result += self.sep.size_hint(strategy) * num_seps;
            }
            result
        } else {
            0
        }
    }
}

/// ```
/// use fmt_utils::fast_fmt::{Repeated, fmt_to_cleared_string};
///
/// let mut buf = String::new();
///
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "", count: 0 }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: 'a', count: 0 }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "ab", count: 0 }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "", count: 1 }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: 'a', count: 1 }, &fast_fmt::Display), "a");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "ab", count: 1 }, &fast_fmt::Display), "ab");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "", count: 2 }, &fast_fmt::Display), "");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: 'a', count: 2 }, &fast_fmt::Display), "aa");
/// assert_eq!(fmt_to_cleared_string(&mut buf, Repeated { value: "ab", count: 2 }, &fast_fmt::Display), "abab");
/// ```
#[derive(Copy, Clone, Debug)]
pub struct Repeated<T> {
    pub value: T,
    pub count: usize,
}

impl<T, S> fast_fmt::Fmt<S> for Repeated<T>
where
    T: fast_fmt::Fmt<S>,
{
    fn fmt<W: fast_fmt::Write>(&self, writer: &mut W, strategy: &S) -> Result<(), W::Error> {
        for _ in 0..self.count {
            self.value.fmt(writer, strategy)?;
        }
        Ok(())
    }

    fn size_hint(&self, strategy: &S) -> usize {
        if self.count == 0 {
            0
        } else {
            self.value.size_hint(strategy) * self.count
        }
    }
}