/rust/registry/src/index.crates.io-1949cf8c6b5b557f/time-0.3.44/src/weekday.rs

Source
//! Days of the week.

use core::fmt;
use core::str::FromStr;

use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};

use self::Weekday::*;
use crate::error;

/// Days of the week.
///
/// As order is dependent on context (Sunday could be either two days after or five days before
/// Friday), this type does not implement `PartialOrd` or `Ord`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Weekday {
    #[expect(missing_docs)]
    Monday,
    #[expect(missing_docs)]
    Tuesday,
    #[expect(missing_docs)]
    Wednesday,
    #[expect(missing_docs)]
    Thursday,
    #[expect(missing_docs)]
    Friday,
    #[expect(missing_docs)]
    Saturday,
    #[expect(missing_docs)]
    Sunday,
}

impl Weekday {
    /// Get the previous weekday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Tuesday.previous(), Weekday::Monday);
    /// ```
    #[inline]
    pub const fn previous(self) -> Self {
        match self {
            Monday => Sunday,
            Tuesday => Monday,
            Wednesday => Tuesday,
            Thursday => Wednesday,
            Friday => Thursday,
            Saturday => Friday,
            Sunday => Saturday,
        }
    }

    /// Get the next weekday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.next(), Weekday::Tuesday);
    /// ```
    #[inline]
    pub const fn next(self) -> Self {
        match self {
            Monday => Tuesday,
            Tuesday => Wednesday,
            Wednesday => Thursday,
            Thursday => Friday,
            Friday => Saturday,
            Saturday => Sunday,
            Sunday => Monday,
        }
    }

    /// Get n-th next day.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.nth_next(1), Weekday::Tuesday);
    /// assert_eq!(Weekday::Sunday.nth_next(10), Weekday::Wednesday);
    /// ```
    #[inline]
    pub const fn nth_next(self, n: u8) -> Self {
        match (self.number_days_from_monday() + n % 7) % 7 {
            0 => Monday,
            1 => Tuesday,
            2 => Wednesday,
            3 => Thursday,
            4 => Friday,
            5 => Saturday,
            val => {
                debug_assert!(val == 6);
                Sunday
            }
        }
    }

    /// Get n-th previous day.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.nth_prev(1), Weekday::Sunday);
    /// assert_eq!(Weekday::Sunday.nth_prev(10), Weekday::Thursday);
    /// ```
    #[inline]
    pub const fn nth_prev(self, n: u8) -> Self {
        match self.number_days_from_monday() as i8 - (n % 7) as i8 {
            1 | -6 => Tuesday,
            2 | -5 => Wednesday,
            3 | -4 => Thursday,
            4 | -3 => Friday,
            5 | -2 => Saturday,
            6 | -1 => Sunday,
            val => {
                debug_assert!(val == 0);
                Monday
            }
        }
    }

    /// Get the one-indexed number of days from Monday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.number_from_monday(), 1);
    /// ```
    #[doc(alias = "iso_weekday_number")]
    #[inline]
    pub const fn number_from_monday(self) -> u8 {
        self.number_days_from_monday() + 1
    }

    /// Get the one-indexed number of days from Sunday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.number_from_sunday(), 2);
    /// ```
    #[inline]
    pub const fn number_from_sunday(self) -> u8 {
        self.number_days_from_sunday() + 1
    }

    /// Get the zero-indexed number of days from Monday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);
    /// ```
    #[inline]
    pub const fn number_days_from_monday(self) -> u8 {
        self as u8
    }

    /// Get the zero-indexed number of days from Sunday.
    ///
    /// ```rust
    /// # use time::Weekday;
    /// assert_eq!(Weekday::Monday.number_days_from_sunday(), 1);
    /// ```
    #[inline]
    pub const fn number_days_from_sunday(self) -> u8 {
        match self {
            Monday => 1,
            Tuesday => 2,
            Wednesday => 3,
            Thursday => 4,
            Friday => 5,
            Saturday => 6,
            Sunday => 0,
        }
    }
}

mod private {
    #[non_exhaustive]
    #[derive(Debug, Clone, Copy)]
    pub struct WeekdayMetadata;
}
use private::WeekdayMetadata;

impl SmartDisplay for Weekday {
    type Metadata = WeekdayMetadata;

