Skip to main content

workflow_log/
levels.rs

1///
2/// This enum is a replica of the Level and LevelFilter
3/// enums from the log crate : https://crates.io/crates/log
4///
5/// The original references can be found here:
6/// - https://docs.rs/log/latest/log/enum.Level.html
7/// - https://docs.rs/log/latest/log/enum.LevelFilter.html
8///
9/// This is embedded directly into this crate to to allow
10/// usage of log levels while retaining the ability to embed
11/// the log crate itself as an optional feature. This is done
12/// to accomodate reduced bytecode requirements of build
13/// targets such as BPF.
14///
15use std::cmp;
16
17/// An enumeration of the available verbosity levels of a log message,
18/// ordered from the most severe (`Error`) to the least severe (`Trace`).
19#[repr(usize)]
20#[derive(Copy, Eq, Debug)]
21pub enum Level {
22    /// The "error" level, designating very serious failures.
23    Error = 1,
24    /// The "warn" level, designating hazardous situations.
25    Warn,
26    /// The "info" level, designating useful informational messages.
27    Info,
28    /// The "debug" level, designating lower-priority diagnostic information.
29    Debug,
30    /// The "trace" level, designating very low-priority, verbose information.
31    Trace,
32}
33
34impl Clone for Level {
35    #[inline]
36    fn clone(&self) -> Level {
37        *self
38    }
39}
40
41impl PartialEq for Level {
42    #[inline]
43    fn eq(&self, other: &Level) -> bool {
44        *self as usize == *other as usize
45    }
46}
47
48impl PartialEq<LevelFilter> for Level {
49    #[inline]
50    fn eq(&self, other: &LevelFilter) -> bool {
51        *self as usize == *other as usize
52    }
53}
54
55impl PartialOrd for Level {
56    #[inline]
57    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
58        Some(self.cmp(other))
59    }
60
61    #[inline]
62    fn lt(&self, other: &Level) -> bool {
63        (*self as usize) < *other as usize
64    }
65
66    #[inline]
67    fn le(&self, other: &Level) -> bool {
68        *self as usize <= *other as usize
69    }
70
71    #[inline]
72    fn gt(&self, other: &Level) -> bool {
73        *self as usize > *other as usize
74    }
75
76    #[inline]
77    fn ge(&self, other: &Level) -> bool {
78        *self as usize >= *other as usize
79    }
80}
81
82impl PartialOrd<LevelFilter> for Level {
83    #[inline]
84    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
85        Some((*self as usize).cmp(&(*other as usize)))
86    }
87
88    #[inline]
89    fn lt(&self, other: &LevelFilter) -> bool {
90        (*self as usize) < *other as usize
91    }
92
93    #[inline]
94    fn le(&self, other: &LevelFilter) -> bool {
95        *self as usize <= *other as usize
96    }
97
98    #[inline]
99    fn gt(&self, other: &LevelFilter) -> bool {
100        *self as usize > *other as usize
101    }
102
103    #[inline]
104    fn ge(&self, other: &LevelFilter) -> bool {
105        *self as usize >= *other as usize
106    }
107}
108
109impl Ord for Level {
110    #[inline]
111    fn cmp(&self, other: &Level) -> cmp::Ordering {
112        (*self as usize).cmp(&(*other as usize))
113    }
114}
115
116/// An enumeration of the available log level filters, used to enable or
117/// suppress log messages at or below a given [`Level`]. Includes an `Off`
118/// variant that disables all logging.
119#[repr(usize)]
120#[derive(Copy, Eq, Debug)]
121pub enum LevelFilter {
122    /// A level lower than all log levels.
123    Off,
124    /// Corresponds to the `Error` log level.
125    Error,
126    /// Corresponds to the `Warn` log level.
127    Warn,
128    /// Corresponds to the `Info` log level.
129    Info,
130    /// Corresponds to the `Debug` log level.
131    Debug,
132    /// Corresponds to the `Trace` log level.
133    Trace,
134}
135
136// Deriving generates terrible impls of these traits
137
138impl Clone for LevelFilter {
139    #[inline]
140    fn clone(&self) -> LevelFilter {
141        *self
142    }
143}
144
145impl PartialEq for LevelFilter {
146    #[inline]
147    fn eq(&self, other: &LevelFilter) -> bool {
148        *self as usize == *other as usize
149    }
150}
151
152impl PartialEq<Level> for LevelFilter {
153    #[inline]
154    fn eq(&self, other: &Level) -> bool {
155        other.eq(self)
156    }
157}
158
159impl PartialOrd for LevelFilter {
160    #[inline]
161    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
162        Some(self.cmp(other))
163    }
164
165    #[inline]
166    fn lt(&self, other: &LevelFilter) -> bool {
167        (*self as usize) < *other as usize
168    }
169
170    #[inline]
171    fn le(&self, other: &LevelFilter) -> bool {
172        *self as usize <= *other as usize
173    }
174
175    #[inline]
176    fn gt(&self, other: &LevelFilter) -> bool {
177        *self as usize > *other as usize
178    }
179
180    #[inline]
181    fn ge(&self, other: &LevelFilter) -> bool {
182        *self as usize >= *other as usize
183    }
184}
185
186impl PartialOrd<Level> for LevelFilter {
187    #[inline]
188    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
189        Some((*self as usize).cmp(&(*other as usize)))
190    }
191
192    #[inline]
193    fn lt(&self, other: &Level) -> bool {
194        (*self as usize) < *other as usize
195    }
196
197    #[inline]
198    fn le(&self, other: &Level) -> bool {
199        *self as usize <= *other as usize
200    }
201
202    #[inline]
203    fn gt(&self, other: &Level) -> bool {
204        *self as usize > *other as usize
205    }
206
207    #[inline]
208    fn ge(&self, other: &Level) -> bool {
209        *self as usize >= *other as usize
210    }
211}
212
213impl Ord for LevelFilter {
214    #[inline]
215    fn cmp(&self, other: &LevelFilter) -> cmp::Ordering {
216        (*self as usize).cmp(&(*other as usize))
217    }
218}