Coverage Report

Created: 2025-10-29 06:49

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/rust/registry/src/index.crates.io-1949cf8c6b5b557f/time-0.3.14/src/month.rs
Line
Count
Source
1
//! The `Month` enum and its associated `impl`s.
2
3
use core::fmt;
4
use core::num::NonZeroU8;
5
use core::str::FromStr;
6
7
use self::Month::*;
8
use crate::error;
9
10
/// Months of the year.
11
#[allow(clippy::missing_docs_in_private_items)] // variants
12
#[repr(u8)]
13
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
14
pub enum Month {
15
    January = 1,
16
    February = 2,
17
    March = 3,
18
    April = 4,
19
    May = 5,
20
    June = 6,
21
    July = 7,
22
    August = 8,
23
    September = 9,
24
    October = 10,
25
    November = 11,
26
    December = 12,
27
}
28
29
impl Month {
30
    /// Create a `Month` from its numerical value.
31
0
    pub(crate) const fn from_number(n: NonZeroU8) -> Result<Self, error::ComponentRange> {
32
0
        match n.get() {
33
0
            1 => Ok(January),
34
0
            2 => Ok(February),
35
0
            3 => Ok(March),
36
0
            4 => Ok(April),
37
0
            5 => Ok(May),
38
0
            6 => Ok(June),
39
0
            7 => Ok(July),
40
0
            8 => Ok(August),
41
0
            9 => Ok(September),
42
0
            10 => Ok(October),
43
0
            11 => Ok(November),
44
0
            12 => Ok(December),
45
0
            n => Err(error::ComponentRange {
46
0
                name: "month",
47
0
                minimum: 1,
48
0
                maximum: 12,
49
0
                value: n as _,
50
0
                conditional_range: false,
51
0
            }),
52
        }
53
0
    }
54
55
    /// Get the previous month.
56
    ///
57
    /// ```rust
58
    /// # use time::Month;
59
    /// assert_eq!(Month::January.previous(), Month::December);
60
    /// ```
61
0
    pub const fn previous(self) -> Self {
62
0
        match self {
63
0
            January => December,
64
0
            February => January,
65
0
            March => February,
66
0
            April => March,
67
0
            May => April,
68
0
            June => May,
69
0
            July => June,
70
0
            August => July,
71
0
            September => August,
72
0
            October => September,
73
0
            November => October,
74
0
            December => November,
75
        }
76
0
    }
77
78
    /// Get the next month.
79
    ///
80
    /// ```rust
81
    /// # use time::Month;
82
    /// assert_eq!(Month::January.next(), Month::February);
83
    /// ```
84
0
    pub const fn next(self) -> Self {
85
0
        match self {
86
0
            January => February,
87
0
            February => March,
88
0
            March => April,
89
0
            April => May,
90
0
            May => June,
91
0
            June => July,
92
0
            July => August,
93
0
            August => September,
94
0
            September => October,
95
0
            October => November,
96
0
            November => December,
97
0
            December => January,
98
        }
99
0
    }
100
}
101
102
impl fmt::Display for Month {
103
0
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
104
0
        f.write_str(match self {
105
0
            January => "January",
106
0
            February => "February",
107
0
            March => "March",
108
0
            April => "April",
109
0
            May => "May",
110
0
            June => "June",
111
0
            July => "July",
112
0
            August => "August",
113
0
            September => "September",
114
0
            October => "October",
115
0
            November => "November",
116
0
            December => "December",
117
        })
118
0
    }
119
}
120
121
impl FromStr for Month {
122
    type Err = error::InvalidVariant;
123
124
0
    fn from_str(s: &str) -> Result<Self, Self::Err> {
125
0
        match s {
126
0
            "January" => Ok(January),
127
0
            "February" => Ok(February),
128
0
            "March" => Ok(March),
129
0
            "April" => Ok(April),
130
0
            "May" => Ok(May),
131
0
            "June" => Ok(June),
132
0
            "July" => Ok(July),
133
0
            "August" => Ok(August),
134
0
            "September" => Ok(September),
135
0
            "October" => Ok(October),
136
0
            "November" => Ok(November),
137
0
            "December" => Ok(December),
138
0
            _ => Err(error::InvalidVariant),
139
        }
140
0
    }
141
}
142
143
impl From<Month> for u8 {
144
0
    fn from(month: Month) -> Self {
145
0
        month as _
146
0
    }
147
}
148
149
impl TryFrom<u8> for Month {
150
    type Error = error::ComponentRange;
151
152
0
    fn try_from(value: u8) -> Result<Self, Self::Error> {
153
0
        match NonZeroU8::new(value) {
154
0
            Some(value) => Self::from_number(value),
155
0
            None => Err(error::ComponentRange {
156
0
                name: "month",
157
0
                minimum: 1,
158
0
                maximum: 12,
159
0
                value: 0,
160
0
                conditional_range: false,
161
0
            }),
162
        }
163
0
    }
164
}