Skip to main content

ed_journals/modules/ship/models/ship_module/
module_class.rs

1use std::fmt::{Display, Formatter};
2use std::str::FromStr;
3
4use serde::Serialize;
5use thiserror::Error;
6
7use crate::modules::ship::{ArmorGrade, ArmorModule};
8
9/// The class of a module. Not all classes are available for every module.
10#[derive(Debug, Serialize, Clone, PartialEq)]
11pub enum ModuleClass {
12    A,
13    B,
14    C,
15    D,
16    E,
17    F,
18    G,
19    H,
20    I,
21
22    #[cfg(feature = "allow-unknown")]
23    #[cfg_attr(docsrs, doc(cfg(feature = "allow-unknown")))]
24    Unknown,
25}
26
27#[derive(Debug, Error)]
28pub enum ModuleClassError {
29    #[error("Unknown module class: {0}")]
30    UnknownModuleClass(u8),
31
32    #[error("Unknown module class string: '{0}'")]
33    UnknownModuleClassString(String),
34}
35
36impl TryFrom<u8> for ModuleClass {
37    type Error = ModuleClassError;
38
39    fn try_from(value: u8) -> Result<Self, Self::Error> {
40        match value {
41            5 => Ok(ModuleClass::A),
42            4 => Ok(ModuleClass::B),
43            3 => Ok(ModuleClass::C),
44            2 => Ok(ModuleClass::D),
45            1 => Ok(ModuleClass::E),
46
47            #[cfg(feature = "allow-unknown")]
48            _ => Ok(ModuleClass::Unknown),
49
50            #[cfg(not(feature = "allow-unknown"))]
51            _ => Err(ModuleClassError::UnknownModuleClass(value)),
52        }
53    }
54}
55
56impl FromStr for ModuleClass {
57    type Err = ModuleClassError;
58
59    fn from_str(s: &str) -> Result<Self, Self::Err> {
60        match s {
61            "A" | "a" => Ok(ModuleClass::A),
62            "B" | "b" => Ok(ModuleClass::B),
63            "C" | "c" => Ok(ModuleClass::C),
64            "D" | "d" => Ok(ModuleClass::D),
65            "E" | "e" => Ok(ModuleClass::E),
66            "F" | "f" => Ok(ModuleClass::F),
67            "G" | "g" => Ok(ModuleClass::G),
68            "H" | "h" => Ok(ModuleClass::H),
69            "I" | "i" => Ok(ModuleClass::I),
70
71            #[cfg(feature = "allow-unknown")]
72            _ => Ok(ModuleClass::Unknown),
73
74            #[cfg(not(feature = "allow-unknown"))]
75            _ => Err(ModuleClassError::UnknownModuleClassString(s.to_string())),
76        }
77    }
78}
79
80impl Display for ModuleClass {
81    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
82        write!(
83            f,
84            "{}",
85            match self {
86                ModuleClass::A => "A",
87                ModuleClass::B => "B",
88                ModuleClass::C => "C",
89                ModuleClass::D => "D",
90                ModuleClass::E => "E",
91                ModuleClass::F => "F",
92                ModuleClass::G => "G",
93                ModuleClass::H => "H",
94                ModuleClass::I => "I",
95
96                #[cfg(feature = "allow-unknown")]
97                ModuleClass::Unknown => "U",
98            }
99        )
100    }
101}
102
103impl From<&ArmorGrade> for ModuleClass {
104    fn from(value: &ArmorGrade) -> Self {
105        match value {
106            ArmorGrade::LightweightAlloy => ModuleClass::C,
107            ArmorGrade::ReinforcedAlloy => ModuleClass::B,
108            ArmorGrade::MilitaryGradeComposite => ModuleClass::A,
109            ArmorGrade::MirroredSurfaceComposite => ModuleClass::A,
110            ArmorGrade::ReactiveSurfaceComposite => ModuleClass::A,
111
112            #[cfg(feature = "allow-unknown")]
113            ArmorGrade::Unknown(_) => ModuleClass::Unknown,
114
115            #[cfg(feature = "allow-unknown")]
116            ArmorGrade::UnknownString(_) => ModuleClass::Unknown,
117        }
118    }
119}
120
121impl From<ArmorGrade> for ModuleClass {
122    fn from(value: ArmorGrade) -> Self {
123        (&value).into()
124    }
125}
126
127impl From<&ArmorModule> for ModuleClass {
128    fn from(value: &ArmorModule) -> Self {
129        (&value.grade).into()
130    }
131}
132
133impl From<ArmorModule> for ModuleClass {
134    fn from(value: ArmorModule) -> Self {
135        value.grade.into()
136    }
137}