1use crate::model::{LengthUnit, Units};
4
5impl LengthUnit {
6 pub fn meters(self) -> Option<f64> {
8 Some(match self {
9 Self::Unitless | Self::Custom => return None,
10 Self::Inch => 0.0254,
11 Self::Foot => 0.3048,
12 Self::Mile => 1609.344,
13 Self::Millimeter => 0.001,
14 Self::Centimeter => 0.01,
15 Self::Meter => 1.0,
16 Self::Kilometer => 1000.0,
17 Self::Microinch => 2.54e-8,
18 Self::Mil => 2.54e-5,
19 Self::Yard => 0.9144,
20 Self::Angstrom => 1e-10,
21 Self::Nanometer => 1e-9,
22 Self::Micrometer => 1e-6,
23 Self::Decimeter => 0.1,
24 Self::Decameter => 10.0,
25 Self::Hectometer => 100.0,
26 Self::Gigameter => 1e9,
27 Self::AstronomicalUnit => 149_597_870_700.0,
28 Self::LightYear => 9_460_730_472_580_800.0,
29 Self::Parsec => 3.085_677_581_491_367e16,
30 Self::UsSurveyFoot => 1200.0 / 3937.0,
31 })
32 }
33
34 pub fn from_insunits(code: i32) -> Self {
36 match code {
37 1 => Self::Inch,
38 2 => Self::Foot,
39 3 => Self::Mile,
40 4 => Self::Millimeter,
41 5 => Self::Centimeter,
42 6 => Self::Meter,
43 7 => Self::Kilometer,
44 8 => Self::Microinch,
45 9 => Self::Mil,
46 10 => Self::Yard,
47 11 => Self::Angstrom,
48 12 => Self::Nanometer,
49 13 => Self::Micrometer,
50 14 => Self::Decimeter,
51 15 => Self::Decameter,
52 16 => Self::Hectometer,
53 17 => Self::Gigameter,
54 18 => Self::AstronomicalUnit,
55 19 => Self::LightYear,
56 20 => Self::Parsec,
57 21 => Self::UsSurveyFoot,
58 _ => Self::Unitless,
59 }
60 }
61
62 pub fn to_insunits(self) -> i32 {
64 match self {
65 Self::Unitless | Self::Custom => 0,
66 Self::Inch => 1,
67 Self::Foot => 2,
68 Self::Mile => 3,
69 Self::Millimeter => 4,
70 Self::Centimeter => 5,
71 Self::Meter => 6,
72 Self::Kilometer => 7,
73 Self::Microinch => 8,
74 Self::Mil => 9,
75 Self::Yard => 10,
76 Self::Angstrom => 11,
77 Self::Nanometer => 12,
78 Self::Micrometer => 13,
79 Self::Decimeter => 14,
80 Self::Decameter => 15,
81 Self::Hectometer => 16,
82 Self::Gigameter => 17,
83 Self::AstronomicalUnit => 18,
84 Self::LightYear => 19,
85 Self::Parsec => 20,
86 Self::UsSurveyFoot => 21,
87 }
88 }
89
90 pub const fn as_str(self) -> &'static str {
92 match self {
93 Self::Unitless => "unitless",
94 Self::Inch => "inch",
95 Self::Foot => "foot",
96 Self::Mile => "mile",
97 Self::Millimeter => "millimeter",
98 Self::Centimeter => "centimeter",
99 Self::Meter => "meter",
100 Self::Kilometer => "kilometer",
101 Self::Microinch => "microinch",
102 Self::Mil => "mil",
103 Self::Yard => "yard",
104 Self::Angstrom => "angstrom",
105 Self::Nanometer => "nanometer",
106 Self::Micrometer => "micrometer",
107 Self::Decimeter => "decimeter",
108 Self::Decameter => "decameter",
109 Self::Hectometer => "hectometer",
110 Self::Gigameter => "gigameter",
111 Self::AstronomicalUnit => "astronomical_unit",
112 Self::LightYear => "light_year",
113 Self::Parsec => "parsec",
114 Self::UsSurveyFoot => "us_survey_foot",
115 Self::Custom => "custom",
116 }
117 }
118
119 pub fn from_name(name: &str) -> Option<Self> {
121 let lower = name.trim().to_ascii_lowercase();
122 Some(match lower.as_str() {
123 "unitless" | "none" => Self::Unitless,
124 "in" | "inch" | "inches" => Self::Inch,
125 "ft" | "foot" | "feet" => Self::Foot,
126 "mi" | "mile" | "miles" => Self::Mile,
127 "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => Self::Millimeter,
128 "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => Self::Centimeter,
129 "m" | "meter" | "meters" | "metre" | "metres" => Self::Meter,
130 "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => Self::Kilometer,
131 "uin" | "microinch" | "microinches" => Self::Microinch,
132 "mil" | "mils" => Self::Mil,
133 "yd" | "yard" | "yards" => Self::Yard,
134 "angstrom" | "angstroms" => Self::Angstrom,
135 "nm" | "nanometer" | "nanometers" | "nanometre" | "nanometres" => Self::Nanometer,
136 "um" | "micrometer" | "micrometers" | "micrometre" | "micrometres" | "micron" => {
137 Self::Micrometer
138 }
139 "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => Self::Decimeter,
140 "dam" | "decameter" | "decameters" | "decametre" | "decametres" => Self::Decameter,
141 "hm" | "hectometer" | "hectometers" | "hectometre" | "hectometres" => Self::Hectometer,
142 "gm" | "gigameter" | "gigameters" | "gigametre" | "gigametres" => Self::Gigameter,
143 "au" | "astronomical_unit" | "astronomical-unit" => Self::AstronomicalUnit,
144 "ly" | "light_year" | "light-year" => Self::LightYear,
145 "pc" | "parsec" | "parsecs" => Self::Parsec,
146 "us_ft" | "us-ft" | "us_survey_foot" | "us-survey-foot" | "survey_foot" => {
147 Self::UsSurveyFoot
148 }
149 "custom" => Self::Custom,
150 _ => return None,
151 })
152 }
153}
154
155impl Units {
156 pub fn meters_per_unit(&self) -> Option<f64> {
159 match self.meters_per_unit {
160 Some(m) if m.is_finite() && m > 0.0 => Some(m),
161 _ => self.unit.meters(),
162 }
163 }
164
165 pub fn from_insunits(code: i32) -> Self {
168 match code {
169 22 => Self {
170 unit: LengthUnit::Custom,
171 meters_per_unit: Some(100.0 / 3937.0),
172 },
173 23 => Self {
174 unit: LengthUnit::Custom,
175 meters_per_unit: Some(3600.0 / 3937.0),
176 },
177 24 => Self {
178 unit: LengthUnit::Custom,
179 meters_per_unit: Some(6_336_000.0 / 3937.0),
180 },
181 _ => {
182 let unit = LengthUnit::from_insunits(code);
183 Self {
184 unit,
185 meters_per_unit: unit.meters(),
186 }
187 }
188 }
189 }
190
191 pub fn to_insunits(&self) -> i32 {
194 if self.unit == LengthUnit::Custom {
195 match self.meters_per_unit {
196 Some(m) if (m - 100.0 / 3937.0).abs() < 1e-9 => 22,
197 Some(m) if (m - 3600.0 / 3937.0).abs() < 1e-9 => 23,
198 Some(m) if (m - 6_336_000.0 / 3937.0).abs() < 1e-6 => 24,
199 _ => 0,
200 }
201 } else {
202 self.unit.to_insunits()
203 }
204 }
205}
206
207#[cfg(test)]
208mod tests {
209 use super::*;
210
211 #[test]
212 fn meters() {
213 assert_eq!(LengthUnit::Millimeter.meters(), Some(0.001));
214 assert_eq!(LengthUnit::Unitless.meters(), None);
215 assert_eq!(LengthUnit::Custom.meters(), None);
216 assert!((LengthUnit::Foot.meters().unwrap() - 0.3048).abs() < 1e-12);
217 }
218
219 #[test]
220 fn insunits_roundtrip() {
221 for code in 0..=21 {
222 assert_eq!(LengthUnit::from_insunits(code).to_insunits(), code);
223 }
224 for code in 0..=24 {
225 let u = Units::from_insunits(code);
226 assert_eq!(u.to_insunits(), code, "code {code} failed roundtrip");
227 if code >= 1 {
228 assert!(u.meters_per_unit().is_some());
229 }
230 }
231 assert_eq!(LengthUnit::from_insunits(99), LengthUnit::Unitless);
232 assert_eq!(LengthUnit::from_insunits(-1), LengthUnit::Unitless);
233 assert_eq!(Units::from_insunits(99).to_insunits(), 0);
234 assert_eq!(LengthUnit::Custom.to_insunits(), 0);
235 }
236
237 #[test]
238 fn explicit_field_preferred() {
239 let u = Units {
240 unit: LengthUnit::Meter,
241 meters_per_unit: Some(0.5),
242 };
243 assert_eq!(u.meters_per_unit(), Some(0.5));
244 let u = Units {
245 unit: LengthUnit::Meter,
246 meters_per_unit: None,
247 };
248 assert_eq!(u.meters_per_unit(), Some(1.0));
249 let u = Units {
250 unit: LengthUnit::Meter,
251 meters_per_unit: Some(f64::NAN),
252 };
253 assert_eq!(u.meters_per_unit(), Some(1.0));
254 let u = Units {
255 unit: LengthUnit::Custom,
256 meters_per_unit: Some(0.01),
257 };
258 assert_eq!(u.meters_per_unit(), Some(0.01));
259 assert_eq!(Units::default().meters_per_unit(), None);
260 }
261}