    #[inline]
    fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
        match self {
            Monday => Metadata::new(6, self, WeekdayMetadata),
            Tuesday => Metadata::new(7, self, WeekdayMetadata),
            Wednesday => Metadata::new(9, self, WeekdayMetadata),
            Thursday => Metadata::new(8, self, WeekdayMetadata),
            Friday => Metadata::new(6, self, WeekdayMetadata),
            Saturday => Metadata::new(8, self, WeekdayMetadata),
            Sunday => Metadata::new(6, self, WeekdayMetadata),
        }
    }

    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad(match self {
            Monday => "Monday",
            Tuesday => "Tuesday",
            Wednesday => "Wednesday",
            Thursday => "Thursday",
            Friday => "Friday",
            Saturday => "Saturday",
            Sunday => "Sunday",
        })
    }
}

impl fmt::Display for Weekday {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        SmartDisplay::fmt(self, f)
    }
}

impl FromStr for Weekday {
    type Err = error::InvalidVariant;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Monday" => Ok(Monday),
            "Tuesday" => Ok(Tuesday),
            "Wednesday" => Ok(Wednesday),
            "Thursday" => Ok(Thursday),
            "Friday" => Ok(Friday),
            "Saturday" => Ok(Saturday),
            "Sunday" => Ok(Sunday),
            _ => Err(error::InvalidVariant),
        }
    }
}

Coverage Report

Created: 2025-10-10 07:05

