libtad-models 0.2.0

Time and Date API models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use serde::{Deserialize, Deserializer, Serialize, Serializer};

#[derive(Debug, Default, Clone, Copy, PartialEq, Deserialize)]
#[serde(default)]
/// Date and time, split up into components.
pub struct DateTime {
    /// The year component of the timestamp.
    pub year: i32,

    /// The month component of the timestamp.
    pub month: i32,

    /// The day component of the timestamp.
    pub day: i32,

    /// The hour component of the timestamp.
    pub hour: i32,

    /// The minute component of the timestamp.
    pub minute: i32,

    /// The second component of the timestamp.
    pub second: i32,
}

impl Serialize for DateTime {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl DateTime {
    pub(crate) fn option_deserialize_from_str<'a, D>(
        deserializer: D,
    ) -> Result<Option<Self>, D::Error>
    where
        D: Deserializer<'a>,
    {
        let s: Option<String> = Option::deserialize(deserializer)?;
        if let Some(inner) = s {
            Ok(Some(DateTime::from(&inner)))
        } else {
            Ok(None)
        }
    }

    pub(crate) fn deserialize_from_str<'a, D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'a>,
    {
        let s = String::deserialize(deserializer)?;

        Ok(DateTime::from(&s))
    }
}

impl std::fmt::Display for DateTime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}",
            self.year, self.month, self.day, self.hour, self.minute, self.second
        )
    }
}

impl<A: AsRef<str>> From<A> for DateTime {
    fn from(s: A) -> Self {
        fn alt(s: &str) -> (&str, &str) {
            if let Some(d) = s.split_once('-') {
                return d;
            }

            if let Some(m) = s.split_once('T') {
                return m;
            }

            if let Some(t) = s.split_once(':') {
                return t;
            }

            (s, "")
        }

        let (year, rest) = alt(s.as_ref());
        let (month, rest) = alt(rest);
        let (day, rest) = alt(rest);
        let (hour, rest) = alt(rest);
        let (minute, rest) = alt(rest);
        let (second, _) = alt(rest);

        Self {
            year: year.parse().unwrap_or_default(),
            month: month.parse().unwrap_or_default(),
            day: day.parse().unwrap_or_default(),
            hour: hour.parse().unwrap_or_default(),
            minute: minute.parse().unwrap_or_default(),
            second: second.parse().unwrap_or_default(),
        }
    }
}

#[test]
fn parse_datetime() {
    let datetime_str = "2021-04-04T16:42:21";

    let datetime = DateTime::from(datetime_str.to_string());

    assert!(datetime.year == 2021);
    assert!(datetime.month == 4);
    assert!(datetime.day == 4);
    assert!(datetime.hour == 16);
    assert!(datetime.minute == 42);
    assert!(datetime.second == 21);
}

#[test]
fn parse_date_only() {
    let datetime_str = "2021-04-04";

    let datetime = DateTime::from(datetime_str.to_string());

    assert!(datetime.year == 2021);
    assert!(datetime.month == 4);
    assert!(datetime.day == 4);
    assert!(datetime.hour == 0);
    assert!(datetime.minute == 0);
    assert!(datetime.second == 0);
}