fit_rust/protocol/
value.rs

Help
1//////////
2//// Value
3//////////
4
5#[derive(Clone, Debug, PartialEq)]
6pub enum Value {
7    U8(u8),
8    I8(i8),
9    U16(u16),
10    I16(i16),
11    U32(u32),
12    I32(i32),
13    Enum(&'static str),
14    String(String),
15    F32(f32),
16    F64(f64),
17    I64(i64),
18    U64(u64),
19    Time(u32),
20    ArrU8(Vec<u8>),
21    ArrU16(Vec<u16>),
22    ArrU32(Vec<u32>),
23    None,
24}
25
26#[allow(unused_must_use)]
27impl Value {
28    pub(super) fn rescale(&mut self, val: f32) {
29        match self {
30            Value::U8(mut inner) => {
31                let new_inner = f32::from(inner) * val;
32                std::mem::replace(&mut inner, new_inner as u8);
33            }
34            Value::I8(mut inner) => {
35                let new_inner = f32::from(inner) * val;
36                std::mem::replace(&mut inner, new_inner as i8);
37            }
38            Value::U16(mut inner) => {
39                let new_inner = f32::from(inner) * val;
40                std::mem::replace(&mut inner, new_inner as u16);
41            }
42            Value::I16(mut inner) => {
43                let new_inner = f32::from(inner) * val;
44                std::mem::replace(&mut inner, new_inner as i16);
45            }
46            Value::U32(mut inner) => {
47                let new_inner = inner as f32 * val;
48                std::mem::replace(&mut inner, new_inner as u32);
49            }
50            Value::I32(mut inner) => {
51                let new_inner = inner as f32 * val;
52                std::mem::replace(&mut inner, new_inner as i32);
53            }
54            _ => (),
55        }
56    }
57
58    pub(super) fn scale(&mut self, val: f32) {
59        match self {
60            Value::U8(mut inner) => {
61                let new_inner = f32::from(inner) / val;
62                std::mem::replace(&mut inner, new_inner as u8);
63            }
64            Value::I8(mut inner) => {
65                let new_inner = f32::from(inner) / val;
66                std::mem::replace(&mut inner, new_inner as i8);
67            }
68            Value::U16(mut inner) => {
69                let new_inner = f32::from(inner) / val;
70                std::mem::replace(&mut inner, new_inner as u16);
71            }
72            Value::I16(mut inner) => {
73                let new_inner = f32::from(inner) / val;
74                std::mem::replace(&mut inner, new_inner as i16);
75            }
76            Value::U32(mut inner) => {
77                let new_inner = inner as f32 / val;
78                std::mem::replace(&mut inner, new_inner as u32);
79            }
80            Value::I32(mut inner) => {
81                let new_inner = inner as f32 / val;
82                std::mem::replace(&mut inner, new_inner as i32);
83            }
84            _ => (),
85        }
86    }
87    pub(super) fn offset(&mut self, val: i16) {
88        match self {
89            Value::U8(mut inner) => {
90                let new_inner = i16::from(inner) - val;
91                std::mem::replace(&mut inner, new_inner as u8);
92            }
93            Value::I8(mut inner) => {
94                let new_inner = i16::from(inner) - val;
95                std::mem::replace(&mut inner, new_inner as i8);
96            }
97            Value::U16(mut inner) => {
98                let new_inner = inner as i16 - val;
99                std::mem::replace(&mut inner, new_inner as u16);
100            }
101            Value::I16(mut inner) => {
102                let new_inner = inner - val;
103                std::mem::replace(&mut inner, new_inner);
104            }
105            Value::U32(mut inner) => {
106                let new_inner = inner as i16 - val;
107                std::mem::replace(&mut inner, new_inner as u32);
108            }
109            Value::I32(mut inner) => {
110                let new_inner = inner as i16 - val;
111                std::mem::replace(&mut inner, i32::from(new_inner));
112            }
113            _ => (),
114        }
115    }
116
117    pub(super) fn reoffset(&mut self, val: i16) {
118        match self {
119            Value::U8(mut inner) => {
120                let new_inner = i16::from(inner) + val;
121                std::mem::replace(&mut inner, new_inner as u8);
122            }
123            Value::I8(mut inner) => {
124                let new_inner = i16::from(inner) + val;
125                std::mem::replace(&mut inner, new_inner as i8);
126            }
127            Value::U16(mut inner) => {
128                let new_inner = inner as i16 + val;
129                std::mem::replace(&mut inner, new_inner as u16);
130            }
131            Value::I16(mut inner) => {
132                let new_inner = inner + val;
133                std::mem::replace(&mut inner, new_inner);
134            }
135            Value::U32(mut inner) => {
136                let new_inner = inner as i16 + val;
137                std::mem::replace(&mut inner, new_inner as u32);
138            }
139            Value::I32(mut inner) => {
140                let new_inner = inner as i16 + val;
141                std::mem::replace(&mut inner, i32::from(new_inner));
142            }
143            _ => (),
144        }
145    }
146}
147
148impl From<Value> for i8 {
149    fn from(item: Value) -> Self {
150        match item {
151            Value::I8(v) => v,
152            _ => panic!("can't call this on a non-i8 variant"),
153        }
154    }
155}
156
157impl From<Value> for u8 {
158    fn from(item: Value) -> Self {
159        match item {
160            Value::U8(v) => v,
161            _ => panic!("can't call this on a non-u8 variant"),
162        }
163    }
164}
165
166impl From<Value> for i16 {
167    fn from(item: Value) -> Self {
168        match item {
169            Value::I16(v) => v,
170            _ => panic!("can't call this on a non-i16 variant"),
171        }
172    }
173}
174
175impl From<Value> for u16 {
176    fn from(item: Value) -> Self {
177        match item {
178            Value::U16(v) => v,
179            _ => panic!("can't call this on a non-u16 variant"),
180        }
181    }
182}
183
184impl From<Value> for i32 {
185    fn from(item: Value) -> Self {
186        match item {
187            Value::I32(v) => v,
188            _ => panic!("can't call this on a non-i32 variant"),
189        }
190    }
191}
192
193impl From<Value> for u32 {
194    fn from(item: Value) -> Self {
195        match item {
196            Value::U32(v) => v,
197            Value::Time(v) => v,
198            _ => panic!("can't call this on a non-u32 variant"),
199        }
200    }
201}
202
203impl From<Value> for f32 {
204    fn from(item: Value) -> Self {
205        match item {
206            Value::F32(v) => v,
207            _ => panic!("can't call this on a non-f32 variant"),
208        }
209    }
210}
211
212impl From<Value> for &str {
213    fn from(item: Value) -> Self {
214        match item {
215            Value::Enum(v) => v,
216            _ => panic!("can't call this on a non-str variant"),
217        }
218    }
219}
220
221impl From<Value> for String {
222    fn from(item: Value) -> Self {
223        match item {
224            Value::Enum(v) => v.into(),
225            Value::String(v) => v,
226            _ => panic!("can't call this on a non-String variant"),
227        }
228    }
229}
fit_rust/protocol/value.rs

fit_rust/protocol/
value.rs