Line	Count	Source
1		//! Days of the week.
2
3		use core::fmt;
4		use core::str::FromStr;
5
6		use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};
7
8		use self::Weekday::*;
9		use crate::error;
10
11		/// Days of the week.
12		///
13		/// As order is dependent on context (Sunday could be either two days after or five days before
14		/// Friday), this type does not implement `PartialOrd` or `Ord`.
15		#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
16		pub enum Weekday {
17		#[expect(missing_docs)]
18		Monday,
19		#[expect(missing_docs)]
20		Tuesday,
21		#[expect(missing_docs)]
22		Wednesday,
23		#[expect(missing_docs)]
24		Thursday,
25		#[expect(missing_docs)]
26		Friday,
27		#[expect(missing_docs)]
28		Saturday,
29		#[expect(missing_docs)]
30		Sunday,
31		}
32
33		impl Weekday {
34		/// Get the previous weekday.
35		///
36		/// ```rust
37		/// # use time::Weekday;
38		/// assert_eq!(Weekday::Tuesday.previous(), Weekday::Monday);
39		/// ```
40		#[inline]
41	0	pub const fn previous(self) -> Self {
42	0	match self {
43	0	Monday => Sunday,
44	0	Tuesday => Monday,
45	0	Wednesday => Tuesday,
46	0	Thursday => Wednesday,
47	0	Friday => Thursday,
48	0	Saturday => Friday,
49	0	Sunday => Saturday,
50		}
51	0	}
52
53		/// Get the next weekday.
54		///
55		/// ```rust
56		/// # use time::Weekday;
57		/// assert_eq!(Weekday::Monday.next(), Weekday::Tuesday);
58		/// ```
59		#[inline]
60	0	pub const fn next(self) -> Self {
61	0	match self {
62	0	Monday => Tuesday,
63	0	Tuesday => Wednesday,
64	0	Wednesday => Thursday,
65	0	Thursday => Friday,
66	0	Friday => Saturday,
67	0	Saturday => Sunday,
68	0	Sunday => Monday,
69		}
70	0	}
71
72		/// Get n-th next day.
73		///
74		/// ```rust
75		/// # use time::Weekday;
76		/// assert_eq!(Weekday::Monday.nth_next(1), Weekday::Tuesday);
77		/// assert_eq!(Weekday::Sunday.nth_next(10), Weekday::Wednesday);
78		/// ```
79		#[inline]
80	0	pub const fn nth_next(self, n: u8) -> Self {
81	0	match (self.number_days_from_monday() + n % 7) % 7 {
82	0	0 => Monday,
83	0	1 => Tuesday,
84	0	2 => Wednesday,
85	0	3 => Thursday,
86	0	4 => Friday,
87	0	5 => Saturday,
88	0	val => {
89	0	debug_assert!(val == 6);
90	0	Sunday
91		}
92		}
93	0	}
94
95		/// Get n-th previous day.
96		///
97		/// ```rust
98		/// # use time::Weekday;
99		/// assert_eq!(Weekday::Monday.nth_prev(1), Weekday::Sunday);
100		/// assert_eq!(Weekday::Sunday.nth_prev(10), Weekday::Thursday);
101		/// ```
102		#[inline]
103	0	pub const fn nth_prev(self, n: u8) -> Self {
104	0	match self.number_days_from_monday() as i8 - (n % 7) as i8 {
105	0	1 \| -6 => Tuesday,
106	0	2 \| -5 => Wednesday,
107	0	3 \| -4 => Thursday,
108	0	4 \| -3 => Friday,
109	0	5 \| -2 => Saturday,
110	0	6 \| -1 => Sunday,
111	0	val => {
112	0	debug_assert!(val == 0);
113	0	Monday
114		}
115		}
116	0	}
117
118		/// Get the one-indexed number of days from Monday.
119		///
120		/// ```rust
121		/// # use time::Weekday;
122		/// assert_eq!(Weekday::Monday.number_from_monday(), 1);
123		/// ```
124		#[doc(alias = "iso_weekday_number")]
125		#[inline]
126	0	pub const fn number_from_monday(self) -> u8 {
127	0	self.number_days_from_monday() + 1
128	0	}
129
130		/// Get the one-indexed number of days from Sunday.
131		///
132		/// ```rust
133		/// # use time::Weekday;
134		/// assert_eq!(Weekday::Monday.number_from_sunday(), 2);
135		/// ```
136		#[inline]
137	0	pub const fn number_from_sunday(self) -> u8 {
138	0	self.number_days_from_sunday() + 1
139	0	}
140
141		/// Get the zero-indexed number of days from Monday.
142		///
143		/// ```rust
144		/// # use time::Weekday;
145		/// assert_eq!(Weekday::Monday.number_days_from_monday(), 0);
146		/// ```
147		#[inline]
148	0	pub const fn number_days_from_monday(self) -> u8 {
149	0	self as u8
150	0	}
151
152		/// Get the zero-indexed number of days from Sunday.
153		///
154		/// ```rust
155		/// # use time::Weekday;
156		/// assert_eq!(Weekday::Monday.number_days_from_sunday(), 1);
157		/// ```
158		#[inline]
159	0	pub const fn number_days_from_sunday(self) -> u8 {
160	0	match self {
161	0	Monday => 1,
162	0	Tuesday => 2,
163	0	Wednesday => 3,
164	0	Thursday => 4,
165	0	Friday => 5,
166	0	Saturday => 6,
167	0	Sunday => 0,
168		}
169	0	}
170		}
171
172		mod private {
173		#[non_exhaustive]
174		#[derive(Debug, Clone, Copy)]
175		pub struct WeekdayMetadata;
176		}
177		use private::WeekdayMetadata;
178
179		impl SmartDisplay for Weekday {
180		type Metadata = WeekdayMetadata;
181
182		#[inline]
183	0	fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
184	0	match self {
185	0	Monday => Metadata::new(6, self, WeekdayMetadata),
186	0	Tuesday => Metadata::new(7, self, WeekdayMetadata),
187	0	Wednesday => Metadata::new(9, self, WeekdayMetadata),
188	0	Thursday => Metadata::new(8, self, WeekdayMetadata),
189	0	Friday => Metadata::new(6, self, WeekdayMetadata),
190	0	Saturday => Metadata::new(8, self, WeekdayMetadata),
191	0	Sunday => Metadata::new(6, self, WeekdayMetadata),
192		}
193	0	}
194
195		#[inline]
196	0	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
197	0	f.pad(match self {
198	0	Monday => "Monday",
199	0	Tuesday => "Tuesday",
200	0	Wednesday => "Wednesday",
201	0	Thursday => "Thursday",
202	0	Friday => "Friday",
203	0	Saturday => "Saturday",
204	0	Sunday => "Sunday",
205		})
206	0	}
207		}
208
209		impl fmt::Display for Weekday {
210		#[inline]
211	0	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
212	0	SmartDisplay::fmt(self, f)
213	0	}
214		}
215
216		impl FromStr for Weekday {
217		type Err = error::InvalidVariant;
218
219		#[inline]
220	0	fn from_str(s: &str) -> Result<Self, Self::Err> {
221	0	match s {
222	0	"Monday" => Ok(Monday),
223	0	"Tuesday" => Ok(Tuesday),
224	0	"Wednesday" => Ok(Wednesday),
225	0	"Thursday" => Ok(Thursday),
226	0	"Friday" => Ok(Friday),
227	0	"Saturday" => Ok(Saturday),
228	0	"Sunday" => Ok(Sunday),
229	0	_ => Err(error::InvalidVariant),
230		}
231	0	}
232		}