zeros/
zeros.rs

1/*
2==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--
3
4Zeros
5
6Copyright (C) 2019-2025  Anonymous
7
8There are several releases over multiple years,
9they are listed as ranges, such as: "2019-2025".
10
11This program is free software: you can redistribute it and/or modify
12it under the terms of the GNU Lesser General Public License as published by
13the Free Software Foundation, either version 3 of the License, or
14(at your option) any later version.
15
16This program is distributed in the hope that it will be useful,
17but WITHOUT ANY WARRANTY; without even the implied warranty of
18MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19GNU Lesser General Public License for more details.
20
21You should have received a copy of the GNU Lesser General Public License
22along with this program.  If not, see <https://www.gnu.org/licenses/>.
23
24::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--
25*/
26
27//! # Zeros
28
29use {
30    alloc::{
31        string::String,
32        vec::Vec,
33    },
34    crate::Result,
35};
36
37/// # A slice of hexadecimal strings of all [`u8`][r::u8] values
38///
39/// This slice is used by [`bytes_to_hex()`][::bytes_to_hex()]. Each string consists of 2 characters.
40///
41/// ## Examples
42///
43/// ```
44/// use zeros::HEX_STRS;
45///
46/// assert_eq!(HEX_STRS.len(), 256);
47/// assert_eq!(HEX_STRS[0], "00");
48/// assert_eq!(HEX_STRS[usize::from(u8::MAX)], "ff");
49/// ```
50///
51/// [::bytes_to_hex()]: fn.bytes_to_hex.html
52/// [r::u8]: https://doc.rust-lang.org/std/primitive.u8.html
53pub const HEX_STRS: &[&str] = &[
54    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13", "14", "15", "16",
55    "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d",
56    "2e", "2f", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44",
57    "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b",
58    "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", "70", "71", "72",
59    "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
60    "8a", "8b", "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0",
61    "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
62    "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce",
63    "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5",
64    "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc",
65    "fd", "fe", "ff",
66];
67
68#[test]
69fn test_hex_strs() {
70    assert!(HEX_STRS.len() > usize::from(u8::MAX));
71    for i in 0..HEX_STRS.len() {
72        assert_eq!(format!("{:02x}", i), HEX_STRS[i]);
73    }
74}
75
76
77/// # Formats a byte slice as a hexadecimal string, in lower-case
78///
79/// This function uses [`HEX_STRS`][::HEX_STRS], which (at the time) was faster than `format!("{:02x}", ...)`.
80///
81/// ## Examples
82///
83/// ```
84/// assert_eq!(zeros::bytes_to_hex(     &[202, 254]), "cafe");
85/// assert_eq!(zeros::bytes_to_hex(&[192, 255, 238]), "c0ffee");
86/// ```
87///
88/// [::HEX_STRS]: constant.HEX_STRS.html
89pub fn bytes_to_hex<B>(bytes: B) -> String where B: AsRef<[u8]> {
90    let bytes = bytes.as_ref();
91
92    let mut result = String::with_capacity(bytes.len().saturating_mul(2));
93    for b in bytes {
94        result.push_str(HEX_STRS[usize::from(*b)]);
95    }
96
97    result
98}
99
100/// # Converts a hexadecimal string into a vector of bytes
101///
102/// It requires 2 hexadecimal characters per byte.
103///
104/// ## Examples
105///
106/// ```
107/// assert_eq!(zeros::hex_to_bytes("aaff00")?, [0xaa, 0xff, 0x00]);
108/// assert_eq!(zeros::hex_to_bytes("C0FFEE")?, [0xc0, 0xff, 0xee]);
109///
110/// # zeros::Result::Ok(())
111/// ```
112pub fn hex_to_bytes<H>(hex: H) -> Result<Vec<u8>> where H: AsRef<[u8]> {
113    let hex = hex.as_ref();
114    let err = || err!("Invalid hexadecimal string: {:?}", hex);
115
116    if hex.len() % 2 != 0 {
117        return Err(err());
118    }
119
120    let decimal = |b| match b {
121        b'0' => Some(0),
122        b'1' => Some(1),
123        b'2' => Some(2),
124        b'3' => Some(3),
125        b'4' => Some(4),
126        b'5' => Some(5),
127        b'6' => Some(6),
128        b'7' => Some(7),
129        b'8' => Some(8),
130        b'9' => Some(9),
131        b'a' | b'A' => Some(10),
132        b'b' | b'B' => Some(11),
133        b'c' | b'C' => Some(12),
134        b'd' | b'D' => Some(13),
135        b'e' | b'E' => Some(14),
136        b'f' | b'F' => Some(15),
137        _ => None,
138    };
139    let capacity = hex.len() / 2;
140    (0..capacity).map(|i| i * 2).try_fold(Vec::with_capacity(capacity), |mut result, index| {
141        match (decimal(hex[index]), decimal(hex[index + 1])) {
142            (Some(first), Some(second)) => {
143                result.push(first * 16 + second);
144                Ok(result)
145            },
146            _ => Err(err()),
147        }
148    })
149}
zeros/zeros.rs

zeros/
zeros.rs
