#[repr(u8)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Finger {
Unknown = 0,
LeftThumb = 1,
LeftIndex = 2,
LeftMiddle = 3,
LeftRing = 4,
LeftLittle = 5,
RightThumb = 6,
RightIndex = 7,
RightMiddle = 8,
RightRing = 9,
RightLittle = 10,
}
impl Finger {
pub const FIRST: Finger = Finger::LeftThumb;
pub const LAST: Finger = Finger::RightLittle;
pub const ALL: [Finger; 10] = [
Finger::LeftThumb,
Finger::LeftIndex,
Finger::LeftMiddle,
Finger::LeftRing,
Finger::LeftLittle,
Finger::RightThumb,
Finger::RightIndex,
Finger::RightMiddle,
Finger::RightRing,
Finger::RightLittle,
];
#[must_use]
pub fn from_u8(v: u8) -> Option<Finger> {
Some(match v {
0 => Finger::Unknown,
1 => Finger::LeftThumb,
2 => Finger::LeftIndex,
3 => Finger::LeftMiddle,
4 => Finger::LeftRing,
5 => Finger::LeftLittle,
6 => Finger::RightThumb,
7 => Finger::RightIndex,
8 => Finger::RightMiddle,
9 => Finger::RightRing,
10 => Finger::RightLittle,
_ => return None,
})
}
#[must_use]
pub fn as_u8(self) -> u8 {
self as u8
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct InvalidFinger(
pub u8,
);
impl core::fmt::Display for InvalidFinger {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{} is not a valid finger byte (expected 0..=10)", self.0)
}
}
impl std::error::Error for InvalidFinger {}
impl From<Finger> for u8 {
fn from(finger: Finger) -> u8 {
finger as u8
}
}
impl TryFrom<u8> for Finger {
type Error = InvalidFinger;
fn try_from(v: u8) -> Result<Finger, InvalidFinger> {
Finger::from_u8(v).ok_or(InvalidFinger(v))
}
}
#[cfg(test)]
mod tests {
use super::{Finger, InvalidFinger};
#[test]
fn byte_roundtrip_is_stable() {
for f in Finger::ALL {
assert_eq!(Finger::from_u8(f.as_u8()), Some(f));
}
assert_eq!(Finger::from_u8(0), Some(Finger::Unknown));
assert_eq!(Finger::from_u8(11), None);
}
#[test]
fn std_conversions_agree_with_inherent_methods() {
for v in u8::MIN..=u8::MAX {
assert_eq!(
Finger::try_from(v).ok(),
Finger::from_u8(v),
"try_from({v})"
);
match Finger::try_from(v) {
Ok(f) => assert_eq!(u8::from(f), v, "u8::from round-trip for {f:?}"),
Err(e) => assert_eq!(e, InvalidFinger(v), "error carries the byte"),
}
}
for f in Finger::ALL.iter().chain(&[Finger::Unknown]) {
assert_eq!(u8::from(*f), f.as_u8());
}
}
#[test]
fn from_u8_accepts_exactly_zero_through_ten() {
for v in u8::MIN..=u8::MAX {
let decoded = Finger::from_u8(v);
assert_eq!(decoded.is_some(), v <= 10, "from_u8({v}) = {decoded:?}");
if let Some(f) = decoded {
assert_eq!(f.as_u8(), v);
}
}
}
#[test]
fn all_lists_the_ten_real_fingers_in_byte_order() {
let bytes: Vec<u8> = Finger::ALL.iter().map(|f| f.as_u8()).collect();
assert_eq!(bytes, (1..=10).collect::<Vec<u8>>());
assert!(!Finger::ALL.contains(&Finger::Unknown));
}
#[test]
fn discriminants_match_libfprint() {
assert_eq!(Finger::LeftThumb.as_u8(), 1);
assert_eq!(Finger::RightLittle.as_u8(), 10);
assert_eq!(Finger::FIRST, Finger::LeftThumb);
assert_eq!(Finger::LAST, Finger::RightLittle);
}
}