use std::fmt;
use std::str::FromStr;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Sex {
Male,
Female,
Unspecified,
NonConformant(char),
}
impl Sex {
pub fn from_zone(c: char) -> Sex {
match c {
'M' => Sex::Male,
'F' => Sex::Female,
'<' => Sex::Unspecified,
other => Sex::NonConformant(other),
}
}
pub fn zone_char(self) -> char {
match self {
Sex::Male => 'M',
Sex::Female => 'F',
Sex::Unspecified => '<',
Sex::NonConformant(c) => c,
}
}
}
impl fmt::Display for Sex {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.zone_char())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct ParseSexError;
impl fmt::Display for ParseSexError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("an MRZ sex value is exactly one character of 0-9, A-Z or <")
}
}
impl std::error::Error for ParseSexError {}
impl FromStr for Sex {
type Err = ParseSexError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
let mut chars = text.chars();
match (chars.next(), chars.next()) {
(Some(c), None) if crate::checksum::char_value(c).is_some() => Ok(Sex::from_zone(c)),
_ => Err(ParseSexError),
}
}
}
#[cfg(feature = "serde")]
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
impl serde::Serialize for Sex {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.collect_str(self)
}
}
#[cfg(feature = "serde")]
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
impl<'de> serde::Deserialize<'de> for Sex {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let text = String::deserialize(deserializer)?;
text.parse().map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "zeroize")]
#[cfg_attr(docsrs, doc(cfg(feature = "zeroize")))]
impl zeroize::Zeroize for Sex {
fn zeroize(&mut self) {
*self = Sex::NonConformant('\0');
if let Sex::NonConformant(c) = self {
c.zeroize();
}
std::hint::black_box(&*self);
}
}