#![cfg_attr(not(feature = "std"), no_std)]
#![warn(missing_docs)]
use core::fmt;
use core::iter::{self, FromIterator};
pub use self::FromHexError::*;
pub trait ToHex {
fn to_hex<T: FromIterator<char>>(&self) -> T;
}
static CHARS: &'static [u8] = b"0123456789abcdef";
impl ToHex for [u8] {
fn to_hex<T: FromIterator<char>>(&self) -> T {
ToHexIter::new(self.iter()).collect()
}
}
impl<'a, T: ?Sized + ToHex> ToHex for &'a T {
fn to_hex<U: FromIterator<char>>(&self) -> U {
(**self).to_hex()
}
}
pub struct ToHexIter<T> {
live: Option<char>,
inner: T,
}
impl<T> ToHexIter<T> {
pub fn new(inner: T) -> Self {
Self {
live: None,
inner,
}
}
}
impl<'a, T: Iterator<Item = &'a u8>> Iterator for ToHexIter<T> {
type Item = char;
fn next(&mut self) -> Option<char> {
if let Some(live) = self.live.take() {
return Some(live);
}
self.inner.next().map(|&byte| {
let current = CHARS[(byte >> 4) as usize] as char;
self.live = Some(CHARS[(byte & 0xf) as usize] as char);
current
})
}
fn size_hint(&self) -> (usize, Option<usize>) {
let (a, b) = self.inner.size_hint();
(a.saturating_mul(2), b.map(|b| b.saturating_mul(2)))
}
}
impl<'a, T: iter::ExactSizeIterator + Iterator<Item = &'a u8>> iter::ExactSizeIterator for ToHexIter<T> {
fn len(&self) -> usize {
let mut len = self.inner.len() * 2;
if self.live.is_some() {
len += 1;
}
len
}
}
pub trait FromHex {
fn from_hex<T: FromIterator<u8>>(&self) -> Result<T, FromHexError>;
}
#[derive(Clone, Copy)]
pub enum FromHexError {
InvalidHexCharacter(char, usize),
InvalidHexLength,
}
impl fmt::Debug for FromHexError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvalidHexCharacter(ch, idx) =>
write!(f, "Invalid character '{}' at position {}", ch, idx),
InvalidHexLength => write!(f, "Invalid input length"),
}
}
}
#[cfg(feature = "std")]
impl ::std::error::Error for FromHexError {
fn description(&self) -> &str {
match *self {
InvalidHexCharacter(_, _) => "invalid character",
InvalidHexLength => "invalid length",
}
}
}
#[cfg(feature = "std")]
impl fmt::Display for FromHexError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
#[cfg(not(feature = "std"))]
impl fmt::Display for FromHexError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvalidHexCharacter(ch, idx) => {
f.write_str("invalid character: ")?;
ch.fmt(f)?;
f.write_str(" at index ")?;
idx.fmt(f)
}
InvalidHexLength => f.write_str("invalid length"),
}
}
}
impl FromHex for str {
fn from_hex<T: FromIterator<u8>>(&self) -> Result<T, FromHexError> {
FromHexIter::new(self).collect()
}
}
impl<'a, T: ?Sized + FromHex> FromHex for &'a T {
fn from_hex<U: FromIterator<u8>>(&self) -> Result<U, FromHexError> {
(**self).from_hex()
}
}
pub struct FromHexIter<'a> {
err: bool,
inner: &'a str,
iter: iter::Enumerate<core::str::Bytes<'a>>,
}
impl<'a> FromHexIter<'a> {
pub fn new(inner: &'a str) -> Self {
let iter = inner.bytes().enumerate();
Self {
err: false,
inner,
iter,
}
}
}
impl<'a> Iterator for FromHexIter<'a> {
type Item = Result<u8, FromHexError>;
fn next(&mut self) -> Option<Result<u8, FromHexError>> {
if self.err {
return None;
}
let mut modulus = 0;
let mut buf = 0;
for (idx, byte) in &mut self.iter {
buf <<= 4;
match byte {
b'A'..=b'F' => buf |= byte - b'A' + 10,
b'a'..=b'f' => buf |= byte - b'a' + 10,
b'0'..=b'9' => buf |= byte - b'0',
b' '|b'\r'|b'\n'|b'\t' => {
buf >>= 4;
continue
}
_ => {
let ch = self.inner[idx..].chars().next().unwrap();
self.err = true;
return Some(Err(InvalidHexCharacter(ch, idx)));
}
}
modulus += 1;
if modulus == 2 {
return Some(Ok(buf));
}
}
if modulus != 0 {
self.err = true;
return Some(Err(InvalidHexLength));
}
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
let (a, b) = self.iter.size_hint();
(a / 2, b.map(|b| b / 2))
}
}
#[cfg(test)]
mod tests {
use super::{FromHex, ToHex};
#[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(not(feature = "std"))]
use alloc::{string::String, vec::Vec, format};
#[test]
pub fn test_to_hex() {
assert_eq!("foobar".as_bytes().to_hex::<String>(), "666f6f626172");
}
#[test]
pub fn test_from_hex_okay() {
assert_eq!("666f6f626172".from_hex::<Vec<_>>().unwrap(),
b"foobar");
assert_eq!("666F6F626172".from_hex::<Vec<_>>().unwrap(),
b"foobar");
}
#[test]
pub fn test_from_hex_odd_len() {
assert!("666".from_hex::<Vec<_>>().is_err());
assert!("66 6".from_hex::<Vec<_>>().is_err());
}
#[test]
pub fn test_from_hex_invalid_char() {
assert!("66y6".from_hex::<Vec<_>>().is_err());
}
#[test]
pub fn test_from_hex_ignores_whitespace() {
assert_eq!("666f 6f6\r\n26172 ".from_hex::<Vec<_>>().unwrap(),
b"foobar");
}
#[test]
pub fn test_to_hex_all_bytes() {
for i in 0..256 {
assert_eq!([i as u8].to_hex::<String>(), format!("{:02x}", i));
}
}
#[test]
pub fn test_from_hex_all_bytes() {
for i in 0..256 {
let ii: &[u8] = &[i as u8];
assert_eq!(format!("{:02x}", i).from_hex::<Vec<_>>().unwrap(),
ii);
assert_eq!(format!("{:02X}", i).from_hex::<Vec<_>>().unwrap(),
ii);
}
}
}