Coverage Report

Created: 2025-08-28 06:06

/rust/registry/src/index.crates.io-6f17d22bba15001f/time-0.3.14/src/weekday.rs
Line
Count
Source (jump to first uncovered line)
1
//! Days of the week.
2
3
use core::fmt::{self, Display};
4
use core::str::FromStr;
5
6
use Weekday::*;
7
8
use crate::error;
9
10
/// Days of the week.
11
///
12
/// As order is dependent on context (Sunday could be either two days after or five days before
13
/// Friday), this type does not implement `PartialOrd` or `Ord`.
14
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
15
pub enum Weekday {
16
    #[allow(clippy::missing_docs_in_private_items)]
17
    Monday,
18
    #[allow(clippy::missing_docs_in_private_items)]
19
    Tuesday,
20
    #[allow(clippy::missing_docs_in_private_items)]
21
    Wednesday,
22
    #[allow(clippy::missing_docs_in_private_items)]
23
    Thursday,
24
    #[allow(clippy::missing_docs_in_private_items)]
25
    Friday,
26
    #[allow(clippy::missing_docs_in_private_items)]
27
    Saturday,
28
    #[allow(clippy::missing_docs_in_private_items)]
29
    Sunday,
30
}
31
32
impl Weekday {
33
    /// Get the previous weekday.
34
    ///
35
    /// ```rust
36
    /// # use time::Weekday;
37
    /// assert_eq!(Weekday::Tuesday.previous(), Weekday::Monday);
38
    /// ```
39
0
    pub const fn previous(self) -> Self {
40
0
        match self {
41
0
            Monday => Sunday,
42
0
            Tuesday => Monday,
43
0
            Wednesday => Tuesday,
44
0
            Thursday => Wednesday,
45
0
            Friday => Thursday,
46
0
            Saturday => Friday,
47
0
            Sunday => Saturday,
48
        }
49
0
    }
50
51
    /// Get the next weekday.
52
    ///
53
    /// ```rust
54
    /// # use time::Weekday;
55
    /// assert_eq!(Weekday::Monday.next(), Weekday::Tuesday);
56
    /// ```
57
0
    pub const fn next(self) -> Self {
58
0
        match self {
59
0
            Monday => Tuesday,
60
0
            Tuesday => Wednesday,
61
0
            Wednesday => Thursday,
62
0
            Thursday => Friday,
63
0
            Friday => Saturday,
64
0
            Saturday => Sunday,
65
0
            Sunday => Monday,
66
        }
67
0
    }
68
69
    /// Get the one-indexed number of days from Monday.
70
    ///
71
    /// ```rust
72
    /// # use time::Weekday;
73
    /// assert_eq!(Weekday::Monday.number_from_monday(), 1);
74
    /// ```
75
    #[doc(alias = "iso_weekday_number")]
76
0
    pub const fn number_from_monday(self) -> u8 {
77
0
        self.number_days_from_monday() + 1
78
0
    }
79
80
    /// Get the one-indexed number of days from Sunday.
81
    ///
82
    /// ```rust
83
    /// # use time::Weekday;
84
    /// assert_eq!(Weekday::Monday.number_from_sunday(), 2);
85
    /// ```
86
0
    pub const fn number_from_sunday(self) -> u8 {
87
0
        self.number_days_from_sunday() + 1
88
0
    }
89
90
    /// Get the zero-indexed number of days from Monday.
91
    ///
92
    /// ```rust
93
    /// # use time::Weekday;
94
    /// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);
95
    /// ```
96
0
    pub const fn number_days_from_monday(self) -> u8 {
97
0
        self as _
98
0
    }
99
100
    /// Get the zero-indexed number of days from Sunday.
101
    ///
102
    /// ```rust
103
    /// # use time::Weekday;
104
    /// assert_eq!(Weekday::Monday.number_days_from_sunday(), 1);
105
    /// ```
106
0
    pub const fn number_days_from_sunday(self) -> u8 {
107
0
        match self {
108
0
            Monday => 1,
109
0
            Tuesday => 2,
110
0
            Wednesday => 3,
111
0
            Thursday => 4,
112
0
            Friday => 5,
113
0
            Saturday => 6,
114
0
            Sunday => 0,
115
        }
116
0
    }
117
}
118
119
impl Display for Weekday {
120
0
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
121
0
        f.write_str(match self {
122
0
            Monday => "Monday",
123
0
            Tuesday => "Tuesday",
124
0
            Wednesday => "Wednesday",
125
0
            Thursday => "Thursday",
126
0
            Friday => "Friday",
127
0
            Saturday => "Saturday",
128
0
            Sunday => "Sunday",
129
        })
130
0
    }
131
}
132
133
impl FromStr for Weekday {
134
    type Err = error::InvalidVariant;
135
136
0
    fn from_str(s: &str) -> Result<Self, Self::Err> {
137
0
        match s {
138
0
            "Monday" => Ok(Monday),
139
0
            "Tuesday" => Ok(Tuesday),
140
0
            "Wednesday" => Ok(Wednesday),
141
0
            "Thursday" => Ok(Thursday),
142
0
            "Friday" => Ok(Friday),
143
0
            "Saturday" => Ok(Saturday),
144
0
            "Sunday" => Ok(Sunday),
145
0
            _ => Err(error::InvalidVariant),
146
        }
147
0
    }
148
}