New upstream version 1.48.0~beta.8+dfsg1

[rustc.git] / vendor / generic-array / src / hex.rs

//! Generic array are commonly used as a return value for hash digests, so\r
//! it's a good idea to allow to hexlify them easily. This module implements\r
//! `std::fmt::LowerHex` and `std::fmt::UpperHex` traits.\r
//!\r
//! Example:\r
//!\r
//! ```rust\r
//! # #[macro_use]\r
//! # extern crate generic_array;\r
//! # extern crate typenum;\r
//! # fn main() {\r
//! let array = arr![u8; 10, 20, 30];\r
//! assert_eq!(format!("{:x}", array), "0a141e");\r
//! # }\r
//! ```\r
//!\r
\r
use core::{fmt, str, ops::Add, cmp::min};\r
\r
use typenum::*;\r
\r
use crate::{ArrayLength, GenericArray};\r
\r
static LOWER_CHARS: &'static [u8] = b"0123456789abcdef";\r
static UPPER_CHARS: &'static [u8] = b"0123456789ABCDEF";\r
\r
impl<T: ArrayLength<u8>> fmt::LowerHex for GenericArray<u8, T>\r
where\r
    T: Add<T>,\r
    <T as Add<T>>::Output: ArrayLength<u8>,\r
{\r
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r
        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);\r
        let max_hex = (max_digits >> 1) + (max_digits & 1);\r
\r
        if T::USIZE < 1024 {\r
            // For small arrays use a stack allocated\r
            // buffer of 2x number of bytes\r
            let mut res = GenericArray::<u8, Sum<T, T>>::default();\r
\r
            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {\r
                res[i * 2] = LOWER_CHARS[(c >> 4) as usize];\r
                res[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];\r
            });\r
\r
            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;\r
        } else {\r
            // For large array use chunks of up to 1024 bytes (2048 hex chars)\r
            let mut buf = [0u8; 2048];\r
            let mut digits_left = max_digits;\r
\r
            for chunk in self[..max_hex].chunks(1024) {\r
                chunk.iter().enumerate().for_each(|(i, c)| {\r
                    buf[i * 2] = LOWER_CHARS[(c >> 4) as usize];\r
                    buf[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];\r
                });\r
\r
                let n = min(chunk.len() * 2, digits_left);\r
                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;\r
                digits_left -= n;\r
            }\r
        }\r
        Ok(())\r
    }\r
}\r
\r
impl<T: ArrayLength<u8>> fmt::UpperHex for GenericArray<u8, T>\r
where\r
    T: Add<T>,\r
    <T as Add<T>>::Output: ArrayLength<u8>,\r
{\r
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r
        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);\r
        let max_hex = (max_digits >> 1) + (max_digits & 1);\r
\r
        if T::USIZE < 1024 {\r
            // For small arrays use a stack allocated\r
            // buffer of 2x number of bytes\r
            let mut res = GenericArray::<u8, Sum<T, T>>::default();\r
\r
            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {\r
                res[i * 2] = UPPER_CHARS[(c >> 4) as usize];\r
                res[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];\r
            });\r
\r
            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;\r
        } else {\r
            // For large array use chunks of up to 1024 bytes (2048 hex chars)\r
            let mut buf = [0u8; 2048];\r
            let mut digits_left = max_digits;\r
\r
            for chunk in self[..max_hex].chunks(1024) {\r
                chunk.iter().enumerate().for_each(|(i, c)| {\r
                    buf[i * 2] = UPPER_CHARS[(c >> 4) as usize];\r
                    buf[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];\r
                });\r
\r
                let n = min(chunk.len() * 2, digits_left);\r
                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;\r
                digits_left -= n;\r
            }\r
        }\r
        Ok(())\r
    }\r
}\r