ed_journals/modules/ship/models/ship_module/
module_class.rs1use std::fmt::{Display, Formatter};
2use std::str::FromStr;
3
4use serde::Serialize;
5use thiserror::Error;
6
7use crate::modules::ship::{ArmorGrade, ArmorModule};
8
9#[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}