#![cfg_attr(not(feature = "std"), no_std)]
use core::{error::Error, fmt, str};
const DIGIT_MAX: u8 = 9;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Bcd<const BYTES: usize>([u8; BYTES]);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvalidBcdDigit(u8);
impl fmt::Display for InvalidBcdDigit {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Invalid BCD digit {}. Must be <= {}", self.0, DIGIT_MAX)
}
}
impl Error for InvalidBcdDigit {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BcdOverflowError;
impl fmt::Display for BcdOverflowError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Overflow during BCD conversion")
}
}
impl Error for BcdOverflowError {}
macro_rules! impl_bcd_try_from {
($(#[$attr:meta])* $name:ident, $ty:ty) => {
$(#[$attr])*
pub const fn $name(value: $ty) -> Result<Self, BcdOverflowError> {
const BITS: u32 = <$ty>::BITS;
let mut bcd = [0u8; BYTES];
let mut overflow = false;
let mut bit = BITS;
while bit > 0 {
bit -= 1;
let mut byte = 0;
while byte < BYTES {
let lo = bcd[byte] & 0x0f;
let hi = (bcd[byte] >> 4) & 0x0f;
if lo >= 5 {
bcd[byte] += 0x03;
}
if hi >= 5 {
bcd[byte] += 0x30;
}
byte += 1;
}
let mut carry = ((value >> bit) & 1) as u8;
let mut i = BYTES;
while i > 0 {
i -= 1;
let next_carry = (bcd[i] >> 7) & 1;
bcd[i] = (bcd[i] << 1) | carry;
carry = next_carry;
}
if carry != 0 {
overflow = true;
}
}
if overflow {
Err(BcdOverflowError)
} else {
Ok(Bcd(bcd))
}
}
};
}
macro_rules! impl_bcd_try_into {
($(#[$attr:meta])* $name:ident, $ty:ty) => {
$(#[$attr])*
pub const fn $name(self) -> Result<$ty, BcdOverflowError> {
let mut result: $ty = 0;
let mut i = 0;
while i < BYTES {
let hi = (self.0[i] >> 4) & 0x0f;
let lo = self.0[i] & 0x0f;
result = match result.checked_mul(10) {
Some(v) => v,
None => return Err(BcdOverflowError),
};
result = match result.checked_add(hi as $ty) {
Some(v) => v,
None => return Err(BcdOverflowError),
};
result = match result.checked_mul(10) {
Some(v) => v,
None => return Err(BcdOverflowError),
};
result = match result.checked_add(lo as $ty) {
Some(v) => v,
None => return Err(BcdOverflowError),
};
i += 1;
}
Ok(result)
}
};
}
impl<const BYTES: usize> Bcd<BYTES> {
pub const fn from_bcd_bytes(bytes: [u8; BYTES]) -> Result<Self, InvalidBcdDigit> {
let mut i = 0;
while i < BYTES {
let high = bytes[i] >> 4;
let low = bytes[i] & 0x0F;
if high > DIGIT_MAX {
return Err(InvalidBcdDigit(high));
}
if low > DIGIT_MAX {
return Err(InvalidBcdDigit(low));
}
i += 1;
}
Ok(Self(bytes))
}
impl_bcd_try_from!(
try_from_u8, u8
);
impl_bcd_try_from!(
try_from_u16, u16
);
impl_bcd_try_from!(
try_from_u32, u32
);
impl_bcd_try_from!(
try_from_u64, u64
);
impl_bcd_try_from!(
try_from_u128, u128
);
impl_bcd_try_from!(
try_from_usize, usize
);
impl_bcd_try_into!(
try_into_u8, u8
);
impl_bcd_try_into!(
try_into_u16, u16
);
impl_bcd_try_into!(
try_into_u32, u32
);
impl_bcd_try_into!(
try_into_u64, u64
);
impl_bcd_try_into!(
try_into_u128, u128
);
impl_bcd_try_into!(
try_into_usize, usize
);
}
impl<const BYTES: usize> fmt::Display for Bcd<BYTES> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut buf = [[0u8; 2]; BYTES];
let mut len = 0;
for nibble in self
.0
.iter()
.flat_map(|b| [b >> 4, b & 0x0F])
.skip_while(|n| *n == 0)
{
buf[len / 2][len % 2] = b'0' + nibble;
len += 1;
}
let s = if len == 0 {
"0"
} else {
str::from_utf8(&buf.as_flattened()[..len]).unwrap()
};
f.pad_integral(true, "", s)
}
}
macro_rules! impl_bcd_into {
($prim:ty, $fn_name:ident, $try_into_fn:ident, $($bytes:literal),+) => {
$(
impl Bcd<$bytes> {
pub const fn $fn_name(self) -> $prim {
match self.$try_into_fn() {
Ok(val) => val,
Err(_) => panic!("BUG: infallible BCD conversion overflowed")
}
}
}
)+
};
}
impl_bcd_into!(u8, into_u8, try_into_u8, 0, 1);
impl_bcd_into!(u16, into_u16, try_into_u16, 0, 1, 2);
impl_bcd_into!(u32, into_u32, try_into_u32, 0, 1, 2, 3, 4);
impl_bcd_into!(u64, into_u64, try_into_u64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
impl_bcd_into!(
u128,
into_u128,
try_into_u128,
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19
);
impl_bcd_into!(usize, into_usize, try_into_usize, 0, 1, 2);
#[macro_export]
macro_rules! bcd {
($v:expr) => {{
let v: u128 = $v as u128;
match if v <= u8::MAX as u128 {
$crate::Bcd::try_from_u8(v as u8)
} else if v <= u16::MAX as u128 {
$crate::Bcd::try_from_u16(v as u16)
} else if v <= u32::MAX as u128 {
$crate::Bcd::try_from_u32(v as u32)
} else if v <= u64::MAX as u128 {
$crate::Bcd::try_from_u64(v as u64)
} else {
$crate::Bcd::try_from_u128(v)
} {
Ok(bcd) => bcd,
Err(_) => panic!("Overflow during BCD conversion"),
}
}};
}
#[cfg(test)]
mod tests {
use super::*;
use test_format::assert_display_fmt;
#[test]
fn from_bcd_bytes_valid() {
let n = Bcd::<2>::from_bcd_bytes([0x12, 0x34]).unwrap();
assert_display_fmt!(n, "1234");
}
#[test]
fn from_bcd_bytes_all_zeros() {
let n = Bcd::<4>::from_bcd_bytes([0; 4]).unwrap();
assert_eq!(n.try_into_u32(), Ok(0));
}
#[test]
fn from_bcd_bytes_rejects_invalid_high_nibble() {
let err = Bcd::<1>::from_bcd_bytes([0xA0]).unwrap_err();
assert_eq!(err, InvalidBcdDigit(0xA));
}
#[test]
fn from_bcd_bytes_rejects_invalid_low_nibble() {
let err = Bcd::<1>::from_bcd_bytes([0x0B]).unwrap_err();
assert_eq!(err, InvalidBcdDigit(0xB));
}
#[test]
fn from_bcd_bytes_reports_first_invalid_nibble() {
let err = Bcd::<2>::from_bcd_bytes([0x12, 0xC3]).unwrap_err();
assert_eq!(err, InvalidBcdDigit(0xC));
}
#[test]
fn try_from_u8_exhaustive() {
for v in 0..=99u8 {
let bcd = Bcd::<1>::try_from_u8(v).unwrap();
assert_eq!(bcd.try_into_u8(), Ok(v));
}
for v in 100..=255u8 {
assert!(Bcd::<1>::try_from_u8(v).is_err());
}
}
#[test]
fn try_from_u8_wider_bcd_never_overflows() {
for v in 0..=255u8 {
let bcd = Bcd::<2>::try_from_u8(v).unwrap();
assert_eq!(bcd.try_into_u16(), Ok(v as u16));
}
}
#[test]
fn try_from_u16_roundtrip() {
for v in [0u16, 1, 999, 9999, u16::MAX] {
let bcd = Bcd::<3>::try_from_u16(v).unwrap();
assert_eq!(bcd.try_into_u16(), Ok(v));
}
}
#[test]
fn try_from_u16_overflow() {
assert!(Bcd::<2>::try_from_u16(10_000).is_err());
assert!(Bcd::<2>::try_from_u16(u16::MAX).is_err());
}
#[test]
fn try_from_u32_roundtrip() {
for v in [0u32, 1, 9_999, 99_999_999, u32::MAX] {
let bcd = Bcd::<5>::try_from_u32(v).unwrap();
assert_eq!(bcd.try_into_u32(), Ok(v));
}
}
#[test]
fn try_from_u32_overflow() {
assert!(Bcd::<4>::try_from_u32(100_000_000).is_err());
assert!(Bcd::<4>::try_from_u32(u32::MAX).is_err());
}
#[test]
fn try_from_u64_roundtrip() {
for v in [0u64, 1, u16::MAX as u64, u32::MAX as u64, u64::MAX] {
let bcd = Bcd::<10>::try_from_u64(v).unwrap();
assert_eq!(bcd.try_into_u64(), Ok(v));
}
}
#[test]
fn try_from_u64_overflow() {
assert!(Bcd::<9>::try_from_u64(u64::MAX).is_err());
}
#[test]
fn try_from_u128_roundtrip() {
for v in [0u128, 1, u32::MAX as u128, u64::MAX as u128, u128::MAX] {
let bcd = Bcd::<20>::try_from_u128(v).unwrap();
assert_eq!(bcd.try_into_u128(), Ok(v));
}
}
#[test]
fn try_from_u128_overflow() {
assert!(Bcd::<19>::try_from_u128(u128::MAX).is_err());
}
#[test]
fn try_from_usize_roundtrip() {
for v in [0usize, 1, 99, 99_999] {
let bcd = Bcd::<3>::try_from_usize(v).unwrap();
assert_eq!(bcd.try_into_usize(), Ok(v));
}
}
#[test]
fn try_from_usize_overflow() {
assert!(Bcd::<2>::try_from_usize(10_000).is_err());
}
#[test]
fn try_into_u8_overflow() {
let bcd = Bcd::<2>::try_from_u16(1000).unwrap();
assert!(bcd.try_into_u8().is_err());
}
#[test]
fn try_into_u16_overflow() {
let bcd = Bcd::<3>::try_from_u32(100_000).unwrap();
assert!(bcd.try_into_u16().is_err());
}
#[test]
fn try_into_u32_overflow() {
let bcd = Bcd::<5>::from_bcd_bytes([0x99; 5]).unwrap();
assert!(bcd.try_into_u32().is_err());
}
#[test]
fn try_into_u64_overflow() {
let bcd = Bcd::<10>::from_bcd_bytes([0x99; 10]).unwrap();
assert!(bcd.try_into_u64().is_err());
}
#[test]
fn try_into_u128_overflow() {
let bcd = Bcd::<20>::from_bcd_bytes([0x99; 20]).unwrap();
assert!(bcd.try_into_u128().is_err());
}
#[test]
fn try_into_usize_overflow_on_any_target() {
let bcd = Bcd::<20>::from_bcd_bytes([0x99; 20]).unwrap();
assert!(bcd.try_into_usize().is_err());
}
#[test]
fn infallible_into_u8() {
let bcd = Bcd::<1>::try_from_u8(42).unwrap();
assert_eq!(bcd.into_u8(), 42u8);
}
#[test]
fn infallible_into_u16() {
let bcd = Bcd::<2>::try_from_u16(9999).unwrap();
assert_eq!(bcd.into_u16(), 9999u16);
}
#[test]
fn infallible_into_u32() {
let bcd = Bcd::<4>::try_from_u32(12_345_678).unwrap();
assert_eq!(bcd.into_u32(), 12_345_678u32);
}
#[test]
fn infallible_into_u64() {
let v = 999_999_999_999_999_999u64;
let bcd = Bcd::<9>::try_from_u64(v).unwrap();
assert_eq!(bcd.into_u64(), v);
}
#[test]
fn infallible_into_u128() {
let v = 10u128.pow(38) - 1;
let bcd = Bcd::<19>::try_from_u128(v).unwrap();
assert_eq!(bcd.into_u128(), v);
}
#[test]
fn infallible_into_usize() {
let bcd = Bcd::<2>::try_from_usize(9999).unwrap();
assert_eq!(bcd.into_usize(), 9999usize);
}
#[test]
fn display_zero() {
let n = Bcd::<2>::try_from_u16(0).unwrap();
assert_display_fmt!(n, "0");
}
#[test]
fn display_no_leading_zeros() {
let n = Bcd::<4>::try_from_u32(42).unwrap();
assert_display_fmt!(n, "42");
}
#[test]
fn display_single_digit() {
let n = Bcd::<4>::try_from_u32(7).unwrap();
assert_display_fmt!(n, "7");
}
#[test]
fn display_padding_right_aligned() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:0>6}", n), "000042");
}
#[test]
fn display_padding_left_aligned() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:<6}", n), "42 ");
}
#[test]
fn display_default_right_aligned_like_integer() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:8}", n), " 42");
}
#[test]
fn display_numeric_zero_padding() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:08}", n), "00000042");
}
#[test]
fn display_positive_sign_flag() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:+}", n), "+42");
}
#[test]
fn display_positive_sign_with_zero_pad() {
let n = Bcd::<2>::try_from_u16(42).unwrap();
assert_display_fmt!(format_args!("{:+08}", n), "+0000042");
}
#[test]
fn display_zero_pad_zero_value() {
let n = Bcd::<2>::try_from_u16(0).unwrap();
assert_display_fmt!(format_args!("{:04}", n), "0000");
}
#[test]
fn display_u128_max() {
let bcd = Bcd::<20>::try_from_u128(u128::MAX).unwrap();
assert_eq!(bcd.to_string(), u128::MAX.to_string());
}
#[test]
fn display_internal_zeros() {
let n = Bcd::<2>::try_from_u16(1002).unwrap();
assert_display_fmt!(n, "1002");
let n = Bcd::<4>::try_from_u32(1_000_000).unwrap();
assert_display_fmt!(n, "1000000");
}
#[test]
fn debug_shows_internal_bytes() {
let bcd = Bcd::<2>::from_bcd_bytes([0x12, 0x34]).unwrap();
assert_eq!(format!("{bcd:?}"), "Bcd([18, 52])");
}
#[test]
fn ordering() {
let a = Bcd::<2>::try_from_u16(100).unwrap();
let b = Bcd::<2>::try_from_u16(200).unwrap();
let c = Bcd::<2>::try_from_u16(200).unwrap();
assert!(a < b);
assert!(b > a);
assert_eq!(b, c);
}
#[test]
fn copy_and_clone() {
let a = Bcd::<2>::try_from_u16(42).unwrap();
let b = a;
#[allow(clippy::clone_on_copy)]
let c = a.clone();
assert_eq!(a, b);
assert_eq!(a, c);
}
#[test]
fn hash_consistent_with_eq() {
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(Bcd::<2>::try_from_u16(1234).unwrap(), "hi");
assert_eq!(
map.get(&Bcd::<2>::try_from_u16(1234).unwrap()),
Some(&"hi"),
);
}
#[test]
fn invalid_bcd_digit_display() {
let e = InvalidBcdDigit(10);
assert_display_fmt!(e, "Invalid BCD digit 10. Must be <= 9");
}
#[test]
fn bcd_overflow_error_display() {
let e = BcdOverflowError;
assert_display_fmt!(e, "Overflow during BCD conversion");
}
#[test]
fn zero_byte_bcd_accepts_zero_and_overflows_on_one() {
assert!(Bcd::<0>::try_from_u8(0).is_ok());
assert!(Bcd::<0>::try_from_u8(1).is_err());
let z = Bcd::<0>::try_from_u8(0).unwrap();
assert_eq!(z.try_into_u8(), Ok(0));
assert_eq!(z.into_u8(), 0);
assert_display_fmt!(z, "0");
}
#[test]
fn bcd_macro_u8_range() {
let n: Bcd<1> = bcd!(99u8);
assert_display_fmt!(n, "99");
}
#[test]
fn bcd_macro_u16_range() {
let n: Bcd<2> = bcd!(1234u16);
assert_display_fmt!(n, "1234");
}
#[test]
fn bcd_macro_u32_range() {
let n: Bcd<5> = bcd!(100_000u32);
assert_display_fmt!(n, "100000");
}
#[test]
fn bcd_macro_u64_range() {
let n: Bcd<10> = bcd!(u64::MAX);
assert_eq!(n.to_string(), u64::MAX.to_string());
}
#[test]
fn bcd_macro_u128_range() {
let n: Bcd<20> = bcd!(u128::MAX);
assert_eq!(n.to_string(), u128::MAX.to_string());
}
#[test]
fn bcd_macro_expression() {
let x = 56u8;
let n: Bcd<1> = bcd!(x);
assert_display_fmt!(n, "56");
}
#[test]
fn bcd_macro_zero() {
let n: Bcd<1> = bcd!(0u8);
assert_display_fmt!(n, "0");
}
#[test]
#[should_panic(expected = "Overflow during BCD conversion")]
fn bcd_macro_panics_on_overflow() {
let _: Bcd<1> = bcd!(100u8);
}
#[test]
fn const_construction_and_conversion() {
const RAW: Bcd<2> = match Bcd::<2>::from_bcd_bytes([0x12, 0x34]) {
Ok(v) => v,
Err(_) => panic!(),
};
const FROM_INT: Bcd<2> = match Bcd::<2>::try_from_u16(1234) {
Ok(v) => v,
Err(_) => panic!(),
};
const FROM_MACRO: Bcd<2> = bcd!(1234u16);
const AS_INT: u16 = match FROM_MACRO.try_into_u16() {
Ok(v) => v,
Err(_) => 0,
};
const AS_INFALLIBLE: u16 = FROM_MACRO.into_u16();
assert_eq!(RAW, FROM_INT);
assert_eq!(RAW, FROM_MACRO);
assert_eq!(AS_INT, 1234);
assert_eq!(AS_INFALLIBLE, 1234);
}
}