use serde::{Deserialize, Serialize};
use crate::error::{TypeError, TypeResult};
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct Passport(String);
impl Passport {
pub const SERIES_LEN: usize = 2;
pub const NUMBER_LEN: usize = 7;
pub const LEN: usize = Self::SERIES_LEN + Self::NUMBER_LEN;
pub fn parse(value: impl AsRef<str>) -> TypeResult<Self> {
let raw = value.as_ref().trim();
if raw.len() != Self::LEN {
return Err(TypeError::validation(format!(
"passport must contain exactly {} characters, got {}: {raw}",
Self::LEN,
raw.len(),
)));
}
let (series, number) = raw.split_at(Self::SERIES_LEN);
if !series.bytes().all(|b| b.is_ascii_alphabetic()) {
return Err(TypeError::validation(format!(
"passport series must contain exactly 2 ASCII letters: {raw}",
)));
}
if !number.bytes().all(|b| b.is_ascii_digit()) {
return Err(TypeError::validation(format!(
"passport number must contain exactly 7 digits: {raw}",
)));
}
Ok(Self(format!("{}{}", series.to_ascii_uppercase(), number)))
}
#[inline]
pub fn as_str(&self) -> &str {
&self.0
}
#[inline]
pub fn series(&self) -> &str {
&self.0[..Self::SERIES_LEN]
}
#[inline]
pub fn number(&self) -> &str {
&self.0[Self::SERIES_LEN..]
}
#[inline]
pub fn into_inner(self) -> String {
self.0
}
}
impl AsRef<str> for Passport {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::borrow::Borrow<str> for Passport {
fn borrow(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for Passport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl TryFrom<&str> for Passport {
type Error = TypeError;
fn try_from(value: &str) -> TypeResult<Self> {
Self::parse(value)
}
}
impl TryFrom<String> for Passport {
type Error = TypeError;
fn try_from(value: String) -> TypeResult<Self> {
Self::try_from(value.as_str())
}
}
impl From<Passport> for String {
fn from(value: Passport) -> Self {
value.into_inner()
}
}