1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
use crate::unit_of_measurement::{
pressure::{Pressure, Unit::KiloPascal},
UnitOfMeasurement,
};
// A row in the inputs table has one of each variation.
#[derive(Clone)]
pub enum InputParam {
Rpm(u32), // Revolutions per minute
Ve(u32), // Volumetric efficiency
Map(Pressure), // Manifold absolute pressure
}
impl InputParam {
/* next() and previous() allow InputParam to act as a circular iterator of
* sorts. next() will return the next variation as they are defined. When
* it reaches the end, the first variation will be returned:
* RPM->VE->MAP->RPM->etc...
* previous() simply goes the opposite direction:
* MAP->VE->RPM->MAP->etc...
*/
pub fn next(&self) -> Self {
match self {
Self::Rpm(_) => Self::Ve(0),
Self::Ve(_) => Self::Map(Pressure::default()),
Self::Map(_) => Self::Rpm(0),
}
}
pub fn previous(&self) -> Self {
match self {
Self::Rpm(_) => Self::Map(Pressure::default()),
Self::Ve(_) => Self::Rpm(0),
Self::Map(_) => Self::Ve(0),
}
}
}
// A row in the inputs table. Contains one of each variation of InputParam.
#[derive(Clone)]
pub struct Row {
pub rpm: InputParam,
pub ve: InputParam,
pub map: InputParam,
}
impl Row {
pub fn iter(&self) -> RowIter {
RowIter::from_row(&self)
}
}
impl Default for Row {
fn default() -> Self {
Self {
rpm: InputParam::Rpm(7000),
ve: InputParam::Ve(95),
map: InputParam::Map(Pressure::from_unit(KiloPascal, 200)),
}
}
}
pub struct RowIter<'a> {
row: &'a Row,
iter_state: Option<InputParam>,
}
impl<'a> RowIter<'a> {
fn from_row(row: &'a Row) -> Self {
Self {
row: row,
iter_state: Some(InputParam::Rpm(0)),
}
}
}
impl<'a> Iterator for RowIter<'a> {
type Item = &'a InputParam;
fn next(&mut self) -> Option<Self::Item> {
match self.iter_state {
Some(InputParam::Rpm(_)) => {
self.iter_state = Some(InputParam::Ve(0));
Some(&self.row.rpm)
}
Some(InputParam::Ve(_)) => {
self.iter_state = Some(InputParam::Map(Pressure::default()));
Some(&self.row.ve)
}
Some(InputParam::Map(_)) => {
self.iter_state = None;
Some(&self.row.map)
}
None => None,
}
}
}
|