extfmt 0.2.0

Extended formatting options for commmon types
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

//! Formatting options for slices.

use core::fmt::*;

/// Format a slice in a Rust syntax.
/// Supports formatting using the following traits:
///		- Display
///		- Debug
///		- Binary
///		- Octal
///		- LowerHex, UpperHex
///		- LowerExp, UpperExp
///		- Pointer
///
/// # Examples
/// ```
/// use extfmt::*;
///
/// assert_eq!(format!("{}", CommaSeparated(&[1, 2, 3])), "[1, 2, 3]");
/// assert_eq!(format!("{:x}", CommaSeparated(&[122, 123, 134])), "[7a, 7b, 86]");
/// assert_eq!(format!("{:#o}", CommaSeparated(&[122, 123, 134])), "[0o172, 0o173, 0o206]");
/// ```
#[derive(Clone)]
pub struct CommaSeparated<'a, T: 'a>(pub &'a [T]);

macro_rules! additional_slice_formatting {
    ($($tr:ident),*) => {
        $(
        impl<'a, T: 'a + $tr> $tr for CommaSeparated<'a, T> {
            fn fmt(&self, f: &mut Formatter) -> Result {
                let mut has_items = false;

                f.write_str("[")?;

                for i in self.0.iter() {
                    if has_items {
                        f.write_str(", ")?;
                    }

                    <T as $tr>::fmt(i, f)?;
                    has_items = true;
                }

                f.write_str("]")
            }
        }
        )*
    }
}

additional_slice_formatting!(
    Display, Debug, Binary, Octal, LowerHex, UpperHex, LowerExp, UpperExp, Pointer
);

/// Formats a byte-buffer as a series of concatanated hex-pairs.
///
/// Implements the following formatting traits:
///		- Display, Debug, LowerHex - Will format in all letters in lowercase.
///		- UpperHex - Will format in all letters in uppercase
///
/// # Examples
/// ```
/// use extfmt::*;
///
/// assert_eq!(format!("{}", Hexlify(&[122, 123, 134])), "7a7b86");
/// assert_eq!(format!("{:x}", Hexlify(&[122, 123, 134])), "7a7b86");
/// assert_eq!(format!("{:X}", Hexlify(&[122, 123, 134])), "7A7B86");
/// ```
pub struct Hexlify<'a>(pub &'a [u8]);

impl<'a> LowerHex for Hexlify<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result {
        for byte in self.0.iter() {
            write!(f, "{:02x}", byte)?;
        }

        Ok(())
    }
}

impl<'a> UpperHex for Hexlify<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result {
        for byte in self.0.iter() {
            write!(f, "{:02X}", byte)?;
        }

        Ok(())
    }
}

impl<'a> Debug for Hexlify<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result {
        <Self as LowerHex>::fmt(self, f)
    }
}

impl<'a> Display for Hexlify<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result {
        <Self as LowerHex>::fmt(self, f)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn readme() {
        assert_eq!(
            format!("{:02x}", CommaSeparated(&[1, 2, 255, 64])),
            "[01, 02, ff, 40]"
        );
        assert_eq!(format!("{}", Hexlify(&[1, 2, 255, 64])), "0102ff40");
    }
}