fashex 0.0.10

Hexadecimal string encoding and decoding with best-effort SIMD acceleration.
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

//! See [`Display`].

use alloc::boxed::Box;
use core::fmt;

use crate::traits::Hex;

wrapper_lite::wrapper!(
    #[wrapper(Debug)]
    #[wrapper(AsRef)]
    #[wrapper([const] AsMut)]
    #[wrapper(BorrowMut)]
    #[wrapper(DerefMut)]
    #[wrapper(From)]
    #[bound(T: AsRef<[u8]>)]
    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
    #[derive(Clone, Copy, PartialEq, Eq)]
    /// A wrapper for displaying a byte slice as a hexadecimal string.
    ///
    /// ```rust
    /// let bytes = &[0xde, 0xad, 0xbe, 0xef];
    ///
    /// let displayed = fashex::Display::from(bytes);
    ///
    /// assert_eq!(format!("{}", &displayed), "deadbeef");
    /// assert_eq!(format!("{:X}", &displayed), "DEADBEEF");
    /// assert_eq!(format!("{:#x}", &displayed), "0xdeadbeef");
    /// assert_eq!(format!("{:#X}", &displayed), "0xDEADBEEF");
    /// ```
    pub struct Display<T> {
        value: T,
    }
);

impl<T: AsRef<[u8]>> fmt::Display for Display<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::LowerHex::fmt(self, f)
    }
}

impl<T: AsRef<[u8]>> fmt::LowerHex for Display<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.write::<false>(f)
    }
}

impl<T: AsRef<[u8]>> fmt::UpperHex for Display<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.write::<true>(f)
    }
}

impl<T> Display<T>
where
    T: AsRef<[u8]>,
{
    fn write<const UPPER: bool>(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if f.alternate() {
            f.write_str("0x")?;
        }

        f.write_str(
            &self
                .encode_hex::<Box<str>, UPPER>()
                .map_err(|_| fmt::Error)?,
        )
    }
}