cock_lib/
tier.rs

1use crate::{FromString, GetVariants};
2
3/// The [Tier] enum represents the grade given to a cock.
4#[derive(Debug, PartialEq, Clone, serde::Deserialize)]
5pub enum Tier {
6    S,
7    A,
8    B,
9    C,
10    D,
11    E,
12    F,
13}
14
15/// The [GetVariants] trait implementation for [Tier] returns a vector of the possible variants of [Tier].
16impl GetVariants for Tier {
17    fn get_variants() -> Vec<String> {
18        vec![
19            String::from("S"),
20            String::from("A"),
21            String::from("B"),
22            String::from("C"),
23            String::from("D"),
24            String::from("E"),
25            String::from("F"),
26        ]
27    }
28}
29
30/// The [FromString] trait implementation for [Tier] returns a variant of [Tier].
31impl FromString for Tier {
32    fn from_string(tier: &str) -> Tier {
33        match tier {
34            "S" => Tier::S,
35            "A" => Tier::A,
36            "B" => Tier::B,
37            "C" => Tier::C,
38            "D" => Tier::D,
39            "E" => Tier::E,
40            "F" => Tier::F,
41            _ => panic!("Invalid tier"),
42        }
43    }
44}
45
46/// The [std::fmt::Display] trait implementation for [Tier] returns a string representation of the [Tier] variant.
47impl std::fmt::Display for Tier {
48    /// Returns a string representation of the [Tier] variant.
49    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
50        match self {
51            Tier::S => write!(f, "S"),
52            Tier::A => write!(f, "A"),
53            Tier::B => write!(f, "B"),
54            Tier::C => write!(f, "C"),
55            Tier::D => write!(f, "D"),
56            Tier::E => write!(f, "E"),
57            Tier::F => write!(f, "F"),
58        }
59    }
60}
61
62#[cfg(test)]
63mod tests {
64    use super::*;
65
66    #[test]
67    fn test_tier() {
68        let s = Tier::S;
69        let a = Tier::A;
70        let b = Tier::B;
71        let c = Tier::C;
72        let d = Tier::D;
73        let e = Tier::E;
74        let f = Tier::F;
75
76        assert_eq!(s, Tier::S);
77        assert_eq!(a, Tier::A);
78        assert_eq!(b, Tier::B);
79        assert_eq!(c, Tier::C);
80        assert_eq!(d, Tier::D);
81        assert_eq!(e, Tier::E);
82        assert_eq!(f, Tier::F);
83    }
84}