ashv2 1.2.2

Implementation of the Asynchronous Serial Host (ASH) protocol by Silicon Labs.
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

//! A module for formatting slices of bytes as hexadecimal values.

use core::fmt::{Formatter, LowerHex, Result, UpperHex};

/// A wrapper around a slice of bytes to format it with hexadecimal bytes.
pub struct HexSlice<'a>(&'a [u8]);

impl<'a> HexSlice<'a> {
    /// Creates a new `HexSlice` from a slice of bytes.
    #[must_use]
    pub const fn new(slice: &'a [u8]) -> Self {
        Self(slice)
    }

    /// Formats the slice with a custom byte formatter.
    fn format<F>(&self, f: &mut Formatter<'_>, byte_formatter: F) -> Result
    where
        F: Fn(&u8, &mut Formatter<'_>) -> Result,
    {
        write!(f, "[")?;

        let mut bytes = self.0.iter();

        if let Some(first_byte) = bytes.next() {
            byte_formatter(first_byte, f)?;
        }

        for byte in bytes {
            write!(f, ", ")?;
            byte_formatter(byte, f)?;
        }

        write!(f, "]")
    }
}

impl<'a> From<&'a [u8]> for HexSlice<'a> {
    fn from(slice: &'a [u8]) -> Self {
        Self::new(slice)
    }
}

impl UpperHex for HexSlice<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        self.format(f, UpperHex::fmt)
    }
}

impl LowerHex for HexSlice<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        self.format(f, LowerHex::fmt)
    }
}

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

    #[test]
    fn test_from() {
        let slice: &[u8] = &[0x01, 0xAB, 0x03];
        let hex_slice: HexSlice<'_> = slice.into();
        assert_eq!(hex_slice.0, slice);
    }

    #[test]
    fn test_upper_hex() {
        let slice = HexSlice::new(&[0x01, 0xAB, 0x03]);
        assert_eq!(format!("{slice:#04X}"), "[0x01, 0xAB, 0x03]");
    }

    #[test]
    fn test_lower_hex() {
        let slice = HexSlice::new(&[0x01, 0xAB, 0x03]);
        assert_eq!(format!("{slice:#04x}"), "[0x01, 0xab, 0x03]");
    }

    #[test]
    fn test_empty_slice_upper() {
        let slice = HexSlice::new(&[]);
        assert_eq!(format!("{slice:#04X}"), "[]");
    }

    #[test]
    fn test_empty_slice_lower() {
        let slice = HexSlice::new(&[]);
        assert_eq!(format!("{slice:#04x}"), "[]");
    }

    #[test]
    fn test_slice_len_1_upper() {
        let slice = HexSlice::new(&[0x1A]);
        assert_eq!(format!("{slice:#04X}"), "[0x1A]");
    }

    #[test]
    fn test_slice_len_1_lower() {
        let slice = HexSlice::new(&[0x1A]);
        assert_eq!(format!("{slice:#04x}"), "[0x1a]");
    }
}