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 102 103 104 105 106 107 108 109 110 111 112 113 114 115
//! Utilities to process digits.
//!
//! This both contains routines to convert to and from digits,
//! as well as iterate over digits while skipping digit separators.
// CONST FNS
// ---------
// These are optimized functions for when the radix is known at compile-time,
// which is **most** of our cases. There are cases where for codegen, using a
// runtime algorithm is preferable.
/// Unchecked, highly optimized algorithm to convert a char to a digit.
/// This only works if the input character is known to be a valid digit.
#[inline(always)]
pub const fn char_to_valid_digit_const(c: u8, radix: u32) -> u32 {
if radix <= 10 {
// Optimize for small radixes.
(c.wrapping_sub(b'0')) as u32
} else {
// Fallback, still decently fast.
let digit = match c {
b'0'..=b'9' => c - b'0',
b'A'..=b'Z' => c - b'A' + 10,
b'a'..=b'z' => c - b'a' + 10,
_ => 0xFF,
};
digit as u32
}
}
/// Convert a character to a digit with a radix known at compile time.
///
/// This optimizes for cases where radix is <= 10, and uses a decent,
/// match-based fallback algorithm.
#[inline(always)]
pub const fn char_to_digit_const(c: u8, radix: u32) -> Option<u32> {
let digit = char_to_valid_digit_const(c, radix);
if digit < radix {
Some(digit)
} else {
None
}
}
/// Determine if a character is a digit with a radix known at compile time.
#[inline(always)]
pub const fn char_is_digit_const(c: u8, radix: u32) -> bool {
char_to_digit_const(c, radix).is_some()
}
/// Convert a digit to a character with a radix known at compile time.
///
/// This optimizes for cases where radix is <= 10, and uses a decent,
/// match-based fallback algorithm.
#[inline(always)]
#[cfg(any(feature = "write", feature = "floats"))]
pub const fn digit_to_char_const(digit: u32, radix: u32) -> u8 {
if radix <= 10 || digit < 10 {
// Can short-circuit if we know the radix is small at compile time.
digit as u8 + b'0'
} else {
digit as u8 + b'A' - 10
}
}
// NON-CONST
// ---------
// These are less optimized functions for when the radix is not known at
// compile-time, which is a few (but important) cases. These generally have
// improved compiler optimization passes when generics are used more sparingly.
/// Convert a character to a digit.
#[inline(always)]
#[cfg(feature = "parse")]
pub const fn char_to_digit(c: u8, radix: u32) -> Option<u32> {
// Fallback, still decently fast.
let digit = match c {
b'0'..=b'9' => c - b'0',
b'A'..=b'Z' => c - b'A' + 10,
b'a'..=b'z' => c - b'a' + 10,
_ => 0xFF,
} as u32;
if digit < radix {
Some(digit)
} else {
None
}
}
/// Determine if a character is a digit.
#[inline(always)]
#[cfg(feature = "parse")]
pub const fn char_is_digit(c: u8, radix: u32) -> bool {
char_to_digit(c, radix).is_some()
}
/// Convert a digit to a character. This uses a pre-computed table to avoid
/// branching.
///
/// # Panics
///
/// Panics if `digit >= 36`.
#[inline(always)]
#[cfg(feature = "write")]
pub fn digit_to_char(digit: u32) -> u8 {
const TABLE: [u8; 36] = [
b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'A', b'B', b'C', b'D', b'E',
b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O', b'P', b'Q', b'R', b'S', b'T',
b'U', b'V', b'W', b'X', b'Y', b'Z',
];
debug_assert!(digit < 36, "digit_to_char() invalid character.");
TABLE[digit as usize]
}