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
98
99
100
|
// Intended to emulate vim modes.
pub enum InputMode {
Normal, // Navigating the ui.
Insert, // Editing a parameter.
}
// A row in the inputs table has one of each variation.
#[derive(Clone)]
pub enum InputParam {
Rpm(String), // Revolutions per minute
Ve(String), // Volumetric efficiency
Map(String), // Manifold absolute pressure
}
impl InputParam {
/* Acts like the push() method of a Vec.
* Appends the given char to the end of the string contained by the
* InputParam.
*/
pub fn push(&mut self, c: char) {
match self {
Self::Rpm(rpm) => {
rpm.push(c);
*self = Self::Rpm(rpm.to_string());
}
Self::Ve(ve) => {
ve.push(c);
*self = Self::Ve(ve.to_string());
}
Self::Map(map) => {
map.push(c);
*self = Self::Map(map.to_string());
}
}
}
/* Acts like the pop() method of a Vec.
* Removes the last char from the string contained by the InputParam.
*/
pub fn pop(&mut self) {
match self {
Self::Rpm(rpm) => {
rpm.pop();
*self = Self::Rpm(rpm.to_string());
}
Self::Ve(ve) => {
ve.pop();
*self = Self::Rpm(ve.to_string());
}
Self::Map(map) => {
map.pop();
*self = Self::Map(map.to_string());
}
}
}
// Return a copy of the string contained by the InputParam.
pub fn string(&self) -> String {
match self {
Self::Rpm(rpm) => rpm.to_string(),
Self::Ve(ve) => ve.to_string(),
Self::Map(map) => map.to_string(),
}
}
/* 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(String::new()),
Self::Ve(_) => Self::Map(String::new()),
Self::Map(_) => Self::Rpm(String::new()),
}
}
pub fn previous(&self) -> Self {
match self {
Self::Rpm(_) => Self::Map(String::new()),
Self::Ve(_) => Self::Rpm(String::new()),
Self::Map(_) => Self::Ve(String::new()),
}
}
}
// 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 Default for Row {
fn default() -> Self {
Self {
rpm: InputParam::Rpm(String::from("7000")),
ve: InputParam::Ve(String::from("95")),
map: InputParam::Map(String::from("200")),
}
}
}
|