120 lines
2.8 KiB
Rust
120 lines
2.8 KiB
Rust
use serde::Serialize;
|
|
use serde::{Deserialize, Deserializer, Serializer};
|
|
use std::str::FromStr;
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
|
|
pub struct Date {
|
|
pub year: u16,
|
|
pub month: u8,
|
|
pub day: u8,
|
|
}
|
|
|
|
impl Date {
|
|
#[cfg(test)]
|
|
pub fn new(year: u16, month: u8, day: u8) -> Self {
|
|
Date { year, month, day }
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub enum DateParseError {
|
|
InvalidNumber,
|
|
MonthOutOfRange,
|
|
DayOutOfRange,
|
|
WrongFormat,
|
|
}
|
|
|
|
impl FromStr for Date {
|
|
type Err = DateParseError;
|
|
|
|
fn from_str(input: &str) -> Result<Date, DateParseError> {
|
|
let mut parts = input.splitn(3, "-");
|
|
|
|
let year = parts
|
|
.next()
|
|
.ok_or(DateParseError::WrongFormat)?
|
|
.parse::<u16>()
|
|
.map_err(|_| DateParseError::InvalidNumber)?;
|
|
|
|
let month = parts
|
|
.next()
|
|
.ok_or(DateParseError::WrongFormat)?
|
|
.parse::<u8>()
|
|
.map_err(|_| DateParseError::InvalidNumber)?;
|
|
|
|
let day = parts
|
|
.next()
|
|
.ok_or(DateParseError::WrongFormat)?
|
|
.parse::<u8>()
|
|
.map_err(|_| DateParseError::InvalidNumber)?;
|
|
|
|
if month > 12 {
|
|
return Err(DateParseError::DayOutOfRange);
|
|
}
|
|
|
|
if day > 31 {
|
|
return Err(DateParseError::MonthOutOfRange);
|
|
}
|
|
|
|
Ok(Date { year, month, day })
|
|
}
|
|
}
|
|
|
|
impl Serialize for Date {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let data = (self.year, self.month, self.day);
|
|
|
|
data.serialize(serializer)
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Date {
|
|
fn deserialize<D>(deserializer: D) -> Result<Date, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
let data = <(u16, u8, u8)>::deserialize(deserializer)?;
|
|
|
|
Ok(Date {
|
|
year: data.0,
|
|
month: data.1,
|
|
day: data.2,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn order() {
|
|
// Other Test not needed, since the Ord is derived.
|
|
assert!(Date::new(2019, 10, 10) > Date::new(2018, 10, 10));
|
|
assert!(Date::new(2018, 11, 10) > Date::new(2018, 10, 10));
|
|
assert!(Date::new(2018, 10, 11) > Date::new(2018, 10, 10));
|
|
}
|
|
|
|
#[test]
|
|
fn from_str() {
|
|
assert_eq!(Ok(Date::new(2019, 10, 10)), Date::from_str("2019-10-10"));
|
|
|
|
assert_eq!(Ok(Date::new(2019, 1, 1)), Date::from_str("2019-1-1"));
|
|
|
|
assert!(Date::from_str("2019-1-1-444").is_err());
|
|
|
|
assert_eq!(
|
|
Ok(Date::new(2019, 1, 1)),
|
|
Date::from_str("2019-0000000000001-00000001")
|
|
);
|
|
|
|
assert!(Date::from_str("XXX-400-400").is_err());
|
|
|
|
assert!(Date::from_str("400-400-400").is_err());
|
|
}
|
|
|
|
}
|