1#[repr(u8)]
18#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
19pub enum Finger {
20 Unknown = 0,
22 LeftThumb = 1,
24 LeftIndex = 2,
26 LeftMiddle = 3,
28 LeftRing = 4,
30 LeftLittle = 5,
32 RightThumb = 6,
34 RightIndex = 7,
36 RightMiddle = 8,
38 RightRing = 9,
40 RightLittle = 10,
42}
43
44impl Finger {
45 pub const FIRST: Finger = Finger::LeftThumb;
47 pub const LAST: Finger = Finger::RightLittle;
49
50 pub const ALL: [Finger; 10] = [
52 Finger::LeftThumb,
53 Finger::LeftIndex,
54 Finger::LeftMiddle,
55 Finger::LeftRing,
56 Finger::LeftLittle,
57 Finger::RightThumb,
58 Finger::RightIndex,
59 Finger::RightMiddle,
60 Finger::RightRing,
61 Finger::RightLittle,
62 ];
63
64 #[must_use]
66 pub fn from_u8(v: u8) -> Option<Finger> {
67 Some(match v {
68 0 => Finger::Unknown,
69 1 => Finger::LeftThumb,
70 2 => Finger::LeftIndex,
71 3 => Finger::LeftMiddle,
72 4 => Finger::LeftRing,
73 5 => Finger::LeftLittle,
74 6 => Finger::RightThumb,
75 7 => Finger::RightIndex,
76 8 => Finger::RightMiddle,
77 9 => Finger::RightRing,
78 10 => Finger::RightLittle,
79 _ => return None,
80 })
81 }
82
83 #[must_use]
85 pub fn as_u8(self) -> u8 {
86 self as u8
87 }
88}
89
90#[derive(Clone, Copy, PartialEq, Eq, Debug)]
94pub struct InvalidFinger(
95 pub u8,
97);
98
99impl core::fmt::Display for InvalidFinger {
100 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
101 write!(f, "{} is not a valid finger byte (expected 0..=10)", self.0)
102 }
103}
104
105impl std::error::Error for InvalidFinger {}
106
107impl From<Finger> for u8 {
108 fn from(finger: Finger) -> u8 {
110 finger as u8
111 }
112}
113
114impl TryFrom<u8> for Finger {
115 type Error = InvalidFinger;
116
117 fn try_from(v: u8) -> Result<Finger, InvalidFinger> {
120 Finger::from_u8(v).ok_or(InvalidFinger(v))
121 }
122}
123
124#[cfg(test)]
125mod tests {
126 use super::{Finger, InvalidFinger};
127
128 #[test]
129 fn byte_roundtrip_is_stable() {
130 for f in Finger::ALL {
131 assert_eq!(Finger::from_u8(f.as_u8()), Some(f));
132 }
133 assert_eq!(Finger::from_u8(0), Some(Finger::Unknown));
134 assert_eq!(Finger::from_u8(11), None);
135 }
136
137 #[test]
140 fn std_conversions_agree_with_inherent_methods() {
141 for v in u8::MIN..=u8::MAX {
142 assert_eq!(
143 Finger::try_from(v).ok(),
144 Finger::from_u8(v),
145 "try_from({v})"
146 );
147 match Finger::try_from(v) {
148 Ok(f) => assert_eq!(u8::from(f), v, "u8::from round-trip for {f:?}"),
149 Err(e) => assert_eq!(e, InvalidFinger(v), "error carries the byte"),
150 }
151 }
152 for f in Finger::ALL.iter().chain(&[Finger::Unknown]) {
154 assert_eq!(u8::from(*f), f.as_u8());
155 }
156 }
157
158 #[test]
161 fn from_u8_accepts_exactly_zero_through_ten() {
162 for v in u8::MIN..=u8::MAX {
163 let decoded = Finger::from_u8(v);
164 assert_eq!(decoded.is_some(), v <= 10, "from_u8({v}) = {decoded:?}");
165 if let Some(f) = decoded {
167 assert_eq!(f.as_u8(), v);
168 }
169 }
170 }
171
172 #[test]
174 fn all_lists_the_ten_real_fingers_in_byte_order() {
175 let bytes: Vec<u8> = Finger::ALL.iter().map(|f| f.as_u8()).collect();
176 assert_eq!(bytes, (1..=10).collect::<Vec<u8>>());
177 assert!(!Finger::ALL.contains(&Finger::Unknown));
178 }
179
180 #[test]
181 fn discriminants_match_libfprint() {
182 assert_eq!(Finger::LeftThumb.as_u8(), 1);
184 assert_eq!(Finger::RightLittle.as_u8(), 10);
185 assert_eq!(Finger::FIRST, Finger::LeftThumb);
186 assert_eq!(Finger::LAST, Finger::RightLittle);
187 }
188}