1use core::fmt;
2
3#[cfg(any(feature = "rkyv", feature = "rkyv-16", feature = "rkyv-32", feature = "rkyv-64"))]
4use rkyv::{Archive, Deserialize, Serialize};
5
6use crate::OutOfRange;
7
8/// The day of week.
9///
10/// The order of the days of week depends on the context.
11/// (This is why this type does *not* implement `PartialOrd` or `Ord` traits.)
12/// One should prefer `*_from_monday` or `*_from_sunday` methods to get the correct result.
13///
14/// # Example
15/// ```
16/// use chrono::Weekday;
17///
18/// let monday = "Monday".parse::<Weekday>().unwrap();
19/// assert_eq!(monday, Weekday::Mon);
20///
21/// let sunday = Weekday::try_from(6).unwrap();
22/// assert_eq!(sunday, Weekday::Sun);
23///
24/// assert_eq!(sunday.num_days_from_monday(), 6); // starts counting with Monday = 0
25/// assert_eq!(sunday.number_from_monday(), 7); // starts counting with Monday = 1
26/// assert_eq!(sunday.num_days_from_sunday(), 0); // starts counting with Sunday = 0
27/// assert_eq!(sunday.number_from_sunday(), 1); // starts counting with Sunday = 1
28///
29/// assert_eq!(sunday.succ(), monday);
30/// assert_eq!(sunday.pred(), Weekday::Sat);
31/// ```
32#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
33#[cfg_attr(
34 any(feature = "rkyv", feature = "rkyv-16", feature = "rkyv-32", feature = "rkyv-64"),
35 derive(Archive, Deserialize, Serialize),
36 archive(compare(PartialEq)),
37 archive_attr(derive(Clone, Copy, PartialEq, Eq, Debug, Hash))
38)]
39#[cfg_attr(feature = "rkyv-validation", archive(check_bytes))]
40#[cfg_attr(all(feature = "arbitrary", feature = "std"), derive(arbitrary::Arbitrary))]
41pub enum Weekday {
42 /// Monday.
43 Mon = 0,
44 /// Tuesday.
45 Tue = 1,
46 /// Wednesday.
47 Wed = 2,
48 /// Thursday.
49 Thu = 3,
50 /// Friday.
51 Fri = 4,
52 /// Saturday.
53 Sat = 5,
54 /// Sunday.
55 Sun = 6,
56}
57
58impl Weekday {
59 /// The next day in the week.
60 ///
61 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
62 /// ----------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
63 /// `w.succ()`: | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun` | `Mon`
64 #[inline]
65 #[must_use]
66 pub const fn succ(&self) -> Weekday {
67 match *self {
68 Weekday::Mon => Weekday::Tue,
69 Weekday::Tue => Weekday::Wed,
70 Weekday::Wed => Weekday::Thu,
71 Weekday::Thu => Weekday::Fri,
72 Weekday::Fri => Weekday::Sat,
73 Weekday::Sat => Weekday::Sun,
74 Weekday::Sun => Weekday::Mon,
75 }
76 }
77
78 /// The previous day in the week.
79 ///
80 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
81 /// ----------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
82 /// `w.pred()`: | `Sun` | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat`
83 #[inline]
84 #[must_use]
85 pub const fn pred(&self) -> Weekday {
86 match *self {
87 Weekday::Mon => Weekday::Sun,
88 Weekday::Tue => Weekday::Mon,
89 Weekday::Wed => Weekday::Tue,
90 Weekday::Thu => Weekday::Wed,
91 Weekday::Fri => Weekday::Thu,
92 Weekday::Sat => Weekday::Fri,
93 Weekday::Sun => Weekday::Sat,
94 }
95 }
96
97 /// Returns a day-of-week number starting from Monday = 1. (ISO 8601 weekday number)
98 ///
99 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
100 /// ------------------------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
101 /// `w.number_from_monday()`: | 1 | 2 | 3 | 4 | 5 | 6 | 7
102 #[inline]
103 pub const fn number_from_monday(&self) -> u32 {
104 self.days_since(Weekday::Mon) + 1
105 }
106
107 /// Returns a day-of-week number starting from Sunday = 1.
108 ///
109 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
110 /// ------------------------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
111 /// `w.number_from_sunday()`: | 2 | 3 | 4 | 5 | 6 | 7 | 1
112 #[inline]
113 pub const fn number_from_sunday(&self) -> u32 {
114 self.days_since(Weekday::Sun) + 1
115 }
116
117 /// Returns a day-of-week number starting from Monday = 0.
118 ///
119 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
120 /// --------------------------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
121 /// `w.num_days_from_monday()`: | 0 | 1 | 2 | 3 | 4 | 5 | 6
122 ///
123 /// # Example
124 ///
125 /// ```
126 /// # #[cfg(feature = "clock")] {
127 /// # use chrono::{Local, Datelike};
128 /// // MTWRFSU is occasionally used as a single-letter abbreviation of the weekdays.
129 /// // Use `num_days_from_monday` to index into the array.
130 /// const MTWRFSU: [char; 7] = ['M', 'T', 'W', 'R', 'F', 'S', 'U'];
131 ///
132 /// let today = Local::now().weekday();
133 /// println!("{}", MTWRFSU[today.num_days_from_monday() as usize]);
134 /// # }
135 /// ```
136 #[inline]
137 pub const fn num_days_from_monday(&self) -> u32 {
138 self.days_since(Weekday::Mon)
139 }
140
141 /// Returns a day-of-week number starting from Sunday = 0.
142 ///
143 /// `w`: | `Mon` | `Tue` | `Wed` | `Thu` | `Fri` | `Sat` | `Sun`
144 /// --------------------------- | ----- | ----- | ----- | ----- | ----- | ----- | -----
145 /// `w.num_days_from_sunday()`: | 1 | 2 | 3 | 4 | 5 | 6 | 0
146 #[inline]
147 pub const fn num_days_from_sunday(&self) -> u32 {
148 self.days_since(Weekday::Sun)
149 }
150
151 /// The number of days since the given day.
152 ///
153 /// # Examples
154 ///
155 /// ```
156 /// use chrono::Weekday::*;
157 /// assert_eq!(Mon.days_since(Mon), 0);
158 /// assert_eq!(Sun.days_since(Tue), 5);
159 /// assert_eq!(Wed.days_since(Sun), 3);
160 /// ```
161 pub const fn days_since(&self, other: Weekday) -> u32 {
162 let lhs = *self as u32;
163 let rhs = other as u32;
164 if lhs < rhs { 7 + lhs - rhs } else { lhs - rhs }
165 }
166}
167
168impl fmt::Display for Weekday {
169 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
170 f.pad(match *self {
171 Weekday::Mon => "Mon",
172 Weekday::Tue => "Tue",
173 Weekday::Wed => "Wed",
174 Weekday::Thu => "Thu",
175 Weekday::Fri => "Fri",
176 Weekday::Sat => "Sat",
177 Weekday::Sun => "Sun",
178 })
179 }
180}
181
182/// Any weekday can be represented as an integer from 0 to 6, which equals to
183/// [`Weekday::num_days_from_monday`](#method.num_days_from_monday) in this implementation.
184/// Do not heavily depend on this though; use explicit methods whenever possible.
185impl TryFrom<u8> for Weekday {
186 type Error = OutOfRange;
187
188 fn try_from(value: u8) -> Result<Self, Self::Error> {
189 match value {
190 0 => Ok(Weekday::Mon),
191 1 => Ok(Weekday::Tue),
192 2 => Ok(Weekday::Wed),
193 3 => Ok(Weekday::Thu),
194 4 => Ok(Weekday::Fri),
195 5 => Ok(Weekday::Sat),
196 6 => Ok(Weekday::Sun),
197 _ => Err(OutOfRange::new()),
198 }
199 }
200}
201
202/// Any weekday can be represented as an integer from 0 to 6, which equals to
203/// [`Weekday::num_days_from_monday`](#method.num_days_from_monday) in this implementation.
204/// Do not heavily depend on this though; use explicit methods whenever possible.
205impl num_traits::FromPrimitive for Weekday {
206 #[inline]
207 fn from_i64(n: i64) -> Option<Weekday> {
208 match n {
209 0 => Some(Weekday::Mon),
210 1 => Some(Weekday::Tue),
211 2 => Some(Weekday::Wed),
212 3 => Some(Weekday::Thu),
213 4 => Some(Weekday::Fri),
214 5 => Some(Weekday::Sat),
215 6 => Some(Weekday::Sun),
216 _ => None,
217 }
218 }
219
220 #[inline]
221 fn from_u64(n: u64) -> Option<Weekday> {
222 match n {
223 0 => Some(Weekday::Mon),
224 1 => Some(Weekday::Tue),
225 2 => Some(Weekday::Wed),
226 3 => Some(Weekday::Thu),
227 4 => Some(Weekday::Fri),
228 5 => Some(Weekday::Sat),
229 6 => Some(Weekday::Sun),
230 _ => None,
231 }
232 }
233}
234
235/// An error resulting from reading `Weekday` value with `FromStr`.
236#[derive(Clone, PartialEq, Eq)]
237pub struct ParseWeekdayError {
238 pub(crate) _dummy: (),
239}
240
241#[cfg(feature = "std")]
242impl std::error::Error for ParseWeekdayError {}
243
244impl fmt::Display for ParseWeekdayError {
245 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
246 f.write_fmt(format_args!("{:?}", self))
247 }
248}
249
250impl fmt::Debug for ParseWeekdayError {
251 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
252 write!(f, "ParseWeekdayError {{ .. }}")
253 }
254}
255
256// the actual `FromStr` implementation is in the `format` module to leverage the existing code
257
258#[cfg(feature = "serde")]
259mod weekday_serde {
260 use super::Weekday;
261 use core::fmt;
262 use serde::{de, ser};
263
264 impl ser::Serialize for Weekday {
265 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
266 where
267 S: ser::Serializer,
268 {
269 serializer.collect_str(&self)
270 }
271 }
272
273 struct WeekdayVisitor;
274
275 impl de::Visitor<'_> for WeekdayVisitor {
276 type Value = Weekday;
277
278 fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
279 f.write_str("Weekday")
280 }
281
282 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
283 where
284 E: de::Error,
285 {
286 value.parse().map_err(|_| E::custom("short or long weekday names expected"))
287 }
288 }
289
290 impl<'de> de::Deserialize<'de> for Weekday {
291 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
292 where
293 D: de::Deserializer<'de>,
294 {
295 deserializer.deserialize_str(WeekdayVisitor)
296 }
297 }
298}
299
300#[cfg(test)]
301mod tests {
302 use super::Weekday;
303
304 #[test]
305 fn test_days_since() {
306 for i in 0..7 {
307 let base_day = Weekday::try_from(i).unwrap();
308
309 assert_eq!(base_day.num_days_from_monday(), base_day.days_since(Weekday::Mon));
310 assert_eq!(base_day.num_days_from_sunday(), base_day.days_since(Weekday::Sun));
311
312 assert_eq!(base_day.days_since(base_day), 0);
313
314 assert_eq!(base_day.days_since(base_day.pred()), 1);
315 assert_eq!(base_day.days_since(base_day.pred().pred()), 2);
316 assert_eq!(base_day.days_since(base_day.pred().pred().pred()), 3);
317 assert_eq!(base_day.days_since(base_day.pred().pred().pred().pred()), 4);
318 assert_eq!(base_day.days_since(base_day.pred().pred().pred().pred().pred()), 5);
319 assert_eq!(base_day.days_since(base_day.pred().pred().pred().pred().pred().pred()), 6);
320
321 assert_eq!(base_day.days_since(base_day.succ()), 6);
322 assert_eq!(base_day.days_since(base_day.succ().succ()), 5);
323 assert_eq!(base_day.days_since(base_day.succ().succ().succ()), 4);
324 assert_eq!(base_day.days_since(base_day.succ().succ().succ().succ()), 3);
325 assert_eq!(base_day.days_since(base_day.succ().succ().succ().succ().succ()), 2);
326 assert_eq!(base_day.days_since(base_day.succ().succ().succ().succ().succ().succ()), 1);
327 }
328 }
329
330 #[test]
331 fn test_formatting_alignment() {
332 // No exhaustive testing here as we just delegate the
333 // implementation to Formatter::pad. Just some basic smoke
334 // testing to ensure that it's in fact being done.
335 assert_eq!(format!("{:x>7}", Weekday::Mon), "xxxxMon");
336 assert_eq!(format!("{:^7}", Weekday::Mon), " Mon ");
337 assert_eq!(format!("{:Z<7}", Weekday::Mon), "MonZZZZ");
338 }
339
340 #[test]
341 #[cfg(feature = "serde")]
342 fn test_serde_serialize() {
343 use Weekday::*;
344 use serde_json::to_string;
345
346 let cases: Vec<(Weekday, &str)> = vec![
347 (Mon, "\"Mon\""),
348 (Tue, "\"Tue\""),
349 (Wed, "\"Wed\""),
350 (Thu, "\"Thu\""),
351 (Fri, "\"Fri\""),
352 (Sat, "\"Sat\""),
353 (Sun, "\"Sun\""),
354 ];
355
356 for (weekday, expected_str) in cases {
357 let string = to_string(&weekday).unwrap();
358 assert_eq!(string, expected_str);
359 }
360 }
361
362 #[test]
363 #[cfg(feature = "serde")]
364 fn test_serde_deserialize() {
365 use Weekday::*;
366 use serde_json::from_str;
367
368 let cases: Vec<(&str, Weekday)> = vec![
369 ("\"mon\"", Mon),
370 ("\"MONDAY\"", Mon),
371 ("\"MonDay\"", Mon),
372 ("\"mOn\"", Mon),
373 ("\"tue\"", Tue),
374 ("\"tuesday\"", Tue),
375 ("\"wed\"", Wed),
376 ("\"wednesday\"", Wed),
377 ("\"thu\"", Thu),
378 ("\"thursday\"", Thu),
379 ("\"fri\"", Fri),
380 ("\"friday\"", Fri),
381 ("\"sat\"", Sat),
382 ("\"saturday\"", Sat),
383 ("\"sun\"", Sun),
384 ("\"sunday\"", Sun),
385 ];
386
387 for (str, expected_weekday) in cases {
388 let weekday = from_str::<Weekday>(str).unwrap();
389 assert_eq!(weekday, expected_weekday);
390 }
391
392 let errors: Vec<&str> =
393 vec!["\"not a weekday\"", "\"monDAYs\"", "\"mond\"", "mon", "\"thur\"", "\"thurs\""];
394
395 for str in errors {
396 from_str::<Weekday>(str).unwrap_err();
397 }
398 }
399
400 #[test]
401 #[cfg(feature = "rkyv-validation")]
402 fn test_rkyv_validation() {
403 let mon = Weekday::Mon;
404 let bytes = rkyv::to_bytes::<_, 1>(&mon).unwrap();
405
406 assert_eq!(rkyv::from_bytes::<Weekday>(&bytes).unwrap(), mon);
407 }
408}
409