tea_time/impls/
impl_time.rs

1use std::fmt;
2use std::str::FromStr;
3
4use chrono::Timelike;
5use tea_error::*;
6
7use crate::Time;
8
9impl fmt::Display for Time {
10    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
11        fmt::Debug::fmt(self, f)
12    }
13}
14
15impl FromStr for Time {
16    type Err = TError;
17    #[inline]
18    fn from_str(s: &str) -> TResult<Self> {
19        Self::parse(s, None)
20    }
21}
22
23impl From<i64> for Time {
24    #[inline]
25    fn from(value: i64) -> Self {
26        Self::from_i64(value)
27    }
28}
29
30impl From<Option<i64>> for Time {
31    #[inline]
32    fn from(value: Option<i64>) -> Self {
33        if let Some(value) = value {
34            Self::from(value)
35        } else {
36            Self::nat()
37        }
38    }
39}
40
41impl Timelike for Time {
42    #[inline]
43    fn hour(&self) -> u32 {
44        self.as_cr().unwrap().hour()
45    }
46
47    #[inline]
48    fn minute(&self) -> u32 {
49        self.as_cr().unwrap().minute()
50    }
51
52    #[inline]
53    fn second(&self) -> u32 {
54        self.as_cr().unwrap().second()
55    }
56
57    #[inline]
58    fn nanosecond(&self) -> u32 {
59        self.as_cr().unwrap().nanosecond()
60    }
61
62    #[inline]
63    fn with_hour(&self, hour: u32) -> Option<Self> {
64        if let Some(time) = self.as_cr() {
65            if let Some(time) = time.with_hour(hour) {
66                return Some(Self::from_cr(&time));
67            }
68        }
69        None
70    }
71
72    #[inline]
73    fn with_minute(&self, min: u32) -> Option<Self> {
74        if let Some(time) = self.as_cr() {
75            if let Some(time) = time.with_minute(min) {
76                return Some(Self::from_cr(&time));
77            }
78        }
79        None
80    }
81
82    #[inline]
83    fn with_second(&self, sec: u32) -> Option<Self> {
84        if let Some(time) = self.as_cr() {
85            if let Some(time) = time.with_second(sec) {
86                return Some(Self::from_cr(&time));
87            }
88        }
89        None
90    }
91
92    #[inline]
93    fn with_nanosecond(&self, nano: u32) -> Option<Self> {
94        if let Some(time) = self.as_cr() {
95            if let Some(time) = time.with_nanosecond(nano) {
96                return Some(Self::from_cr(&time));
97            }
98        }
99        None
100    }
101}
102
103#[cfg(test)]
104mod tests {
105    use super::*;
106
107    #[test]
108    fn test_time_getters() {
109        let time = Time::from_hms(12, 34, 56);
110        assert_eq!(time.hour(), 12);
111        assert_eq!(time.minute(), 34);
112        assert_eq!(time.second(), 56);
113        assert_eq!(time.nanosecond(), 0);
114    }
115
116    #[test]
117    fn test_time_with_methods() {
118        let time = Time::from_hms(12, 34, 56);
119
120        let new_time = time.with_hour(15).unwrap();
121        assert_eq!(new_time.hour(), 15);
122        assert_eq!(new_time.minute(), 34);
123        assert_eq!(new_time.second(), 56);
124
125        let new_time = time.with_minute(45).unwrap();
126        assert_eq!(new_time.hour(), 12);
127        assert_eq!(new_time.minute(), 45);
128        assert_eq!(new_time.second(), 56);
129
130        let new_time = time.with_second(30).unwrap();
131        assert_eq!(new_time.hour(), 12);
132        assert_eq!(new_time.minute(), 34);
133        assert_eq!(new_time.second(), 30);
134
135        let new_time = time.with_nanosecond(500_000_000).unwrap();
136        assert_eq!(new_time.hour(), 12);
137        assert_eq!(new_time.minute(), 34);
138        assert_eq!(new_time.second(), 56);
139        assert_eq!(new_time.nanosecond(), 500_000_000);
140    }
141
142    #[test]
143    fn test_invalid_time_modifications() {
144        let time = Time::from_hms(12, 34, 56);
145
146        assert!(time.with_hour(24).is_none());
147        assert!(time.with_minute(60).is_none());
148        assert!(time.with_second(60).is_none());
149        assert!(time.with_nanosecond(3_000_000_000).is_none());
150    }
151}
tea_time/impls/impl_time.rs

tea_time/impls/
impl_time.rs
